文件操作 - babel.js

文件: /var/www/OLD/node_modules/@babel/standalone/babel.js

编辑文件内容

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Babel = {}));
})(this, (function (exports) { 'use strict';

var global$1 = (typeof global !== "undefined" ? global :
    typeof self !== "undefined" ? self :
    typeof window !== "undefined" ? window : {});

// shim for using process in browser
  // based off https://github.com/defunctzombie/node-process/blob/master/browser.js

}
  function runClearTimeout(marker) {
      if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
      }
      // if clearTimeout wasn't available but was latter defined
      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
      } catch (e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
              return cachedClearTimeout.call(null, marker);
          } catch (e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
              // Some versions of I.E. have different rules for clearTimeout vs setTimeout
              return cachedClearTimeout.call(this, marker);
          }
      }

}
  var queue = [];
  var draining = false;
  var currentQueue;
  var queueIndex = -1;

function drainQueue() {
      if (draining) {
          return;
      }
      var timeout = runTimeout(cleanUpNextTick);
      draining = true;

function noop$2() {}

var on = noop$2;
  var addListener = noop$2;
  var once$1 = noop$2;
  var off = noop$2;
  var removeListener = noop$2;
  var removeAllListeners = noop$2;
  var emit$1 = noop$2;

function binding(name) {
      throw new Error('process.binding is not supported');
  }

function cwd () { return '/' }
  function chdir (dir) {
      throw new Error('process.chdir is not supported');
  }function umask() { return 0; }

// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js
  var performance = global$1.performance || {};
  var performanceNow =
    performance.now        ||
    performance.mozNow     ||
    performance.msNow      ||
    performance.oNow       ||
    performance.webkitNow  ||
    function(){ return (new Date()).getTime() };

// generate timestamp or delta
  // see http://nodejs.org/api/process.html#process_process_hrtime
  function hrtime(previousTimestamp){
    var clocktime = performanceNow.call(performance)*1e-3;
    var seconds = Math.floor(clocktime);
    var nanoseconds = Math.floor((clocktime%1)*1e9);
    if (previousTimestamp) {
      seconds = seconds - previousTimestamp[0];
      nanoseconds = nanoseconds - previousTimestamp[1];
      if (nanoseconds<0) {
        seconds--;
        nanoseconds += 1e9;
      }
    }
    return [seconds,nanoseconds]
  }

var startTime = new Date();
  function uptime() {
    var currentTime = new Date();
    var dif = currentTime - startTime;
    return dif / 1000;
  }

var browser$1$1 = {
    nextTick: nextTick,
    title: title,
    browser: browser$3,
    env: env$1,
    argv: argv,
    version: version$2,
    versions: versions$2,
    on: on,
    addListener: addListener,
    once: once$1,
    off: off,
    removeListener: removeListener,
    removeAllListeners: removeAllListeners,
    emit: emit$1,
    binding: binding,
    cwd: cwd,
    chdir: chdir,
    umask: umask,
    hrtime: hrtime,
    platform: platform,
    release: release,
    config: config$1,
    uptime: uptime
  };

function buildMatchMemberExpression$1(match, allowPartial) {
    var parts = match.split(".");
    return function (member) {
      return matchesPattern$2(member, parts, allowPartial);
    };
  }

var isReactComponent = buildMatchMemberExpression$1("React.Component");

function isCompatTag$1(tagName) {
    return !!tagName && /^[a-z]/.test(tagName);
  }

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

defineType$5("ArgumentPlaceholder", {});
  defineType$5("BindExpression", {
    visitor: ["object", "callee"],
    aliases: ["Expression"],
    fields: !browser$1$1.env.BABEL_TYPES_8_BREAKING ? {
      object: {
        validate: Object.assign(function () {}, {
          oneOfNodeTypes: ["Expression"]
        })
      },
      callee: {
        validate: Object.assign(function () {}, {
          oneOfNodeTypes: ["Expression"]
        })
      }
    } : {
      object: {
        validate: assertNodeType("Expression")
      },
      callee: {
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$5("ImportAttribute", {
    visitor: ["key", "value"],
    fields: {
      key: {
        validate: assertNodeType("Identifier", "StringLiteral")
      },
      value: {
        validate: assertNodeType("StringLiteral")
      }
    }
  });
  defineType$5("Decorator", {
    visitor: ["expression"],
    fields: {
      expression: {
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$5("DoExpression", {
    visitor: ["body"],
    builder: ["body", "async"],
    aliases: ["Expression"],
    fields: {
      body: {
        validate: assertNodeType("BlockStatement")
      },
      async: {
        validate: assertValueType("boolean"),
        "default": false
      }
    }
  });
  defineType$5("ExportDefaultSpecifier", {
    visitor: ["exported"],
    aliases: ["ModuleSpecifier"],
    fields: {
      exported: {
        validate: assertNodeType("Identifier")
      }
    }
  });
  defineType$5("RecordExpression", {
    visitor: ["properties"],
    aliases: ["Expression"],
    fields: {
      properties: validateArrayOfType("ObjectProperty", "SpreadElement")
    }
  });
  defineType$5("TupleExpression", {
    fields: {
      elements: {
        validate: arrayOfType("Expression", "SpreadElement"),
        "default": []
      }
    },
    visitor: ["elements"],
    aliases: ["Expression"]
  });
  {
    defineType$5("DecimalLiteral", {
      builder: ["value"],
      fields: {
        value: {
          validate: assertValueType("string")
        }
      },
      aliases: ["Expression", "Pureish", "Literal", "Immutable"]
    });
  }
  defineType$5("ModuleExpression", {
    visitor: ["body"],
    fields: {
      body: {
        validate: assertNodeType("Program")
      }
    },
    aliases: ["Expression"]
  });
  defineType$5("TopicReference", {
    aliases: ["Expression"]
  });
  defineType$5("PipelineTopicExpression", {
    builder: ["expression"],
    visitor: ["expression"],
    fields: {
      expression: {
        validate: assertNodeType("Expression")
      }
    },
    aliases: ["Expression"]
  });
  defineType$5("PipelineBareFunction", {
    builder: ["callee"],
    visitor: ["callee"],
    fields: {
      callee: {
        validate: assertNodeType("Expression")
      }
    },
    aliases: ["Expression"]
  });
  defineType$5("PipelinePrimaryTopicReference", {
    aliases: ["Expression"]
  });

var _fields, _fields2, _fields3, _fields4;
  var defineType = defineAliasedType("TypeScript");
  var bool$a = assertValueType("boolean");
  var tSFunctionTypeAnnotationCommon = function tSFunctionTypeAnnotationCommon() {
    return {
      returnType: {
        validate: assertNodeType("TSTypeAnnotation", "Noop"),
        optional: true
      },
      typeParameters: {
        validate: assertNodeType("TSTypeParameterDeclaration", "Noop"),
        optional: true
      }
    };
  };
  defineType("TSParameterProperty", {
    aliases: ["LVal"],
    visitor: ["parameter"],
    fields: {
      accessibility: {
        validate: assertOneOf("public", "private", "protected"),
        optional: true
      },
      readonly: {
        validate: assertValueType("boolean"),
        optional: true
      },
      parameter: {
        validate: assertNodeType("Identifier", "AssignmentPattern")
      },
      override: {
        validate: assertValueType("boolean"),
        optional: true
      },
      decorators: {
        validate: arrayOfType("Decorator"),
        optional: true
      }
    }
  });
  defineType("TSDeclareFunction", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "typeParameters", "params", "returnType"],
    fields: Object.assign({}, functionDeclarationCommon(), tSFunctionTypeAnnotationCommon())
  });
  defineType("TSDeclareMethod", {
    visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
    fields: Object.assign({}, classMethodOrDeclareMethodCommon(), tSFunctionTypeAnnotationCommon())
  });
  defineType("TSQualifiedName", {
    aliases: ["TSEntityName"],
    visitor: ["left", "right"],
    fields: {
      left: validateType("TSEntityName"),
      right: validateType("Identifier")
    }
  });
  var signatureDeclarationCommon = function signatureDeclarationCommon() {
    var _ref;
    return _ref = {
      typeParameters: validateOptionalType("TSTypeParameterDeclaration")
    }, _ref["parameters"] = validateArrayOfType("ArrayPattern", "Identifier", "ObjectPattern", "RestElement"), _ref["typeAnnotation"] = validateOptionalType("TSTypeAnnotation"), _ref;
  };
  var callConstructSignatureDeclaration = {
    aliases: ["TSTypeElement"],
    visitor: ["typeParameters", "parameters", "typeAnnotation"],
    fields: signatureDeclarationCommon()
  };
  defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
  defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
  var namedTypeElementCommon = function namedTypeElementCommon() {
    return {
      key: validateType("Expression"),
      computed: {
        "default": false
      },
      optional: validateOptional(bool$a)
    };
  };
  defineType("TSPropertySignature", {
    aliases: ["TSTypeElement"],
    visitor: ["key", "typeAnnotation"],
    fields: Object.assign({}, namedTypeElementCommon(), {
      readonly: validateOptional(bool$a),
      typeAnnotation: validateOptionalType("TSTypeAnnotation"),
      kind: {
        validate: assertOneOf("get", "set")
      }
    })
  });
  defineType("TSMethodSignature", {
    aliases: ["TSTypeElement"],
    visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
    fields: Object.assign({}, signatureDeclarationCommon(), namedTypeElementCommon(), {
      kind: {
        validate: assertOneOf("method", "get", "set")
      }
    })
  });
  defineType("TSIndexSignature", {
    aliases: ["TSTypeElement"],
    visitor: ["parameters", "typeAnnotation"],
    fields: {
      readonly: validateOptional(bool$a),
      "static": validateOptional(bool$a),
      parameters: validateArrayOfType("Identifier"),
      typeAnnotation: validateOptionalType("TSTypeAnnotation")
    }
  });
  var tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"];
  for (var _i$1 = 0, _tsKeywordTypes = tsKeywordTypes; _i$1 < _tsKeywordTypes.length; _i$1++) {
    var type$1 = _tsKeywordTypes[_i$1];
    defineType(type$1, {
      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": validateOptional(bool$a)
    })
  }));
  defineType("TSTypeReference", {
    aliases: ["TSType"],
    visitor: ["typeName", "typeParameters"],
    fields: (_fields = {
      typeName: validateType("TSEntityName")
    }, _fields["typeParameters"] = validateOptionalType("TSTypeParameterInstantiation"), _fields)
  });
  defineType("TSTypePredicate", {
    aliases: ["TSType"],
    visitor: ["parameterName", "typeAnnotation"],
    builder: ["parameterName", "typeAnnotation", "asserts"],
    fields: {
      parameterName: validateType("Identifier", "TSThisType"),
      typeAnnotation: validateOptionalType("TSTypeAnnotation"),
      asserts: validateOptional(bool$a)
    }
  });
  defineType("TSTypeQuery", {
    aliases: ["TSType"],
    visitor: ["exprName", "typeParameters"],
    fields: (_fields2 = {
      exprName: validateType("TSEntityName", "TSImportType")
    }, _fields2["typeParameters"] = validateOptionalType("TSTypeParameterInstantiation"), _fields2)
  });
  defineType("TSTypeLiteral", {
    aliases: ["TSType"],
    visitor: ["members"],
    fields: {
      members: validateArrayOfType("TSTypeElement")
    }
  });
  defineType("TSArrayType", {
    aliases: ["TSType"],
    visitor: ["elementType"],
    fields: {
      elementType: validateType("TSType")
    }
  });
  defineType("TSTupleType", {
    aliases: ["TSType"],
    visitor: ["elementTypes"],
    fields: {
      elementTypes: validateArrayOfType("TSType", "TSNamedTupleMember")
    }
  });
  defineType("TSOptionalType", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: validateType("TSType")
    }
  });
  defineType("TSRestType", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: validateType("TSType")
    }
  });
  defineType("TSNamedTupleMember", {
    visitor: ["label", "elementType"],
    builder: ["label", "elementType", "optional"],
    fields: {
      label: validateType("Identifier"),
      optional: {
        validate: bool$a,
        "default": false
      },
      elementType: validateType("TSType")
    }
  });
  var unionOrIntersection = {
    aliases: ["TSType"],
    visitor: ["types"],
    fields: {
      types: validateArrayOfType("TSType")
    }
  };
  defineType("TSUnionType", unionOrIntersection);
  defineType("TSIntersectionType", unionOrIntersection);
  defineType("TSConditionalType", {
    aliases: ["TSType"],
    visitor: ["checkType", "extendsType", "trueType", "falseType"],
    fields: {
      checkType: validateType("TSType"),
      extendsType: validateType("TSType"),
      trueType: validateType("TSType"),
      falseType: validateType("TSType")
    }
  });
  defineType("TSInferType", {
    aliases: ["TSType"],
    visitor: ["typeParameter"],
    fields: {
      typeParameter: validateType("TSTypeParameter")
    }
  });
  defineType("TSParenthesizedType", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: validateType("TSType")
    }
  });
  defineType("TSTypeOperator", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    fields: {
      operator: validate$7(assertValueType("string")),
      typeAnnotation: validateType("TSType")
    }
  });
  defineType("TSIndexedAccessType", {
    aliases: ["TSType"],
    visitor: ["objectType", "indexType"],
    fields: {
      objectType: validateType("TSType"),
      indexType: validateType("TSType")
    }
  });
  defineType("TSMappedType", {
    aliases: ["TSType"],
    visitor: ["typeParameter", "nameType", "typeAnnotation"],
    builder: ["typeParameter", "typeAnnotation", "nameType"],
    fields: Object.assign({}, {
      typeParameter: validateType("TSTypeParameter")
    }, {
      readonly: validateOptional(assertOneOf(true, false, "+", "-")),
      optional: validateOptional(assertOneOf(true, false, "+", "-")),
      typeAnnotation: validateOptionalType("TSType"),
      nameType: validateOptionalType("TSType")
    })
  });
  defineType("TSLiteralType", {
    aliases: ["TSType", "TSBaseType"],
    visitor: ["literal"],
    fields: {
      literal: {
        validate: function () {
          var unaryExpression = assertNodeType("NumericLiteral", "BigIntLiteral");
          var unaryOperator = assertOneOf("-");
          var literal = assertNodeType("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral");
          function validator(parent, key, node) {
            if (is("UnaryExpression", node)) {
              unaryOperator(node, "operator", node.operator);
              unaryExpression(node, "argument", node.argument);
            } else {
              literal(parent, key, node);
            }
          }
          validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral", "UnaryExpression"];
          return validator;
        }()
      }
    }
  });
  {
    defineType("TSExpressionWithTypeArguments", {
      aliases: ["TSType"],
      visitor: ["expression", "typeParameters"],
      fields: {
        expression: validateType("TSEntityName"),
        typeParameters: validateOptionalType("TSTypeParameterInstantiation")
      }
    });
  }
  defineType("TSInterfaceDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "typeParameters", "extends", "body"],
    fields: {
      declare: validateOptional(bool$a),
      id: validateType("Identifier"),
      typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
      "extends": validateOptional(arrayOfType("TSExpressionWithTypeArguments")),
      body: validateType("TSInterfaceBody")
    }
  });
  defineType("TSInterfaceBody", {
    visitor: ["body"],
    fields: {
      body: validateArrayOfType("TSTypeElement")
    }
  });
  defineType("TSTypeAliasDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "typeParameters", "typeAnnotation"],
    fields: {
      declare: validateOptional(bool$a),
      id: validateType("Identifier"),
      typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
      typeAnnotation: validateType("TSType")
    }
  });
  defineType("TSInstantiationExpression", {
    aliases: ["Expression"],
    visitor: ["expression", "typeParameters"],
    fields: (_fields3 = {
      expression: validateType("Expression")
    }, _fields3["typeParameters"] = validateOptionalType("TSTypeParameterInstantiation"), _fields3)
  });
  var TSTypeExpression$1 = {
    aliases: ["Expression", "LVal", "PatternLike"],
    visitor: ["expression", "typeAnnotation"],
    fields: {
      expression: validateType("Expression"),
      typeAnnotation: validateType("TSType")
    }
  };
  defineType("TSAsExpression", TSTypeExpression$1);
  defineType("TSSatisfiesExpression", TSTypeExpression$1);
  defineType("TSTypeAssertion", {
    aliases: ["Expression", "LVal", "PatternLike"],
    visitor: ["typeAnnotation", "expression"],
    fields: {
      typeAnnotation: validateType("TSType"),
      expression: validateType("Expression")
    }
  });
  defineType("TSEnumBody", {
    visitor: ["members"],
    fields: {
      members: validateArrayOfType("TSEnumMember")
    }
  });
  {
    defineType("TSEnumDeclaration", {
      aliases: ["Statement", "Declaration"],
      visitor: ["id", "members"],
      fields: {
        declare: validateOptional(bool$a),
        "const": validateOptional(bool$a),
        id: validateType("Identifier"),
        members: validateArrayOfType("TSEnumMember"),
        initializer: validateOptionalType("Expression"),
        body: validateOptionalType("TSEnumBody")
      }
    });
  }
  defineType("TSEnumMember", {
    visitor: ["id", "initializer"],
    fields: {
      id: validateType("Identifier", "StringLiteral"),
      initializer: validateOptionalType("Expression")
    }
  });
  defineType("TSModuleDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "body"],
    fields: Object.assign({
      kind: {
        validate: assertOneOf("global", "module", "namespace")
      },
      declare: validateOptional(bool$a)
    }, {
      global: validateOptional(bool$a)
    }, {
      id: validateType("Identifier", "StringLiteral"),
      body: validateType("TSModuleBlock", "TSModuleDeclaration")
    })
  });
  defineType("TSModuleBlock", {
    aliases: ["Scopable", "Block", "BlockParent", "FunctionParent"],
    visitor: ["body"],
    fields: {
      body: validateArrayOfType("Statement")
    }
  });
  defineType("TSImportType", {
    aliases: ["TSType"],
    builder: ["argument", "qualifier", "typeParameters"],
    visitor: ["argument", "options", "qualifier", "typeParameters"],
    fields: (_fields4 = {
      argument: validateType("StringLiteral"),
      qualifier: validateOptionalType("TSEntityName")
    }, _fields4["typeParameters"] = validateOptionalType("TSTypeParameterInstantiation"), _fields4.options = {
      validate: assertNodeType("Expression"),
      optional: true
    }, _fields4)
  });
  defineType("TSImportEqualsDeclaration", {
    aliases: ["Statement"],
    visitor: ["id", "moduleReference"],
    fields: {
      isExport: validate$7(bool$a),
      id: validateType("Identifier"),
      moduleReference: validateType("TSEntityName", "TSExternalModuleReference"),
      importKind: {
        validate: assertOneOf("type", "value"),
        optional: true
      }
    }
  });
  defineType("TSExternalModuleReference", {
    visitor: ["expression"],
    fields: {
      expression: validateType("StringLiteral")
    }
  });
  defineType("TSNonNullExpression", {
    aliases: ["Expression", "LVal", "PatternLike"],
    visitor: ["expression"],
    fields: {
      expression: validateType("Expression")
    }
  });
  defineType("TSExportAssignment", {
    aliases: ["Statement"],
    visitor: ["expression"],
    fields: {
      expression: validateType("Expression")
    }
  });
  defineType("TSNamespaceExportDeclaration", {
    aliases: ["Statement"],
    visitor: ["id"],
    fields: {
      id: validateType("Identifier")
    }
  });
  defineType("TSTypeAnnotation", {
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: {
        validate: assertNodeType("TSType")
      }
    }
  });
  defineType("TSTypeParameterInstantiation", {
    visitor: ["params"],
    fields: {
      params: validateArrayOfType("TSType")
    }
  });
  defineType("TSTypeParameterDeclaration", {
    visitor: ["params"],
    fields: {
      params: validateArrayOfType("TSTypeParameter")
    }
  });
  defineType("TSTypeParameter", {
    builder: ["constraint", "default", "name"],
    visitor: ["constraint", "default"],
    fields: {
      name: {
        validate: assertValueType("string")
      },
      "in": {
        validate: assertValueType("boolean"),
        optional: true
      },
      out: {
        validate: assertValueType("boolean"),
        optional: true
      },
      "const": {
        validate: assertValueType("boolean"),
        optional: true
      },
      constraint: {
        validate: assertNodeType("TSType"),
        optional: true
      },
      "default": {
        validate: assertNodeType("TSType"),
        optional: true
      }
    }
  });

var DEPRECATED_ALIASES$1 = {
    ModuleDeclaration: "ImportOrExportDeclaration"
  };

Object.keys(DEPRECATED_ALIASES$1).forEach(function (deprecatedAlias) {
    FLIPPED_ALIAS_KEYS$3[deprecatedAlias] = FLIPPED_ALIAS_KEYS$3[DEPRECATED_ALIASES$1[deprecatedAlias]];
  });
  var TYPES$1 = [].concat(Object.keys(VISITOR_KEYS$7), Object.keys(FLIPPED_ALIAS_KEYS$3), Object.keys(DEPRECATED_KEYS$1));

function isNode(node) {
    return !!(node && VISITOR_KEYS$7[node.type]);
  }

function assertNode(node) {
    if (!isNode(node)) {
      var _node$type;
      var type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);
      throw new TypeError("Not a valid node of type \"" + type + "\"");
    }
  }

function createTypeAnnotationBasedOnTypeof$1(type) {
    switch (type) {
      case "string":
        return stringTypeAnnotation$2();
      case "number":
        return numberTypeAnnotation$2();
      case "undefined":
        return voidTypeAnnotation$3();
      case "boolean":
        return booleanTypeAnnotation$1();
      case "function":
        return genericTypeAnnotation$1(identifier$d("Function"));
      case "object":
        return genericTypeAnnotation$1(identifier$d("Object"));
      case "symbol":
        return genericTypeAnnotation$1(identifier$d("Symbol"));
      case "bigint":
        return anyTypeAnnotation$2();
    }
    throw new Error("Invalid typeof value: " + type);
  }

function buildUndefinedNode$2() {
    return unaryExpression$4("void", numericLiteral$5(0), true);
  }

function clone(node) {
    return cloneNode$e(node, false);
  }

function cloneDeep$1(node) {
    return cloneNode$e(node);
  }

function cloneDeepWithoutLoc(node) {
    return cloneNode$e(node, true, true);
  }

function cloneWithoutLoc(node) {
    return cloneNode$e(node, false, true);
  }

function addComment$2(node, type, content, line) {
    return addComments$1(node, type, [{
      type: line ? "CommentLine" : "CommentBlock",
      value: content
    }]);
  }

function inherit(key, child, parent) {
    if (child && parent) {
      child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean)));
    }
  }

function inheritInnerComments(child, parent) {
    inherit("innerComments", child, parent);
  }

function inheritLeadingComments$1(child, parent) {
    inherit("leadingComments", child, parent);
  }

function inheritTrailingComments$1(child, parent) {
    inherit("trailingComments", child, parent);
  }

function inheritsComments$1(child, parent) {
    inheritTrailingComments$1(child, parent);
    inheritLeadingComments$1(child, parent);
    inheritInnerComments(child, parent);
    return child;
  }

function removeComments$1(node) {
    COMMENT_KEYS.forEach(function (key) {
      node[key] = null;
    });
    return node;
  }

var STANDARDIZED_TYPES = FLIPPED_ALIAS_KEYS$3["Standardized"];
  var EXPRESSION_TYPES = FLIPPED_ALIAS_KEYS$3["Expression"];
  var BINARY_TYPES = FLIPPED_ALIAS_KEYS$3["Binary"];
  var SCOPABLE_TYPES = FLIPPED_ALIAS_KEYS$3["Scopable"];
  var BLOCKPARENT_TYPES = FLIPPED_ALIAS_KEYS$3["BlockParent"];
  var BLOCK_TYPES = FLIPPED_ALIAS_KEYS$3["Block"];
  var STATEMENT_TYPES = FLIPPED_ALIAS_KEYS$3["Statement"];
  var TERMINATORLESS_TYPES = FLIPPED_ALIAS_KEYS$3["Terminatorless"];
  var COMPLETIONSTATEMENT_TYPES = FLIPPED_ALIAS_KEYS$3["CompletionStatement"];
  var CONDITIONAL_TYPES = FLIPPED_ALIAS_KEYS$3["Conditional"];
  var LOOP_TYPES = FLIPPED_ALIAS_KEYS$3["Loop"];
  var WHILE_TYPES = FLIPPED_ALIAS_KEYS$3["While"];
  var EXPRESSIONWRAPPER_TYPES = FLIPPED_ALIAS_KEYS$3["ExpressionWrapper"];
  var FOR_TYPES = FLIPPED_ALIAS_KEYS$3["For"];
  var FORXSTATEMENT_TYPES = FLIPPED_ALIAS_KEYS$3["ForXStatement"];
  var FUNCTION_TYPES$1 = FLIPPED_ALIAS_KEYS$3["Function"];
  var FUNCTIONPARENT_TYPES = FLIPPED_ALIAS_KEYS$3["FunctionParent"];
  var PUREISH_TYPES = FLIPPED_ALIAS_KEYS$3["Pureish"];
  var DECLARATION_TYPES = FLIPPED_ALIAS_KEYS$3["Declaration"];
  var PATTERNLIKE_TYPES = FLIPPED_ALIAS_KEYS$3["PatternLike"];
  var LVAL_TYPES = FLIPPED_ALIAS_KEYS$3["LVal"];
  var TSENTITYNAME_TYPES = FLIPPED_ALIAS_KEYS$3["TSEntityName"];
  var LITERAL_TYPES = FLIPPED_ALIAS_KEYS$3["Literal"];
  var IMMUTABLE_TYPES = FLIPPED_ALIAS_KEYS$3["Immutable"];
  var USERWHITESPACABLE_TYPES = FLIPPED_ALIAS_KEYS$3["UserWhitespacable"];
  var METHOD_TYPES = FLIPPED_ALIAS_KEYS$3["Method"];
  var OBJECTMEMBER_TYPES = FLIPPED_ALIAS_KEYS$3["ObjectMember"];
  var PROPERTY_TYPES = FLIPPED_ALIAS_KEYS$3["Property"];
  var UNARYLIKE_TYPES = FLIPPED_ALIAS_KEYS$3["UnaryLike"];
  var PATTERN_TYPES = FLIPPED_ALIAS_KEYS$3["Pattern"];
  var CLASS_TYPES = FLIPPED_ALIAS_KEYS$3["Class"];
  var IMPORTOREXPORTDECLARATION_TYPES = FLIPPED_ALIAS_KEYS$3["ImportOrExportDeclaration"];
  var EXPORTDECLARATION_TYPES = FLIPPED_ALIAS_KEYS$3["ExportDeclaration"];
  var MODULESPECIFIER_TYPES = FLIPPED_ALIAS_KEYS$3["ModuleSpecifier"];
  var ACCESSOR_TYPES = FLIPPED_ALIAS_KEYS$3["Accessor"];
  var PRIVATE_TYPES = FLIPPED_ALIAS_KEYS$3["Private"];
  var FLOW_TYPES = FLIPPED_ALIAS_KEYS$3["Flow"];
  var FLOWTYPE_TYPES = FLIPPED_ALIAS_KEYS$3["FlowType"];
  var FLOWBASEANNOTATION_TYPES = FLIPPED_ALIAS_KEYS$3["FlowBaseAnnotation"];
  var FLOWDECLARATION_TYPES = FLIPPED_ALIAS_KEYS$3["FlowDeclaration"];
  var FLOWPREDICATE_TYPES = FLIPPED_ALIAS_KEYS$3["FlowPredicate"];
  var ENUMBODY_TYPES = FLIPPED_ALIAS_KEYS$3["EnumBody"];
  var ENUMMEMBER_TYPES = FLIPPED_ALIAS_KEYS$3["EnumMember"];
  var JSX_TYPES = FLIPPED_ALIAS_KEYS$3["JSX"];
  var MISCELLANEOUS_TYPES = FLIPPED_ALIAS_KEYS$3["Miscellaneous"];
  var TYPESCRIPT_TYPES = FLIPPED_ALIAS_KEYS$3["TypeScript"];
  var TSTYPEELEMENT_TYPES = FLIPPED_ALIAS_KEYS$3["TSTypeElement"];
  var TSTYPE_TYPES = FLIPPED_ALIAS_KEYS$3["TSType"];
  var TSBASETYPE_TYPES = FLIPPED_ALIAS_KEYS$3["TSBaseType"];
  var MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;

function ensureBlock$1(node, key) {
    if (key === void 0) {
      key = "body";
    }
    var result = toBlock(node[key], node);
    node[key] = result;
    return result;
  }

function toBindingIdentifierName$1(name) {
    name = toIdentifier$1(name);
    if (name === "eval" || name === "arguments") name = "_" + name;
    return name;
  }

function toComputedKey$1(node, key) {
    if (key === void 0) {
      key = node.key || node.property;
    }
    if (!node.computed && isIdentifier$e(key)) key = stringLiteral$6(key.name);
    return key;
  }

function removePropertiesDeep$1(tree, opts) {
    traverseFast$3(tree, removeProperties$1, opts);
    return tree;
  }

function appendToMemberExpression(member, append, computed) {
    if (computed === void 0) {
      computed = false;
    }
    member.object = memberExpression$9(member.object, member.property, member.computed);
    member.property = append;
    member.computed = !!computed;
    return member;
  }

function prependToMemberExpression(member, prepend) {
    if (isSuper$2(member.object)) {
      throw new Error("Cannot prepend node to super property access (`super.foo`).");
    }
    member.object = memberExpression$9(prepend, member.object);
    return member;
  }

function getOuterBindingIdentifiers$1(node, duplicates) {
    return getBindingIdentifiers$4(node, duplicates, true);
  }

function isLet(node) {
    return isVariableDeclaration$3(node) && (node.kind !== "var" || node[BLOCK_SCOPED_SYMBOL]);
  }

function isBlockScoped$2(node) {
    return isFunctionDeclaration$2(node) || isClassDeclaration$2(node) || isLet(node);
  }

function isSpecifierDefault(specifier) {
    return isImportDefaultSpecifier$1(specifier) || isIdentifier$e(specifier.imported || specifier.exported, {
      name: "default"
    });
  }

var RESERVED_WORDS_ES3_ONLY = 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(name) {
    return isValidIdentifier$1(name) && !RESERVED_WORDS_ES3_ONLY.has(name);
  }

function isVar$1(node) {
    return isVariableDeclaration$3(node, {
      kind: "var"
    }) && !node[BLOCK_SCOPED_SYMBOL];
  }

var react$3 = {
    isReactComponent: isReactComponent,
    isCompatTag: isCompatTag$1,
    buildChildren: buildChildren
  };
  if (browser$1$1.env.BABEL_TYPES_8_BREAKING) {
    console.warn("BABEL_TYPES_8_BREAKING is not supported anymore. Use the latest Babel 8.0.0 pre-release instead!");
  }

var t$4 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    ACCESSOR_TYPES: ACCESSOR_TYPES,
    ALIAS_KEYS: ALIAS_KEYS,
    ASSIGNMENT_OPERATORS: ASSIGNMENT_OPERATORS,
    AnyTypeAnnotation: anyTypeAnnotation$2,
    ArgumentPlaceholder: argumentPlaceholder,
    ArrayExpression: arrayExpression$1,
    ArrayPattern: arrayPattern,
    ArrayTypeAnnotation: arrayTypeAnnotation$1,
    ArrowFunctionExpression: arrowFunctionExpression$4,
    AssignmentExpression: assignmentExpression$8,
    AssignmentPattern: assignmentPattern,
    AwaitExpression: awaitExpression$1,
    BINARY_OPERATORS: BINARY_OPERATORS,
    BINARY_TYPES: BINARY_TYPES,
    BLOCKPARENT_TYPES: BLOCKPARENT_TYPES,
    BLOCK_SCOPED_SYMBOL: BLOCK_SCOPED_SYMBOL,
    BLOCK_TYPES: BLOCK_TYPES,
    BOOLEAN_BINARY_OPERATORS: BOOLEAN_BINARY_OPERATORS$1,
    BOOLEAN_NUMBER_BINARY_OPERATORS: BOOLEAN_NUMBER_BINARY_OPERATORS$1,
    BOOLEAN_UNARY_OPERATORS: BOOLEAN_UNARY_OPERATORS$1,
    BUILDER_KEYS: BUILDER_KEYS,
    BigIntLiteral: bigIntLiteral,
    BinaryExpression: binaryExpression$4,
    BindExpression: bindExpression,
    BlockStatement: blockStatement$6,
    BooleanLiteral: booleanLiteral$2,
    BooleanLiteralTypeAnnotation: booleanLiteralTypeAnnotation,
    BooleanTypeAnnotation: booleanTypeAnnotation$1,
    BreakStatement: breakStatement,
    CLASS_TYPES: CLASS_TYPES,
    COMMENT_KEYS: COMMENT_KEYS,
    COMPARISON_BINARY_OPERATORS: COMPARISON_BINARY_OPERATORS,
    COMPLETIONSTATEMENT_TYPES: COMPLETIONSTATEMENT_TYPES,
    CONDITIONAL_TYPES: CONDITIONAL_TYPES,
    CallExpression: callExpression$c,
    CatchClause: catchClause,
    ClassAccessorProperty: classAccessorProperty,
    ClassBody: classBody,
    ClassDeclaration: classDeclaration,
    ClassExpression: classExpression,
    ClassImplements: classImplements,
    ClassMethod: classMethod,
    ClassPrivateMethod: classPrivateMethod,
    ClassPrivateProperty: classPrivateProperty,
    ClassProperty: classProperty,
    ConditionalExpression: conditionalExpression$5,
    ContinueStatement: continueStatement,
    DECLARATION_TYPES: DECLARATION_TYPES,
    DEPRECATED_ALIASES: DEPRECATED_ALIASES$1,
    DEPRECATED_KEYS: DEPRECATED_KEYS$1,
    DebuggerStatement: debuggerStatement,
    DecimalLiteral: decimalLiteral,
    DeclareClass: declareClass,
    DeclareExportAllDeclaration: declareExportAllDeclaration,
    DeclareExportDeclaration: declareExportDeclaration,
    DeclareFunction: declareFunction,
    DeclareInterface: declareInterface,
    DeclareModule: declareModule,
    DeclareModuleExports: declareModuleExports,
    DeclareOpaqueType: declareOpaqueType,
    DeclareTypeAlias: declareTypeAlias,
    DeclareVariable: declareVariable,
    DeclaredPredicate: declaredPredicate,
    Decorator: decorator,
    Directive: directive,
    DirectiveLiteral: directiveLiteral,
    DoExpression: doExpression,
    DoWhileStatement: doWhileStatement,
    ENUMBODY_TYPES: ENUMBODY_TYPES,
    ENUMMEMBER_TYPES: ENUMMEMBER_TYPES,
    EQUALITY_BINARY_OPERATORS: EQUALITY_BINARY_OPERATORS,
    EXPORTDECLARATION_TYPES: EXPORTDECLARATION_TYPES,
    EXPRESSIONWRAPPER_TYPES: EXPRESSIONWRAPPER_TYPES,
    EXPRESSION_TYPES: EXPRESSION_TYPES,
    EmptyStatement: emptyStatement$1,
    EmptyTypeAnnotation: emptyTypeAnnotation,
    EnumBooleanBody: enumBooleanBody,
    EnumBooleanMember: enumBooleanMember,
    EnumDeclaration: enumDeclaration,
    EnumDefaultedMember: enumDefaultedMember,
    EnumNumberBody: enumNumberBody,
    EnumNumberMember: enumNumberMember,
    EnumStringBody: enumStringBody,
    EnumStringMember: enumStringMember,
    EnumSymbolBody: enumSymbolBody,
    ExistsTypeAnnotation: existsTypeAnnotation,
    ExportAllDeclaration: exportAllDeclaration,
    ExportDefaultDeclaration: exportDefaultDeclaration,
    ExportDefaultSpecifier: exportDefaultSpecifier,
    ExportNamedDeclaration: exportNamedDeclaration$2,
    ExportNamespaceSpecifier: exportNamespaceSpecifier,
    ExportSpecifier: exportSpecifier$2,
    ExpressionStatement: expressionStatement$7,
    FLATTENABLE_KEYS: FLATTENABLE_KEYS,
    FLIPPED_ALIAS_KEYS: FLIPPED_ALIAS_KEYS$3,
    FLOWBASEANNOTATION_TYPES: FLOWBASEANNOTATION_TYPES,
    FLOWDECLARATION_TYPES: FLOWDECLARATION_TYPES,
    FLOWPREDICATE_TYPES: FLOWPREDICATE_TYPES,
    FLOWTYPE_TYPES: FLOWTYPE_TYPES,
    FLOW_TYPES: FLOW_TYPES,
    FORXSTATEMENT_TYPES: FORXSTATEMENT_TYPES,
    FOR_INIT_KEYS: FOR_INIT_KEYS,
    FOR_TYPES: FOR_TYPES,
    FUNCTIONPARENT_TYPES: FUNCTIONPARENT_TYPES,
    FUNCTION_TYPES: FUNCTION_TYPES$1,
    File: file$1,
    ForInStatement: forInStatement,
    ForOfStatement: forOfStatement,
    ForStatement: forStatement,
    FunctionDeclaration: functionDeclaration,
    FunctionExpression: functionExpression$2,
    FunctionTypeAnnotation: functionTypeAnnotation,
    FunctionTypeParam: functionTypeParam,
    GenericTypeAnnotation: genericTypeAnnotation$1,
    IMMUTABLE_TYPES: IMMUTABLE_TYPES,
    IMPORTOREXPORTDECLARATION_TYPES: IMPORTOREXPORTDECLARATION_TYPES,
    INHERIT_KEYS: INHERIT_KEYS,
    Identifier: identifier$d,
    IfStatement: ifStatement,
    Import: _import,
    ImportAttribute: importAttribute,
    ImportDeclaration: importDeclaration$1,
    ImportDefaultSpecifier: importDefaultSpecifier$1,
    ImportExpression: importExpression,
    ImportNamespaceSpecifier: importNamespaceSpecifier$1,
    ImportSpecifier: importSpecifier$2,
    IndexedAccessType: indexedAccessType,
    InferredPredicate: inferredPredicate,
    InterfaceDeclaration: interfaceDeclaration,
    InterfaceExtends: interfaceExtends,
    InterfaceTypeAnnotation: interfaceTypeAnnotation,
    InterpreterDirective: interpreterDirective$1,
    IntersectionTypeAnnotation: intersectionTypeAnnotation,
    JSXAttribute: jsxAttribute,
    JSXClosingElement: jsxClosingElement,
    JSXClosingFragment: jsxClosingFragment,
    JSXElement: jsxElement,
    JSXEmptyExpression: jsxEmptyExpression,
    JSXExpressionContainer: jsxExpressionContainer$1,
    JSXFragment: jsxFragment,
    JSXIdentifier: jsxIdentifier$1,
    JSXMemberExpression: jsxMemberExpression,
    JSXNamespacedName: jsxNamespacedName,
    JSXOpeningElement: jsxOpeningElement,
    JSXOpeningFragment: jsxOpeningFragment,
    JSXSpreadAttribute: jsxSpreadAttribute,
    JSXSpreadChild: jsxSpreadChild,
    JSXText: jsxText,
    JSX_TYPES: JSX_TYPES,
    LITERAL_TYPES: LITERAL_TYPES,
    LOGICAL_OPERATORS: LOGICAL_OPERATORS$2,
    LOOP_TYPES: LOOP_TYPES,
    LVAL_TYPES: LVAL_TYPES,
    LabeledStatement: labeledStatement,
    LogicalExpression: logicalExpression$2,
    METHOD_TYPES: METHOD_TYPES,
    MISCELLANEOUS_TYPES: MISCELLANEOUS_TYPES,
    MODULEDECLARATION_TYPES: MODULEDECLARATION_TYPES,
    MODULESPECIFIER_TYPES: MODULESPECIFIER_TYPES,
    MemberExpression: memberExpression$9,
    MetaProperty: metaProperty$1,
    MixedTypeAnnotation: mixedTypeAnnotation,
    ModuleExpression: moduleExpression,
    NODE_FIELDS: NODE_FIELDS$1,
    NODE_PARENT_VALIDATIONS: NODE_PARENT_VALIDATIONS,
    NOT_LOCAL_BINDING: NOT_LOCAL_BINDING$1,
    NUMBER_BINARY_OPERATORS: NUMBER_BINARY_OPERATORS$1,
    NUMBER_UNARY_OPERATORS: NUMBER_UNARY_OPERATORS$1,
    NewExpression: newExpression,
    Noop: noop$1,
    NullLiteral: nullLiteral$2,
    NullLiteralTypeAnnotation: nullLiteralTypeAnnotation$1,
    NullableTypeAnnotation: nullableTypeAnnotation,
    NumberLiteral: NumberLiteral,
    NumberLiteralTypeAnnotation: numberLiteralTypeAnnotation,
    NumberTypeAnnotation: numberTypeAnnotation$2,
    NumericLiteral: numericLiteral$5,
    OBJECTMEMBER_TYPES: OBJECTMEMBER_TYPES,
    ObjectExpression: objectExpression$3,
    ObjectMethod: objectMethod,
    ObjectPattern: objectPattern$1,
    ObjectProperty: objectProperty$1,
    ObjectTypeAnnotation: objectTypeAnnotation,
    ObjectTypeCallProperty: objectTypeCallProperty,
    ObjectTypeIndexer: objectTypeIndexer,
    ObjectTypeInternalSlot: objectTypeInternalSlot,
    ObjectTypeProperty: objectTypeProperty,
    ObjectTypeSpreadProperty: objectTypeSpreadProperty,
    OpaqueType: opaqueType,
    OptionalCallExpression: optionalCallExpression$2,
    OptionalIndexedAccessType: optionalIndexedAccessType,
    OptionalMemberExpression: optionalMemberExpression$2,
    PATTERNLIKE_TYPES: PATTERNLIKE_TYPES,
    PATTERN_TYPES: PATTERN_TYPES,
    PLACEHOLDERS: PLACEHOLDERS,
    PLACEHOLDERS_ALIAS: PLACEHOLDERS_ALIAS,
    PLACEHOLDERS_FLIPPED_ALIAS: PLACEHOLDERS_FLIPPED_ALIAS,
    PRIVATE_TYPES: PRIVATE_TYPES,
    PROPERTY_TYPES: PROPERTY_TYPES,
    PUREISH_TYPES: PUREISH_TYPES,
    ParenthesizedExpression: parenthesizedExpression,
    PipelineBareFunction: pipelineBareFunction,
    PipelinePrimaryTopicReference: pipelinePrimaryTopicReference,
    PipelineTopicExpression: pipelineTopicExpression,
    Placeholder: placeholder,
    PrivateName: privateName,
    Program: program$3,
    QualifiedTypeIdentifier: qualifiedTypeIdentifier,
    RecordExpression: recordExpression,
    RegExpLiteral: regExpLiteral,
    RegexLiteral: RegexLiteral,
    RestElement: restElement$2,
    RestProperty: RestProperty$1,
    ReturnStatement: returnStatement$3,
    SCOPABLE_TYPES: SCOPABLE_TYPES,
    STANDARDIZED_TYPES: STANDARDIZED_TYPES,
    STATEMENT_OR_BLOCK_KEYS: STATEMENT_OR_BLOCK_KEYS$1,
    STATEMENT_TYPES: STATEMENT_TYPES,
    STRING_UNARY_OPERATORS: STRING_UNARY_OPERATORS$1,
    SequenceExpression: sequenceExpression$6,
    SpreadElement: spreadElement$2,
    SpreadProperty: SpreadProperty$1,
    StaticBlock: staticBlock,
    StringLiteral: stringLiteral$6,
    StringLiteralTypeAnnotation: stringLiteralTypeAnnotation,
    StringTypeAnnotation: stringTypeAnnotation$2,
    Super: _super$1,
    SwitchCase: switchCase,
    SwitchStatement: switchStatement,
    SymbolTypeAnnotation: symbolTypeAnnotation,
    TERMINATORLESS_TYPES: TERMINATORLESS_TYPES,
    TSAnyKeyword: tsAnyKeyword,
    TSArrayType: tsArrayType,
    TSAsExpression: tsAsExpression,
    TSBASETYPE_TYPES: TSBASETYPE_TYPES,
    TSBigIntKeyword: tsBigIntKeyword,
    TSBooleanKeyword: tsBooleanKeyword,
    TSCallSignatureDeclaration: tsCallSignatureDeclaration,
    TSConditionalType: tsConditionalType,
    TSConstructSignatureDeclaration: tsConstructSignatureDeclaration,
    TSConstructorType: tsConstructorType,
    TSDeclareFunction: tsDeclareFunction,
    TSDeclareMethod: tsDeclareMethod,
    TSENTITYNAME_TYPES: TSENTITYNAME_TYPES,
    TSEnumBody: tsEnumBody,
    TSEnumDeclaration: tsEnumDeclaration,
    TSEnumMember: tsEnumMember,
    TSExportAssignment: tsExportAssignment,
    TSExpressionWithTypeArguments: tsExpressionWithTypeArguments,
    TSExternalModuleReference: tsExternalModuleReference,
    TSFunctionType: tsFunctionType,
    TSImportEqualsDeclaration: tsImportEqualsDeclaration,
    TSImportType: tsImportType,
    TSIndexSignature: tsIndexSignature,
    TSIndexedAccessType: tsIndexedAccessType,
    TSInferType: tsInferType,
    TSInstantiationExpression: tsInstantiationExpression,
    TSInterfaceBody: tsInterfaceBody,
    TSInterfaceDeclaration: tsInterfaceDeclaration,
    TSIntersectionType: tsIntersectionType,
    TSIntrinsicKeyword: tsIntrinsicKeyword,
    TSLiteralType: tsLiteralType,
    TSMappedType: tsMappedType,
    TSMethodSignature: tsMethodSignature,
    TSModuleBlock: tsModuleBlock,
    TSModuleDeclaration: tsModuleDeclaration,
    TSNamedTupleMember: tsNamedTupleMember,
    TSNamespaceExportDeclaration: tsNamespaceExportDeclaration,
    TSNeverKeyword: tsNeverKeyword,
    TSNonNullExpression: tsNonNullExpression,
    TSNullKeyword: tsNullKeyword,
    TSNumberKeyword: tsNumberKeyword,
    TSObjectKeyword: tsObjectKeyword,
    TSOptionalType: tsOptionalType,
    TSParameterProperty: tsParameterProperty,
    TSParenthesizedType: tsParenthesizedType,
    TSPropertySignature: tsPropertySignature,
    TSQualifiedName: tsQualifiedName,
    TSRestType: tsRestType,
    TSSatisfiesExpression: tsSatisfiesExpression,
    TSStringKeyword: tsStringKeyword,
    TSSymbolKeyword: tsSymbolKeyword,
    TSTYPEELEMENT_TYPES: TSTYPEELEMENT_TYPES,
    TSTYPE_TYPES: TSTYPE_TYPES,
    TSThisType: tsThisType,
    TSTupleType: tsTupleType,
    TSTypeAliasDeclaration: tsTypeAliasDeclaration,
    TSTypeAnnotation: tsTypeAnnotation,
    TSTypeAssertion: tsTypeAssertion,
    TSTypeLiteral: tsTypeLiteral,
    TSTypeOperator: tsTypeOperator,
    TSTypeParameter: tsTypeParameter,
    TSTypeParameterDeclaration: tsTypeParameterDeclaration,
    TSTypeParameterInstantiation: tsTypeParameterInstantiation,
    TSTypePredicate: tsTypePredicate,
    TSTypeQuery: tsTypeQuery,
    TSTypeReference: tsTypeReference,
    TSUndefinedKeyword: tsUndefinedKeyword,
    TSUnionType: tsUnionType,
    TSUnknownKeyword: tsUnknownKeyword,
    TSVoidKeyword: tsVoidKeyword,
    TYPES: TYPES$1,
    TYPESCRIPT_TYPES: TYPESCRIPT_TYPES,
    TaggedTemplateExpression: taggedTemplateExpression,
    TemplateElement: templateElement,
    TemplateLiteral: templateLiteral,
    ThisExpression: thisExpression$4,
    ThisTypeAnnotation: thisTypeAnnotation,
    ThrowStatement: throwStatement,
    TopicReference: topicReference,
    TryStatement: tryStatement,
    TupleExpression: tupleExpression,
    TupleTypeAnnotation: tupleTypeAnnotation$1,
    TypeAlias: typeAlias,
    TypeAnnotation: typeAnnotation,
    TypeCastExpression: typeCastExpression,
    TypeParameter: typeParameter,
    TypeParameterDeclaration: typeParameterDeclaration,
    TypeParameterInstantiation: typeParameterInstantiation,
    TypeofTypeAnnotation: typeofTypeAnnotation,
    UNARYLIKE_TYPES: UNARYLIKE_TYPES,
    UNARY_OPERATORS: UNARY_OPERATORS,
    UPDATE_OPERATORS: UPDATE_OPERATORS,
    USERWHITESPACABLE_TYPES: USERWHITESPACABLE_TYPES,
    UnaryExpression: unaryExpression$4,
    UnionTypeAnnotation: unionTypeAnnotation$1,
    UpdateExpression: updateExpression$1,
    V8IntrinsicIdentifier: v8IntrinsicIdentifier,
    VISITOR_KEYS: VISITOR_KEYS$7,
    VariableDeclaration: variableDeclaration$6,
    VariableDeclarator: variableDeclarator$6,
    Variance: variance,
    VoidTypeAnnotation: voidTypeAnnotation$3,
    WHILE_TYPES: WHILE_TYPES,
    WhileStatement: whileStatement,
    WithStatement: withStatement,
    YieldExpression: yieldExpression$2,
    __internal__deprecationWarning: deprecationWarning$1,
    addComment: addComment$2,
    addComments: addComments$1,
    anyTypeAnnotation: anyTypeAnnotation$2,
    appendToMemberExpression: appendToMemberExpression,
    argumentPlaceholder: argumentPlaceholder,
    arrayExpression: arrayExpression$1,
    arrayPattern: arrayPattern,
    arrayTypeAnnotation: arrayTypeAnnotation$1,
    arrowFunctionExpression: arrowFunctionExpression$4,
    assertAccessor: assertAccessor,
    assertAnyTypeAnnotation: assertAnyTypeAnnotation,
    assertArgumentPlaceholder: assertArgumentPlaceholder,
    assertArrayExpression: assertArrayExpression,
    assertArrayPattern: assertArrayPattern,
    assertArrayTypeAnnotation: assertArrayTypeAnnotation,
    assertArrowFunctionExpression: assertArrowFunctionExpression,
    assertAssignmentExpression: assertAssignmentExpression,
    assertAssignmentPattern: assertAssignmentPattern,
    assertAwaitExpression: assertAwaitExpression,
    assertBigIntLiteral: assertBigIntLiteral,
    assertBinary: assertBinary,
    assertBinaryExpression: assertBinaryExpression,
    assertBindExpression: assertBindExpression,
    assertBlock: assertBlock,
    assertBlockParent: assertBlockParent,
    assertBlockStatement: assertBlockStatement,
    assertBooleanLiteral: assertBooleanLiteral,
    assertBooleanLiteralTypeAnnotation: assertBooleanLiteralTypeAnnotation,
    assertBooleanTypeAnnotation: assertBooleanTypeAnnotation,
    assertBreakStatement: assertBreakStatement,
    assertCallExpression: assertCallExpression,
    assertCatchClause: assertCatchClause,
    assertClass: assertClass,
    assertClassAccessorProperty: assertClassAccessorProperty,
    assertClassBody: assertClassBody,
    assertClassDeclaration: assertClassDeclaration,
    assertClassExpression: assertClassExpression,
    assertClassImplements: assertClassImplements,
    assertClassMethod: assertClassMethod,
    assertClassPrivateMethod: assertClassPrivateMethod,
    assertClassPrivateProperty: assertClassPrivateProperty,
    assertClassProperty: assertClassProperty,
    assertCompletionStatement: assertCompletionStatement,
    assertConditional: assertConditional,
    assertConditionalExpression: assertConditionalExpression,
    assertContinueStatement: assertContinueStatement,
    assertDebuggerStatement: assertDebuggerStatement,
    assertDecimalLiteral: assertDecimalLiteral,
    assertDeclaration: assertDeclaration,
    assertDeclareClass: assertDeclareClass,
    assertDeclareExportAllDeclaration: assertDeclareExportAllDeclaration,
    assertDeclareExportDeclaration: assertDeclareExportDeclaration,
    assertDeclareFunction: assertDeclareFunction,
    assertDeclareInterface: assertDeclareInterface,
    assertDeclareModule: assertDeclareModule,
    assertDeclareModuleExports: assertDeclareModuleExports,
    assertDeclareOpaqueType: assertDeclareOpaqueType,
    assertDeclareTypeAlias: assertDeclareTypeAlias,
    assertDeclareVariable: assertDeclareVariable,
    assertDeclaredPredicate: assertDeclaredPredicate,
    assertDecorator: assertDecorator,
    assertDirective: assertDirective,
    assertDirectiveLiteral: assertDirectiveLiteral,
    assertDoExpression: assertDoExpression,
    assertDoWhileStatement: assertDoWhileStatement,
    assertEmptyStatement: assertEmptyStatement,
    assertEmptyTypeAnnotation: assertEmptyTypeAnnotation,
    assertEnumBody: assertEnumBody,
    assertEnumBooleanBody: assertEnumBooleanBody,
    assertEnumBooleanMember: assertEnumBooleanMember,
    assertEnumDeclaration: assertEnumDeclaration,
    assertEnumDefaultedMember: assertEnumDefaultedMember,
    assertEnumMember: assertEnumMember,
    assertEnumNumberBody: assertEnumNumberBody,
    assertEnumNumberMember: assertEnumNumberMember,
    assertEnumStringBody: assertEnumStringBody,
    assertEnumStringMember: assertEnumStringMember,
    assertEnumSymbolBody: assertEnumSymbolBody,
    assertExistsTypeAnnotation: assertExistsTypeAnnotation,
    assertExportAllDeclaration: assertExportAllDeclaration,
    assertExportDeclaration: assertExportDeclaration,
    assertExportDefaultDeclaration: assertExportDefaultDeclaration,
    assertExportDefaultSpecifier: assertExportDefaultSpecifier,
    assertExportNamedDeclaration: assertExportNamedDeclaration,
    assertExportNamespaceSpecifier: assertExportNamespaceSpecifier,
    assertExportSpecifier: assertExportSpecifier$1,
    assertExpression: assertExpression$1,
    assertExpressionStatement: assertExpressionStatement$1,
    assertExpressionWrapper: assertExpressionWrapper,
    assertFile: assertFile,
    assertFlow: assertFlow,
    assertFlowBaseAnnotation: assertFlowBaseAnnotation,
    assertFlowDeclaration: assertFlowDeclaration,
    assertFlowPredicate: assertFlowPredicate,
    assertFlowType: assertFlowType,
    assertFor: assertFor,
    assertForInStatement: assertForInStatement,
    assertForOfStatement: assertForOfStatement,
    assertForStatement: assertForStatement,
    assertForXStatement: assertForXStatement,
    assertFunction: assertFunction$1,
    assertFunctionDeclaration: assertFunctionDeclaration,
    assertFunctionExpression: assertFunctionExpression,
    assertFunctionParent: assertFunctionParent,
    assertFunctionTypeAnnotation: assertFunctionTypeAnnotation,
    assertFunctionTypeParam: assertFunctionTypeParam,
    assertGenericTypeAnnotation: assertGenericTypeAnnotation,
    assertIdentifier: assertIdentifier,
    assertIfStatement: assertIfStatement,
    assertImmutable: assertImmutable,
    assertImport: assertImport,
    assertImportAttribute: assertImportAttribute,
    assertImportDeclaration: assertImportDeclaration,
    assertImportDefaultSpecifier: assertImportDefaultSpecifier,
    assertImportExpression: assertImportExpression,
    assertImportNamespaceSpecifier: assertImportNamespaceSpecifier,
    assertImportOrExportDeclaration: assertImportOrExportDeclaration,
    assertImportSpecifier: assertImportSpecifier,
    assertIndexedAccessType: assertIndexedAccessType,
    assertInferredPredicate: assertInferredPredicate,
    assertInterfaceDeclaration: assertInterfaceDeclaration,
    assertInterfaceExtends: assertInterfaceExtends,
    assertInterfaceTypeAnnotation: assertInterfaceTypeAnnotation,
    assertInterpreterDirective: assertInterpreterDirective,
    assertIntersectionTypeAnnotation: assertIntersectionTypeAnnotation,
    assertJSX: assertJSX,
    assertJSXAttribute: assertJSXAttribute,
    assertJSXClosingElement: assertJSXClosingElement,
    assertJSXClosingFragment: assertJSXClosingFragment,
    assertJSXElement: assertJSXElement,
    assertJSXEmptyExpression: assertJSXEmptyExpression,
    assertJSXExpressionContainer: assertJSXExpressionContainer,
    assertJSXFragment: assertJSXFragment,
    assertJSXIdentifier: assertJSXIdentifier,
    assertJSXMemberExpression: assertJSXMemberExpression,
    assertJSXNamespacedName: assertJSXNamespacedName,
    assertJSXOpeningElement: assertJSXOpeningElement,
    assertJSXOpeningFragment: assertJSXOpeningFragment,
    assertJSXSpreadAttribute: assertJSXSpreadAttribute,
    assertJSXSpreadChild: assertJSXSpreadChild,
    assertJSXText: assertJSXText,
    assertLVal: assertLVal,
    assertLabeledStatement: assertLabeledStatement,
    assertLiteral: assertLiteral,
    assertLogicalExpression: assertLogicalExpression,
    assertLoop: assertLoop,
    assertMemberExpression: assertMemberExpression,
    assertMetaProperty: assertMetaProperty,
    assertMethod: assertMethod,
    assertMiscellaneous: assertMiscellaneous,
    assertMixedTypeAnnotation: assertMixedTypeAnnotation,
    assertModuleDeclaration: assertModuleDeclaration,
    assertModuleExpression: assertModuleExpression,
    assertModuleSpecifier: assertModuleSpecifier,
    assertNewExpression: assertNewExpression,
    assertNode: assertNode,
    assertNoop: assertNoop,
    assertNullLiteral: assertNullLiteral,
    assertNullLiteralTypeAnnotation: assertNullLiteralTypeAnnotation,
    assertNullableTypeAnnotation: assertNullableTypeAnnotation,
    assertNumberLiteral: assertNumberLiteral,
    assertNumberLiteralTypeAnnotation: assertNumberLiteralTypeAnnotation,
    assertNumberTypeAnnotation: assertNumberTypeAnnotation,
    assertNumericLiteral: assertNumericLiteral,
    assertObjectExpression: assertObjectExpression,
    assertObjectMember: assertObjectMember,
    assertObjectMethod: assertObjectMethod,
    assertObjectPattern: assertObjectPattern,
    assertObjectProperty: assertObjectProperty,
    assertObjectTypeAnnotation: assertObjectTypeAnnotation,
    assertObjectTypeCallProperty: assertObjectTypeCallProperty,
    assertObjectTypeIndexer: assertObjectTypeIndexer,
    assertObjectTypeInternalSlot: assertObjectTypeInternalSlot,
    assertObjectTypeProperty: assertObjectTypeProperty,
    assertObjectTypeSpreadProperty: assertObjectTypeSpreadProperty,
    assertOpaqueType: assertOpaqueType,
    assertOptionalCallExpression: assertOptionalCallExpression,
    assertOptionalIndexedAccessType: assertOptionalIndexedAccessType,
    assertOptionalMemberExpression: assertOptionalMemberExpression,
    assertParenthesizedExpression: assertParenthesizedExpression,
    assertPattern: assertPattern,
    assertPatternLike: assertPatternLike,
    assertPipelineBareFunction: assertPipelineBareFunction,
    assertPipelinePrimaryTopicReference: assertPipelinePrimaryTopicReference,
    assertPipelineTopicExpression: assertPipelineTopicExpression,
    assertPlaceholder: assertPlaceholder,
    assertPrivate: assertPrivate,
    assertPrivateName: assertPrivateName,
    assertProgram: assertProgram,
    assertProperty: assertProperty,
    assertPureish: assertPureish,
    assertQualifiedTypeIdentifier: assertQualifiedTypeIdentifier,
    assertRecordExpression: assertRecordExpression,
    assertRegExpLiteral: assertRegExpLiteral,
    assertRegexLiteral: assertRegexLiteral,
    assertRestElement: assertRestElement,
    assertRestProperty: assertRestProperty,
    assertReturnStatement: assertReturnStatement,
    assertScopable: assertScopable,
    assertSequenceExpression: assertSequenceExpression,
    assertSpreadElement: assertSpreadElement,
    assertSpreadProperty: assertSpreadProperty,
    assertStandardized: assertStandardized,
    assertStatement: assertStatement,
    assertStaticBlock: assertStaticBlock,
    assertStringLiteral: assertStringLiteral,
    assertStringLiteralTypeAnnotation: assertStringLiteralTypeAnnotation,
    assertStringTypeAnnotation: assertStringTypeAnnotation,
    assertSuper: assertSuper,
    assertSwitchCase: assertSwitchCase,
    assertSwitchStatement: assertSwitchStatement,
    assertSymbolTypeAnnotation: assertSymbolTypeAnnotation,
    assertTSAnyKeyword: assertTSAnyKeyword,
    assertTSArrayType: assertTSArrayType,
    assertTSAsExpression: assertTSAsExpression,
    assertTSBaseType: assertTSBaseType,
    assertTSBigIntKeyword: assertTSBigIntKeyword,
    assertTSBooleanKeyword: assertTSBooleanKeyword,
    assertTSCallSignatureDeclaration: assertTSCallSignatureDeclaration,
    assertTSConditionalType: assertTSConditionalType,
    assertTSConstructSignatureDeclaration: assertTSConstructSignatureDeclaration,
    assertTSConstructorType: assertTSConstructorType,
    assertTSDeclareFunction: assertTSDeclareFunction,
    assertTSDeclareMethod: assertTSDeclareMethod,
    assertTSEntityName: assertTSEntityName,
    assertTSEnumBody: assertTSEnumBody,
    assertTSEnumDeclaration: assertTSEnumDeclaration,
    assertTSEnumMember: assertTSEnumMember,
    assertTSExportAssignment: assertTSExportAssignment,
    assertTSExpressionWithTypeArguments: assertTSExpressionWithTypeArguments,
    assertTSExternalModuleReference: assertTSExternalModuleReference,
    assertTSFunctionType: assertTSFunctionType,
    assertTSImportEqualsDeclaration: assertTSImportEqualsDeclaration,
    assertTSImportType: assertTSImportType,
    assertTSIndexSignature: assertTSIndexSignature,
    assertTSIndexedAccessType: assertTSIndexedAccessType,
    assertTSInferType: assertTSInferType,
    assertTSInstantiationExpression: assertTSInstantiationExpression,
    assertTSInterfaceBody: assertTSInterfaceBody,
    assertTSInterfaceDeclaration: assertTSInterfaceDeclaration,
    assertTSIntersectionType: assertTSIntersectionType,
    assertTSIntrinsicKeyword: assertTSIntrinsicKeyword,
    assertTSLiteralType: assertTSLiteralType,
    assertTSMappedType: assertTSMappedType,
    assertTSMethodSignature: assertTSMethodSignature,
    assertTSModuleBlock: assertTSModuleBlock,
    assertTSModuleDeclaration: assertTSModuleDeclaration,
    assertTSNamedTupleMember: assertTSNamedTupleMember,
    assertTSNamespaceExportDeclaration: assertTSNamespaceExportDeclaration,
    assertTSNeverKeyword: assertTSNeverKeyword,
    assertTSNonNullExpression: assertTSNonNullExpression,
    assertTSNullKeyword: assertTSNullKeyword,
    assertTSNumberKeyword: assertTSNumberKeyword,
    assertTSObjectKeyword: assertTSObjectKeyword,
    assertTSOptionalType: assertTSOptionalType,
    assertTSParameterProperty: assertTSParameterProperty,
    assertTSParenthesizedType: assertTSParenthesizedType,
    assertTSPropertySignature: assertTSPropertySignature,
    assertTSQualifiedName: assertTSQualifiedName,
    assertTSRestType: assertTSRestType,
    assertTSSatisfiesExpression: assertTSSatisfiesExpression,
    assertTSStringKeyword: assertTSStringKeyword,
    assertTSSymbolKeyword: assertTSSymbolKeyword,
    assertTSThisType: assertTSThisType,
    assertTSTupleType: assertTSTupleType,
    assertTSType: assertTSType,
    assertTSTypeAliasDeclaration: assertTSTypeAliasDeclaration,
    assertTSTypeAnnotation: assertTSTypeAnnotation,
    assertTSTypeAssertion: assertTSTypeAssertion,
    assertTSTypeElement: assertTSTypeElement,
    assertTSTypeLiteral: assertTSTypeLiteral,
    assertTSTypeOperator: assertTSTypeOperator,
    assertTSTypeParameter: assertTSTypeParameter,
    assertTSTypeParameterDeclaration: assertTSTypeParameterDeclaration,
    assertTSTypeParameterInstantiation: assertTSTypeParameterInstantiation,
    assertTSTypePredicate: assertTSTypePredicate,
    assertTSTypeQuery: assertTSTypeQuery,
    assertTSTypeReference: assertTSTypeReference,
    assertTSUndefinedKeyword: assertTSUndefinedKeyword,
    assertTSUnionType: assertTSUnionType,
    assertTSUnknownKeyword: assertTSUnknownKeyword,
    assertTSVoidKeyword: assertTSVoidKeyword,
    assertTaggedTemplateExpression: assertTaggedTemplateExpression,
    assertTemplateElement: assertTemplateElement,
    assertTemplateLiteral: assertTemplateLiteral,
    assertTerminatorless: assertTerminatorless,
    assertThisExpression: assertThisExpression,
    assertThisTypeAnnotation: assertThisTypeAnnotation,
    assertThrowStatement: assertThrowStatement,
    assertTopicReference: assertTopicReference,
    assertTryStatement: assertTryStatement,
    assertTupleExpression: assertTupleExpression,
    assertTupleTypeAnnotation: assertTupleTypeAnnotation,
    assertTypeAlias: assertTypeAlias,
    assertTypeAnnotation: assertTypeAnnotation,
    assertTypeCastExpression: assertTypeCastExpression,
    assertTypeParameter: assertTypeParameter,
    assertTypeParameterDeclaration: assertTypeParameterDeclaration,
    assertTypeParameterInstantiation: assertTypeParameterInstantiation,
    assertTypeScript: assertTypeScript,
    assertTypeofTypeAnnotation: assertTypeofTypeAnnotation,
    assertUnaryExpression: assertUnaryExpression,
    assertUnaryLike: assertUnaryLike,
    assertUnionTypeAnnotation: assertUnionTypeAnnotation,
    assertUpdateExpression: assertUpdateExpression,
    assertUserWhitespacable: assertUserWhitespacable,
    assertV8IntrinsicIdentifier: assertV8IntrinsicIdentifier,
    assertVariableDeclaration: assertVariableDeclaration,
    assertVariableDeclarator: assertVariableDeclarator,
    assertVariance: assertVariance,
    assertVoidTypeAnnotation: assertVoidTypeAnnotation,
    assertWhile: assertWhile,
    assertWhileStatement: assertWhileStatement,
    assertWithStatement: assertWithStatement,
    assertYieldExpression: assertYieldExpression,
    assignmentExpression: assignmentExpression$8,
    assignmentPattern: assignmentPattern,
    awaitExpression: awaitExpression$1,
    bigIntLiteral: bigIntLiteral,
    binaryExpression: binaryExpression$4,
    bindExpression: bindExpression,
    blockStatement: blockStatement$6,
    booleanLiteral: booleanLiteral$2,
    booleanLiteralTypeAnnotation: booleanLiteralTypeAnnotation,
    booleanTypeAnnotation: booleanTypeAnnotation$1,
    breakStatement: breakStatement,
    buildMatchMemberExpression: buildMatchMemberExpression$1,
    buildUndefinedNode: buildUndefinedNode$2,
    callExpression: callExpression$c,
    catchClause: catchClause,
    classAccessorProperty: classAccessorProperty,
    classBody: classBody,
    classDeclaration: classDeclaration,
    classExpression: classExpression,
    classImplements: classImplements,
    classMethod: classMethod,
    classPrivateMethod: classPrivateMethod,
    classPrivateProperty: classPrivateProperty,
    classProperty: classProperty,
    clone: clone,
    cloneDeep: cloneDeep$1,
    cloneDeepWithoutLoc: cloneDeepWithoutLoc,
    cloneNode: cloneNode$e,
    cloneWithoutLoc: cloneWithoutLoc,
    conditionalExpression: conditionalExpression$5,
    continueStatement: continueStatement,
    createFlowUnionType: createFlowUnionType$1,
    createTSUnionType: createTSUnionType$1,
    createTypeAnnotationBasedOnTypeof: createTypeAnnotationBasedOnTypeof$1,
    createUnionTypeAnnotation: createFlowUnionType$1,
    debuggerStatement: debuggerStatement,
    decimalLiteral: decimalLiteral,
    declareClass: declareClass,
    declareExportAllDeclaration: declareExportAllDeclaration,
    declareExportDeclaration: declareExportDeclaration,
    declareFunction: declareFunction,
    declareInterface: declareInterface,
    declareModule: declareModule,
    declareModuleExports: declareModuleExports,
    declareOpaqueType: declareOpaqueType,
    declareTypeAlias: declareTypeAlias,
    declareVariable: declareVariable,
    declaredPredicate: declaredPredicate,
    decorator: decorator,
    directive: directive,
    directiveLiteral: directiveLiteral,
    doExpression: doExpression,
    doWhileStatement: doWhileStatement,
    emptyStatement: emptyStatement$1,
    emptyTypeAnnotation: emptyTypeAnnotation,
    ensureBlock: ensureBlock$1,
    enumBooleanBody: enumBooleanBody,
    enumBooleanMember: enumBooleanMember,
    enumDeclaration: enumDeclaration,
    enumDefaultedMember: enumDefaultedMember,
    enumNumberBody: enumNumberBody,
    enumNumberMember: enumNumberMember,
    enumStringBody: enumStringBody,
    enumStringMember: enumStringMember,
    enumSymbolBody: enumSymbolBody,
    existsTypeAnnotation: existsTypeAnnotation,
    exportAllDeclaration: exportAllDeclaration,
    exportDefaultDeclaration: exportDefaultDeclaration,
    exportDefaultSpecifier: exportDefaultSpecifier,
    exportNamedDeclaration: exportNamedDeclaration$2,
    exportNamespaceSpecifier: exportNamespaceSpecifier,
    exportSpecifier: exportSpecifier$2,
    expressionStatement: expressionStatement$7,
    file: file$1,
    forInStatement: forInStatement,
    forOfStatement: forOfStatement,
    forStatement: forStatement,
    functionDeclaration: functionDeclaration,
    functionExpression: functionExpression$2,
    functionTypeAnnotation: functionTypeAnnotation,
    functionTypeParam: functionTypeParam,
    genericTypeAnnotation: genericTypeAnnotation$1,
    getAssignmentIdentifiers: getAssignmentIdentifiers$2,
    getBindingIdentifiers: getBindingIdentifiers$4,
    getFunctionName: getFunctionName$1,
    getOuterBindingIdentifiers: getOuterBindingIdentifiers$1,
    identifier: identifier$d,
    ifStatement: ifStatement,
    import: _import,
    importAttribute: importAttribute,
    importDeclaration: importDeclaration$1,
    importDefaultSpecifier: importDefaultSpecifier$1,
    importExpression: importExpression,
    importNamespaceSpecifier: importNamespaceSpecifier$1,
    importSpecifier: importSpecifier$2,
    indexedAccessType: indexedAccessType,
    inferredPredicate: inferredPredicate,
    inheritInnerComments: inheritInnerComments,
    inheritLeadingComments: inheritLeadingComments$1,
    inheritTrailingComments: inheritTrailingComments$1,
    inherits: inherits$3,
    inheritsComments: inheritsComments$1,
    interfaceDeclaration: interfaceDeclaration,
    interfaceExtends: interfaceExtends,
    interfaceTypeAnnotation: interfaceTypeAnnotation,
    interpreterDirective: interpreterDirective$1,
    intersectionTypeAnnotation: intersectionTypeAnnotation,
    is: is,
    isAccessor: isAccessor,
    isAnyTypeAnnotation: isAnyTypeAnnotation$1,
    isArgumentPlaceholder: isArgumentPlaceholder,
    isArrayExpression: isArrayExpression$2,
    isArrayPattern: isArrayPattern,
    isArrayTypeAnnotation: isArrayTypeAnnotation$2,
    isArrowFunctionExpression: isArrowFunctionExpression,
    isAssignmentExpression: isAssignmentExpression$2,
    isAssignmentPattern: isAssignmentPattern$4,
    isAwaitExpression: isAwaitExpression,
    isBigIntLiteral: isBigIntLiteral,
    isBinary: isBinary$2,
    isBinaryExpression: isBinaryExpression$1,
    isBindExpression: isBindExpression,
    isBinding: isBinding$1,
    isBlock: isBlock,
    isBlockParent: isBlockParent,
    isBlockScoped: isBlockScoped$2,
    isBlockStatement: isBlockStatement$3,
    isBooleanLiteral: isBooleanLiteral,
    isBooleanLiteralTypeAnnotation: isBooleanLiteralTypeAnnotation,
    isBooleanTypeAnnotation: isBooleanTypeAnnotation$1,
    isBreakStatement: isBreakStatement,
    isCallExpression: isCallExpression$8,
    isCatchClause: isCatchClause,
    isClass: isClass$1,
    isClassAccessorProperty: isClassAccessorProperty,
    isClassBody: isClassBody$2,
    isClassDeclaration: isClassDeclaration$2,
    isClassExpression: isClassExpression,
    isClassImplements: isClassImplements,
    isClassMethod: isClassMethod,
    isClassPrivateMethod: isClassPrivateMethod,
    isClassPrivateProperty: isClassPrivateProperty,
    isClassProperty: isClassProperty,
    isCompletionStatement: isCompletionStatement,
    isConditional: isConditional,
    isConditionalExpression: isConditionalExpression,
    isContinueStatement: isContinueStatement,
    isDebuggerStatement: isDebuggerStatement,
    isDecimalLiteral: isDecimalLiteral,
    isDeclaration: isDeclaration,
    isDeclareClass: isDeclareClass,
    isDeclareExportAllDeclaration: isDeclareExportAllDeclaration,
    isDeclareExportDeclaration: isDeclareExportDeclaration$1,
    isDeclareFunction: isDeclareFunction,
    isDeclareInterface: isDeclareInterface,
    isDeclareModule: isDeclareModule,
    isDeclareModuleExports: isDeclareModuleExports,
    isDeclareOpaqueType: isDeclareOpaqueType,
    isDeclareTypeAlias: isDeclareTypeAlias,
    isDeclareVariable: isDeclareVariable,
    isDeclaredPredicate: isDeclaredPredicate,
    isDecorator: isDecorator$1,
    isDirective: isDirective,
    isDirectiveLiteral: isDirectiveLiteral,
    isDoExpression: isDoExpression,
    isDoWhileStatement: isDoWhileStatement,
    isEmptyStatement: isEmptyStatement$1,
    isEmptyTypeAnnotation: isEmptyTypeAnnotation$1,
    isEnumBody: isEnumBody,
    isEnumBooleanBody: isEnumBooleanBody,
    isEnumBooleanMember: isEnumBooleanMember,
    isEnumDeclaration: isEnumDeclaration,
    isEnumDefaultedMember: isEnumDefaultedMember,
    isEnumMember: isEnumMember,
    isEnumNumberBody: isEnumNumberBody,
    isEnumNumberMember: isEnumNumberMember,
    isEnumStringBody: isEnumStringBody,
    isEnumStringMember: isEnumStringMember,
    isEnumSymbolBody: isEnumSymbolBody,
    isExistsTypeAnnotation: isExistsTypeAnnotation,
    isExportAllDeclaration: isExportAllDeclaration$1,
    isExportDeclaration: isExportDeclaration$2,
    isExportDefaultDeclaration: isExportDefaultDeclaration$2,
    isExportDefaultSpecifier: isExportDefaultSpecifier$1,
    isExportNamedDeclaration: isExportNamedDeclaration$3,
    isExportNamespaceSpecifier: isExportNamespaceSpecifier$1,
    isExportSpecifier: isExportSpecifier,
    isExpression: isExpression$5,
    isExpressionStatement: isExpressionStatement$2,
    isExpressionWrapper: isExpressionWrapper,
    isFile: isFile,
    isFlow: isFlow$1,
    isFlowBaseAnnotation: isFlowBaseAnnotation$1,
    isFlowDeclaration: isFlowDeclaration,
    isFlowPredicate: isFlowPredicate,
    isFlowType: isFlowType$1,
    isFor: isFor$1,
    isForInStatement: isForInStatement,
    isForOfStatement: isForOfStatement$2,
    isForStatement: isForStatement$2,
    isForXStatement: isForXStatement$1,
    isFunction: isFunction$6,
    isFunctionDeclaration: isFunctionDeclaration$2,
    isFunctionExpression: isFunctionExpression,
    isFunctionParent: isFunctionParent,
    isFunctionTypeAnnotation: isFunctionTypeAnnotation,
    isFunctionTypeParam: isFunctionTypeParam,
    isGenericTypeAnnotation: isGenericTypeAnnotation$1,
    isIdentifier: isIdentifier$e,
    isIfStatement: isIfStatement$2,
    isImmutable: isImmutable,
    isImport: isImport,
    isImportAttribute: isImportAttribute,
    isImportDeclaration: isImportDeclaration$3,
    isImportDefaultSpecifier: isImportDefaultSpecifier$1,
    isImportExpression: isImportExpression,
    isImportNamespaceSpecifier: isImportNamespaceSpecifier$1,
    isImportOrExportDeclaration: isImportOrExportDeclaration,
    isImportSpecifier: isImportSpecifier$1,
    isIndexedAccessType: isIndexedAccessType$1,
    isInferredPredicate: isInferredPredicate,
    isInterfaceDeclaration: isInterfaceDeclaration,
    isInterfaceExtends: isInterfaceExtends,
    isInterfaceTypeAnnotation: isInterfaceTypeAnnotation,
    isInterpreterDirective: isInterpreterDirective,
    isIntersectionTypeAnnotation: isIntersectionTypeAnnotation,
    isJSX: isJSX,
    isJSXAttribute: isJSXAttribute,
    isJSXClosingElement: isJSXClosingElement,
    isJSXClosingFragment: isJSXClosingFragment,
    isJSXElement: isJSXElement,
    isJSXEmptyExpression: isJSXEmptyExpression,
    isJSXExpressionContainer: isJSXExpressionContainer$1,
    isJSXFragment: isJSXFragment,
    isJSXIdentifier: isJSXIdentifier$3,
    isJSXMemberExpression: isJSXMemberExpression$2,
    isJSXNamespacedName: isJSXNamespacedName$1,
    isJSXOpeningElement: isJSXOpeningElement,
    isJSXOpeningFragment: isJSXOpeningFragment,
    isJSXSpreadAttribute: isJSXSpreadAttribute$1,
    isJSXSpreadChild: isJSXSpreadChild,
    isJSXText: isJSXText,
    isLVal: isLVal,
    isLabeledStatement: isLabeledStatement,
    isLet: isLet,
    isLiteral: isLiteral$4,
    isLogicalExpression: isLogicalExpression,
    isLoop: isLoop$1,
    isMemberExpression: isMemberExpression$7,
    isMetaProperty: isMetaProperty$1,
    isMethod: isMethod$1,
    isMiscellaneous: isMiscellaneous,
    isMixedTypeAnnotation: isMixedTypeAnnotation$1,
    isModuleDeclaration: isModuleDeclaration,
    isModuleExpression: isModuleExpression,
    isModuleSpecifier: isModuleSpecifier$1,
    isNewExpression: isNewExpression$3,
    isNode: isNode,
    isNodesEquivalent: isNodesEquivalent,
    isNoop: isNoop,
    isNullLiteral: isNullLiteral$1,
    isNullLiteralTypeAnnotation: isNullLiteralTypeAnnotation,
    isNullableTypeAnnotation: isNullableTypeAnnotation,
    isNumberLiteral: isNumberLiteral,
    isNumberLiteralTypeAnnotation: isNumberLiteralTypeAnnotation,
    isNumberTypeAnnotation: isNumberTypeAnnotation$1,
    isNumericLiteral: isNumericLiteral,
    isObjectExpression: isObjectExpression$3,
    isObjectMember: isObjectMember,
    isObjectMethod: isObjectMethod,
    isObjectPattern: isObjectPattern$1,
    isObjectProperty: isObjectProperty$3,
    isObjectTypeAnnotation: isObjectTypeAnnotation,
    isObjectTypeCallProperty: isObjectTypeCallProperty,
    isObjectTypeIndexer: isObjectTypeIndexer,
    isObjectTypeInternalSlot: isObjectTypeInternalSlot,
    isObjectTypeProperty: isObjectTypeProperty,
    isObjectTypeSpreadProperty: isObjectTypeSpreadProperty,
    isOpaqueType: isOpaqueType,
    isOptionalCallExpression: isOptionalCallExpression$2,
    isOptionalIndexedAccessType: isOptionalIndexedAccessType,
    isOptionalMemberExpression: isOptionalMemberExpression$3,
    isParenthesizedExpression: isParenthesizedExpression$2,
    isPattern: isPattern$1,
    isPatternLike: isPatternLike,
    isPipelineBareFunction: isPipelineBareFunction,
    isPipelinePrimaryTopicReference: isPipelinePrimaryTopicReference,
    isPipelineTopicExpression: isPipelineTopicExpression,
    isPlaceholder: isPlaceholder$1,
    isPlaceholderType: isPlaceholderType,
    isPrivate: isPrivate,
    isPrivateName: isPrivateName$2,
    isProgram: isProgram$1,
    isProperty: isProperty$1,
    isPureish: isPureish$1,
    isQualifiedTypeIdentifier: isQualifiedTypeIdentifier,
    isRecordExpression: isRecordExpression$1,
    isReferenced: isReferenced$2,
    isRegExpLiteral: isRegExpLiteral$1,
    isRegexLiteral: isRegexLiteral,
    isRestElement: isRestElement$2,
    isRestProperty: isRestProperty$1,
    isReturnStatement: isReturnStatement,
    isScopable: isScopable,
    isScope: isScope$1,
    isSequenceExpression: isSequenceExpression$1,
    isSpecifierDefault: isSpecifierDefault,
    isSpreadElement: isSpreadElement$1,
    isSpreadProperty: isSpreadProperty$1,
    isStandardized: isStandardized,
    isStatement: isStatement$9,
    isStaticBlock: isStaticBlock,
    isStringLiteral: isStringLiteral$5,
    isStringLiteralTypeAnnotation: isStringLiteralTypeAnnotation,
    isStringTypeAnnotation: isStringTypeAnnotation$1,
    isSuper: isSuper$2,
    isSwitchCase: isSwitchCase,
    isSwitchStatement: isSwitchStatement,
    isSymbolTypeAnnotation: isSymbolTypeAnnotation,
    isTSAnyKeyword: isTSAnyKeyword,
    isTSArrayType: isTSArrayType$1,
    isTSAsExpression: isTSAsExpression$1,
    isTSBaseType: isTSBaseType,
    isTSBigIntKeyword: isTSBigIntKeyword,
    isTSBooleanKeyword: isTSBooleanKeyword,
    isTSCallSignatureDeclaration: isTSCallSignatureDeclaration,
    isTSConditionalType: isTSConditionalType,
    isTSConstructSignatureDeclaration: isTSConstructSignatureDeclaration,
    isTSConstructorType: isTSConstructorType,
    isTSDeclareFunction: isTSDeclareFunction,
    isTSDeclareMethod: isTSDeclareMethod,
    isTSEntityName: isTSEntityName,
    isTSEnumBody: isTSEnumBody,
    isTSEnumDeclaration: isTSEnumDeclaration,
    isTSEnumMember: isTSEnumMember$1,
    isTSExportAssignment: isTSExportAssignment,
    isTSExpressionWithTypeArguments: isTSExpressionWithTypeArguments,
    isTSExternalModuleReference: isTSExternalModuleReference,
    isTSFunctionType: isTSFunctionType,
    isTSImportEqualsDeclaration: isTSImportEqualsDeclaration,
    isTSImportType: isTSImportType,
    isTSIndexSignature: isTSIndexSignature,
    isTSIndexedAccessType: isTSIndexedAccessType,
    isTSInferType: isTSInferType,
    isTSInstantiationExpression: isTSInstantiationExpression,
    isTSInterfaceBody: isTSInterfaceBody$1,
    isTSInterfaceDeclaration: isTSInterfaceDeclaration,
    isTSIntersectionType: isTSIntersectionType,
    isTSIntrinsicKeyword: isTSIntrinsicKeyword,
    isTSLiteralType: isTSLiteralType,
    isTSMappedType: isTSMappedType,
    isTSMethodSignature: isTSMethodSignature,
    isTSModuleBlock: isTSModuleBlock,
    isTSModuleDeclaration: isTSModuleDeclaration,
    isTSNamedTupleMember: isTSNamedTupleMember,
    isTSNamespaceExportDeclaration: isTSNamespaceExportDeclaration,
    isTSNeverKeyword: isTSNeverKeyword,
    isTSNonNullExpression: isTSNonNullExpression$1,
    isTSNullKeyword: isTSNullKeyword,
    isTSNumberKeyword: isTSNumberKeyword,
    isTSObjectKeyword: isTSObjectKeyword,
    isTSOptionalType: isTSOptionalType,
    isTSParameterProperty: isTSParameterProperty,
    isTSParenthesizedType: isTSParenthesizedType,
    isTSPropertySignature: isTSPropertySignature,
    isTSQualifiedName: isTSQualifiedName,
    isTSRestType: isTSRestType,
    isTSSatisfiesExpression: isTSSatisfiesExpression$1,
    isTSStringKeyword: isTSStringKeyword,
    isTSSymbolKeyword: isTSSymbolKeyword,
    isTSThisType: isTSThisType,
    isTSTupleType: isTSTupleType,
    isTSType: isTSType$1,
    isTSTypeAliasDeclaration: isTSTypeAliasDeclaration,
    isTSTypeAnnotation: isTSTypeAnnotation$1,
    isTSTypeAssertion: isTSTypeAssertion$1,
    isTSTypeElement: isTSTypeElement,
    isTSTypeLiteral: isTSTypeLiteral,
    isTSTypeOperator: isTSTypeOperator,
    isTSTypeParameter: isTSTypeParameter,
    isTSTypeParameterDeclaration: isTSTypeParameterDeclaration,
    isTSTypeParameterInstantiation: isTSTypeParameterInstantiation,
    isTSTypePredicate: isTSTypePredicate,
    isTSTypeQuery: isTSTypeQuery,
    isTSTypeReference: isTSTypeReference$1,
    isTSUndefinedKeyword: isTSUndefinedKeyword,
    isTSUnionType: isTSUnionType,
    isTSUnknownKeyword: isTSUnknownKeyword,
    isTSVoidKeyword: isTSVoidKeyword,
    isTaggedTemplateExpression: isTaggedTemplateExpression$1,
    isTemplateElement: isTemplateElement,
    isTemplateLiteral: isTemplateLiteral$1,
    isTerminatorless: isTerminatorless,
    isThisExpression: isThisExpression$2,
    isThisTypeAnnotation: isThisTypeAnnotation,
    isThrowStatement: isThrowStatement,
    isTopicReference: isTopicReference$1,
    isTryStatement: isTryStatement,
    isTupleExpression: isTupleExpression$1,
    isTupleTypeAnnotation: isTupleTypeAnnotation$1,
    isType: isType$2,
    isTypeAlias: isTypeAlias,
    isTypeAnnotation: isTypeAnnotation$1,
    isTypeCastExpression: isTypeCastExpression$1,
    isTypeParameter: isTypeParameter,
    isTypeParameterDeclaration: isTypeParameterDeclaration,
    isTypeParameterInstantiation: isTypeParameterInstantiation,
    isTypeScript: isTypeScript,
    isTypeofTypeAnnotation: isTypeofTypeAnnotation,
    isUnaryExpression: isUnaryExpression$1,
    isUnaryLike: isUnaryLike,
    isUnionTypeAnnotation: isUnionTypeAnnotation$1,
    isUpdateExpression: isUpdateExpression$1,
    isUserWhitespacable: isUserWhitespacable,
    isV8IntrinsicIdentifier: isV8IntrinsicIdentifier,
    isValidES3Identifier: isValidES3Identifier,
    isValidIdentifier: isValidIdentifier$1,
    isVar: isVar$1,
    isVariableDeclaration: isVariableDeclaration$3,
    isVariableDeclarator: isVariableDeclarator,
    isVariance: isVariance,
    isVoidTypeAnnotation: isVoidTypeAnnotation$1,
    isWhile: isWhile,
    isWhileStatement: isWhileStatement,
    isWithStatement: isWithStatement,
    isYieldExpression: isYieldExpression$1,
    jSXAttribute: jsxAttribute,
    jSXClosingElement: jsxClosingElement,
    jSXClosingFragment: jsxClosingFragment,
    jSXElement: jsxElement,
    jSXEmptyExpression: jsxEmptyExpression,
    jSXExpressionContainer: jsxExpressionContainer$1,
    jSXFragment: jsxFragment,
    jSXIdentifier: jsxIdentifier$1,
    jSXMemberExpression: jsxMemberExpression,
    jSXNamespacedName: jsxNamespacedName,
    jSXOpeningElement: jsxOpeningElement,
    jSXOpeningFragment: jsxOpeningFragment,
    jSXSpreadAttribute: jsxSpreadAttribute,
    jSXSpreadChild: jsxSpreadChild,
    jSXText: jsxText,
    jsxAttribute: jsxAttribute,
    jsxClosingElement: jsxClosingElement,
    jsxClosingFragment: jsxClosingFragment,
    jsxElement: jsxElement,
    jsxEmptyExpression: jsxEmptyExpression,
    jsxExpressionContainer: jsxExpressionContainer$1,
    jsxFragment: jsxFragment,
    jsxIdentifier: jsxIdentifier$1,
    jsxMemberExpression: jsxMemberExpression,
    jsxNamespacedName: jsxNamespacedName,
    jsxOpeningElement: jsxOpeningElement,
    jsxOpeningFragment: jsxOpeningFragment,
    jsxSpreadAttribute: jsxSpreadAttribute,
    jsxSpreadChild: jsxSpreadChild,
    jsxText: jsxText,
    labeledStatement: labeledStatement,
    logicalExpression: logicalExpression$2,
    matchesPattern: matchesPattern$2,
    memberExpression: memberExpression$9,
    metaProperty: metaProperty$1,
    mixedTypeAnnotation: mixedTypeAnnotation,
    moduleExpression: moduleExpression,
    newExpression: newExpression,
    noop: noop$1,
    nullLiteral: nullLiteral$2,
    nullLiteralTypeAnnotation: nullLiteralTypeAnnotation$1,
    nullableTypeAnnotation: nullableTypeAnnotation,
    numberLiteral: NumberLiteral,
    numberLiteralTypeAnnotation: numberLiteralTypeAnnotation,
    numberTypeAnnotation: numberTypeAnnotation$2,
    numericLiteral: numericLiteral$5,
    objectExpression: objectExpression$3,
    objectMethod: objectMethod,
    objectPattern: objectPattern$1,
    objectProperty: objectProperty$1,
    objectTypeAnnotation: objectTypeAnnotation,
    objectTypeCallProperty: objectTypeCallProperty,
    objectTypeIndexer: objectTypeIndexer,
    objectTypeInternalSlot: objectTypeInternalSlot,
    objectTypeProperty: objectTypeProperty,
    objectTypeSpreadProperty: objectTypeSpreadProperty,
    opaqueType: opaqueType,
    optionalCallExpression: optionalCallExpression$2,
    optionalIndexedAccessType: optionalIndexedAccessType,
    optionalMemberExpression: optionalMemberExpression$2,
    parenthesizedExpression: parenthesizedExpression,
    pipelineBareFunction: pipelineBareFunction,
    pipelinePrimaryTopicReference: pipelinePrimaryTopicReference,
    pipelineTopicExpression: pipelineTopicExpression,
    placeholder: placeholder,
    prependToMemberExpression: prependToMemberExpression,
    privateName: privateName,
    program: program$3,
    qualifiedTypeIdentifier: qualifiedTypeIdentifier,
    react: react$3,
    recordExpression: recordExpression,
    regExpLiteral: regExpLiteral,
    regexLiteral: RegexLiteral,
    removeComments: removeComments$1,
    removeProperties: removeProperties$1,
    removePropertiesDeep: removePropertiesDeep$1,
    removeTypeDuplicates: removeTypeDuplicates$1,
    restElement: restElement$2,
    restProperty: RestProperty$1,
    returnStatement: returnStatement$3,
    sequenceExpression: sequenceExpression$6,
    shallowEqual: shallowEqual,
    spreadElement: spreadElement$2,
    spreadProperty: SpreadProperty$1,
    staticBlock: staticBlock,
    stringLiteral: stringLiteral$6,
    stringLiteralTypeAnnotation: stringLiteralTypeAnnotation,
    stringTypeAnnotation: stringTypeAnnotation$2,
    super: _super$1,
    switchCase: switchCase,
    switchStatement: switchStatement,
    symbolTypeAnnotation: symbolTypeAnnotation,
    tSAnyKeyword: tsAnyKeyword,
    tSArrayType: tsArrayType,
    tSAsExpression: tsAsExpression,
    tSBigIntKeyword: tsBigIntKeyword,
    tSBooleanKeyword: tsBooleanKeyword,
    tSCallSignatureDeclaration: tsCallSignatureDeclaration,
    tSConditionalType: tsConditionalType,
    tSConstructSignatureDeclaration: tsConstructSignatureDeclaration,
    tSConstructorType: tsConstructorType,
    tSDeclareFunction: tsDeclareFunction,
    tSDeclareMethod: tsDeclareMethod,
    tSEnumBody: tsEnumBody,
    tSEnumDeclaration: tsEnumDeclaration,
    tSEnumMember: tsEnumMember,
    tSExportAssignment: tsExportAssignment,
    tSExpressionWithTypeArguments: tsExpressionWithTypeArguments,
    tSExternalModuleReference: tsExternalModuleReference,
    tSFunctionType: tsFunctionType,
    tSImportEqualsDeclaration: tsImportEqualsDeclaration,
    tSImportType: tsImportType,
    tSIndexSignature: tsIndexSignature,
    tSIndexedAccessType: tsIndexedAccessType,
    tSInferType: tsInferType,
    tSInstantiationExpression: tsInstantiationExpression,
    tSInterfaceBody: tsInterfaceBody,
    tSInterfaceDeclaration: tsInterfaceDeclaration,
    tSIntersectionType: tsIntersectionType,
    tSIntrinsicKeyword: tsIntrinsicKeyword,
    tSLiteralType: tsLiteralType,
    tSMappedType: tsMappedType,
    tSMethodSignature: tsMethodSignature,
    tSModuleBlock: tsModuleBlock,
    tSModuleDeclaration: tsModuleDeclaration,
    tSNamedTupleMember: tsNamedTupleMember,
    tSNamespaceExportDeclaration: tsNamespaceExportDeclaration,
    tSNeverKeyword: tsNeverKeyword,
    tSNonNullExpression: tsNonNullExpression,
    tSNullKeyword: tsNullKeyword,
    tSNumberKeyword: tsNumberKeyword,
    tSObjectKeyword: tsObjectKeyword,
    tSOptionalType: tsOptionalType,
    tSParameterProperty: tsParameterProperty,
    tSParenthesizedType: tsParenthesizedType,
    tSPropertySignature: tsPropertySignature,
    tSQualifiedName: tsQualifiedName,
    tSRestType: tsRestType,
    tSSatisfiesExpression: tsSatisfiesExpression,
    tSStringKeyword: tsStringKeyword,
    tSSymbolKeyword: tsSymbolKeyword,
    tSThisType: tsThisType,
    tSTupleType: tsTupleType,
    tSTypeAliasDeclaration: tsTypeAliasDeclaration,
    tSTypeAnnotation: tsTypeAnnotation,
    tSTypeAssertion: tsTypeAssertion,
    tSTypeLiteral: tsTypeLiteral,
    tSTypeOperator: tsTypeOperator,
    tSTypeParameter: tsTypeParameter,
    tSTypeParameterDeclaration: tsTypeParameterDeclaration,
    tSTypeParameterInstantiation: tsTypeParameterInstantiation,
    tSTypePredicate: tsTypePredicate,
    tSTypeQuery: tsTypeQuery,
    tSTypeReference: tsTypeReference,
    tSUndefinedKeyword: tsUndefinedKeyword,
    tSUnionType: tsUnionType,
    tSUnknownKeyword: tsUnknownKeyword,
    tSVoidKeyword: tsVoidKeyword,
    taggedTemplateExpression: taggedTemplateExpression,
    templateElement: templateElement,
    templateLiteral: templateLiteral,
    thisExpression: thisExpression$4,
    thisTypeAnnotation: thisTypeAnnotation,
    throwStatement: throwStatement,
    toBindingIdentifierName: toBindingIdentifierName$1,
    toBlock: toBlock,
    toComputedKey: toComputedKey$1,
    toExpression: toExpression$1,
    toIdentifier: toIdentifier$1,
    toKeyAlias: toKeyAlias,
    toStatement: toStatement,
    topicReference: topicReference,
    traverse: traverse$2,
    traverseFast: traverseFast$3,
    tryStatement: tryStatement,
    tsAnyKeyword: tsAnyKeyword,
    tsArrayType: tsArrayType,
    tsAsExpression: tsAsExpression,
    tsBigIntKeyword: tsBigIntKeyword,
    tsBooleanKeyword: tsBooleanKeyword,
    tsCallSignatureDeclaration: tsCallSignatureDeclaration,
    tsConditionalType: tsConditionalType,
    tsConstructSignatureDeclaration: tsConstructSignatureDeclaration,
    tsConstructorType: tsConstructorType,
    tsDeclareFunction: tsDeclareFunction,
    tsDeclareMethod: tsDeclareMethod,
    tsEnumBody: tsEnumBody,
    tsEnumDeclaration: tsEnumDeclaration,
    tsEnumMember: tsEnumMember,
    tsExportAssignment: tsExportAssignment,
    tsExpressionWithTypeArguments: tsExpressionWithTypeArguments,
    tsExternalModuleReference: tsExternalModuleReference,
    tsFunctionType: tsFunctionType,
    tsImportEqualsDeclaration: tsImportEqualsDeclaration,
    tsImportType: tsImportType,
    tsIndexSignature: tsIndexSignature,
    tsIndexedAccessType: tsIndexedAccessType,
    tsInferType: tsInferType,
    tsInstantiationExpression: tsInstantiationExpression,
    tsInterfaceBody: tsInterfaceBody,
    tsInterfaceDeclaration: tsInterfaceDeclaration,
    tsIntersectionType: tsIntersectionType,
    tsIntrinsicKeyword: tsIntrinsicKeyword,
    tsLiteralType: tsLiteralType,
    tsMappedType: tsMappedType,
    tsMethodSignature: tsMethodSignature,
    tsModuleBlock: tsModuleBlock,
    tsModuleDeclaration: tsModuleDeclaration,
    tsNamedTupleMember: tsNamedTupleMember,
    tsNamespaceExportDeclaration: tsNamespaceExportDeclaration,
    tsNeverKeyword: tsNeverKeyword,
    tsNonNullExpression: tsNonNullExpression,
    tsNullKeyword: tsNullKeyword,
    tsNumberKeyword: tsNumberKeyword,
    tsObjectKeyword: tsObjectKeyword,
    tsOptionalType: tsOptionalType,
    tsParameterProperty: tsParameterProperty,
    tsParenthesizedType: tsParenthesizedType,
    tsPropertySignature: tsPropertySignature,
    tsQualifiedName: tsQualifiedName,
    tsRestType: tsRestType,
    tsSatisfiesExpression: tsSatisfiesExpression,
    tsStringKeyword: tsStringKeyword,
    tsSymbolKeyword: tsSymbolKeyword,
    tsThisType: tsThisType,
    tsTupleType: tsTupleType,
    tsTypeAliasDeclaration: tsTypeAliasDeclaration,
    tsTypeAnnotation: tsTypeAnnotation,
    tsTypeAssertion: tsTypeAssertion,
    tsTypeLiteral: tsTypeLiteral,
    tsTypeOperator: tsTypeOperator,
    tsTypeParameter: tsTypeParameter,
    tsTypeParameterDeclaration: tsTypeParameterDeclaration,
    tsTypeParameterInstantiation: tsTypeParameterInstantiation,
    tsTypePredicate: tsTypePredicate,
    tsTypeQuery: tsTypeQuery,
    tsTypeReference: tsTypeReference,
    tsUndefinedKeyword: tsUndefinedKeyword,
    tsUnionType: tsUnionType,
    tsUnknownKeyword: tsUnknownKeyword,
    tsVoidKeyword: tsVoidKeyword,
    tupleExpression: tupleExpression,
    tupleTypeAnnotation: tupleTypeAnnotation$1,
    typeAlias: typeAlias,
    typeAnnotation: typeAnnotation,
    typeCastExpression: typeCastExpression,
    typeParameter: typeParameter,
    typeParameterDeclaration: typeParameterDeclaration,
    typeParameterInstantiation: typeParameterInstantiation,
    typeofTypeAnnotation: typeofTypeAnnotation,
    unaryExpression: unaryExpression$4,
    unionTypeAnnotation: unionTypeAnnotation$1,
    updateExpression: updateExpression$1,
    v8IntrinsicIdentifier: v8IntrinsicIdentifier,
    validate: validate$6,
    valueToNode: valueToNode,
    variableDeclaration: variableDeclaration$6,
    variableDeclarator: variableDeclarator$6,
    variance: variance,
    voidTypeAnnotation: voidTypeAnnotation$3,
    whileStatement: whileStatement,
    withStatement: withStatement,
    yieldExpression: yieldExpression$2
  });

var code = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
  var ModuleErrors = {
    ImportMetaOutsideModule: {
      message: "import.meta may appear only with 'sourceType: \"module\"'",
      code: code
    },
    ImportOutsideModule: {
      message: "'import' and 'export' may appear only with 'sourceType: \"module\"'",
      code: code
    }
  };

var _templateObject$K;
  var _excluded$3 = ["message"];
  function defineHidden(obj, key, value) {
    Object.defineProperty(obj, key, {
      enumerable: false,
      configurable: true,
      value: value
    });
  }
  function toParseErrorConstructor(_ref) {
    var toMessage = _ref.toMessage,
      code = _ref.code,
      reasonCode = _ref.reasonCode,
      syntaxPlugin = _ref.syntaxPlugin;
    var hasMissingPlugin = reasonCode === "MissingPlugin" || reasonCode === "MissingOneOfPlugins";
    {
      var oldReasonCodes = {
        AccessorCannotDeclareThisParameter: "AccesorCannotDeclareThisParameter",
        AccessorCannotHaveTypeParameters: "AccesorCannotHaveTypeParameters",
        ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference",
        SetAccessorCannotHaveOptionalParameter: "SetAccesorCannotHaveOptionalParameter",
        SetAccessorCannotHaveRestParameter: "SetAccesorCannotHaveRestParameter",
        SetAccessorCannotHaveReturnType: "SetAccesorCannotHaveReturnType"
      };
      if (oldReasonCodes[reasonCode]) {
        reasonCode = oldReasonCodes[reasonCode];
      }
    }
    return function constructor(loc, details) {
      var error = new SyntaxError();
      error.code = code;
      error.reasonCode = reasonCode;
      error.loc = loc;
      error.pos = loc.index;
      error.syntaxPlugin = syntaxPlugin;
      if (hasMissingPlugin) {
        error.missingPlugin = details.missingPlugin;
      }
      defineHidden(error, "clone", function clone(overrides) {
        var _overrides$loc;
        if (overrides === void 0) {
          overrides = {};
        }
        var _ref2 = (_overrides$loc = overrides.loc) != null ? _overrides$loc : loc,
          line = _ref2.line,
          column = _ref2.column,
          index = _ref2.index;
        return constructor(new Position(line, column, index), Object.assign({}, details, overrides.details));
      });
      defineHidden(error, "details", details);
      Object.defineProperty(error, "message", {
        configurable: true,
        get: function get() {
          var message = toMessage(details) + " (" + loc.line + ":" + loc.column + ")";
          this.message = message;
          return message;
        },
        set: function set(value) {
          Object.defineProperty(this, "message", {
            value: value,
            writable: true
          });
        }
      });
      return error;
    };
  }
  function ParseErrorEnum(argument, syntaxPlugin) {
    if (Array.isArray(argument)) {
      return function (parseErrorTemplates) {
        return ParseErrorEnum(parseErrorTemplates, argument[0]);
      };
    }
    var ParseErrorConstructors = {};
    var _loop = function _loop() {
      var reasonCode = _Object$keys2[_i2];
      var template = argument[reasonCode];
      var _ref3 = typeof template === "string" ? {
          message: function message() {
            return template;
          }
        } : typeof template === "function" ? {
          message: template
        } : template,
        message = _ref3.message,
        rest = _objectWithoutPropertiesLoose(_ref3, _excluded$3);
      var toMessage = typeof message === "string" ? function () {
        return message;
      } : message;
      ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({
        code: "BABEL_PARSER_SYNTAX_ERROR",
        reasonCode: reasonCode,
        toMessage: toMessage
      }, syntaxPlugin ? {
        syntaxPlugin: syntaxPlugin
      } : {}, rest));
    };
    for (var _i2 = 0, _Object$keys2 = Object.keys(argument); _i2 < _Object$keys2.length; _i2++) {
      _loop();
    }
    return ParseErrorConstructors;
  }
  var Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum(_templateObject$K || (_templateObject$K = _taggedTemplateLiteralLoose(["pipelineOperator"])))(PipelineOperatorErrors));

function isIteratorStart(current, next, next2) {
    return current === 64 && next === 64 && isIdentifierStart(next2);
  }
  var reservedWordLikeSet = 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 _templateObject$J;
  var reservedTypes = new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]);
  var FlowErrors = ParseErrorEnum(_templateObject$J || (_templateObject$J = _taggedTemplateLiteralLoose(["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: function AssignReservedType(_ref) {
      var reservedType = _ref.reservedType;
      return "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: function EnumBooleanMemberNotInitialized(_ref2) {
      var memberName = _ref2.memberName,
        enumName = _ref2.enumName;
      return "Boolean enum members need to be initialized. Use either `" + memberName + " = true,` or `" + memberName + " = false,` in enum `" + enumName + "`.";
    },
    EnumDuplicateMemberName: function EnumDuplicateMemberName(_ref3) {
      var memberName = _ref3.memberName,
        enumName = _ref3.enumName;
      return "Enum member names need to be unique, but the name `" + memberName + "` has already been used before in enum `" + enumName + "`.";
    },
    EnumInconsistentMemberValues: function EnumInconsistentMemberValues(_ref4) {
      var enumName = _ref4.enumName;
      return "Enum `" + enumName + "` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.";
    },
    EnumInvalidExplicitType: function EnumInvalidExplicitType(_ref5) {
      var invalidEnumType = _ref5.invalidEnumType,
        enumName = _ref5.enumName;
      return "Enum type `" + invalidEnumType + "` is not valid. Use one of `boolean`, `number`, `string`, or `symbol` in enum `" + enumName + "`.";
    },
    EnumInvalidExplicitTypeUnknownSupplied: function EnumInvalidExplicitTypeUnknownSupplied(_ref6) {
      var enumName = _ref6.enumName;
      return "Supplied enum type is not valid. Use one of `boolean`, `number`, `string`, or `symbol` in enum `" + enumName + "`.";
    },
    EnumInvalidMemberInitializerPrimaryType: function EnumInvalidMemberInitializerPrimaryType(_ref7) {
      var enumName = _ref7.enumName,
        memberName = _ref7.memberName,
        explicitType = _ref7.explicitType;
      return "Enum `" + enumName + "` has type `" + explicitType + "`, so the initializer of `" + memberName + "` needs to be a " + explicitType + " literal.";
    },
    EnumInvalidMemberInitializerSymbolType: function EnumInvalidMemberInitializerSymbolType(_ref8) {
      var enumName = _ref8.enumName,
        memberName = _ref8.memberName;
      return "Symbol enum members cannot be initialized. Use `" + memberName + ",` in enum `" + enumName + "`.";
    },
    EnumInvalidMemberInitializerUnknownType: function EnumInvalidMemberInitializerUnknownType(_ref9) {
      var enumName = _ref9.enumName,
        memberName = _ref9.memberName;
      return "The enum member initializer for `" + memberName + "` needs to be a literal (either a boolean, number, or string) in enum `" + enumName + "`.";
    },
    EnumInvalidMemberName: function EnumInvalidMemberName(_ref10) {
      var enumName = _ref10.enumName,
        memberName = _ref10.memberName,
        suggestion = _ref10.suggestion;
      return "Enum member names cannot start with lowercase 'a' through 'z'. Instead of using `" + memberName + "`, consider using `" + suggestion + "`, in enum `" + enumName + "`.";
    },
    EnumNumberMemberNotInitialized: function EnumNumberMemberNotInitialized(_ref11) {
      var enumName = _ref11.enumName,
        memberName = _ref11.memberName;
      return "Number enum members need to be initialized, e.g. `" + memberName + " = 1` in enum `" + enumName + "`.";
    },
    EnumStringMemberInconsistentlyInitialized: function EnumStringMemberInconsistentlyInitialized(_ref12) {
      var enumName = _ref12.enumName;
      return "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: function UnexpectedReservedType(_ref13) {
      var reservedType = _ref13.reservedType;
      return "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: function UnsupportedDeclareExportKind(_ref14) {
      var unsupportedExportKind = _ref14.unsupportedExportKind,
        suggestion = _ref14.suggestion;
      return "`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(node) {
    return node.importKind === "type" || node.importKind === "typeof";
  }
  var exportSuggestions = {
    "const": "declare export var",
    "let": "declare export var",
    type: "export type",
    "interface": "export interface"
  };
  function partition(list, test) {
    var list1 = [];
    var list2 = [];
    for (var i = 0; i < list.length; i++) {
      (test(list[i], i, list) ? list1 : list2).push(list[i]);
    }
    return [list1, list2];
  }
  var FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/;
  var flow = (function (superClass) {
    return function (_superClass) {
      function FlowParserMixin() {
        var _this2;
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }
        _this2 = _superClass.call.apply(_superClass, [this].concat(args)) || this;
        _this2.flowPragma = undefined;
        return _this2;
      }
      _inherits(FlowParserMixin, _superClass);
      var _proto = FlowParserMixin.prototype;
      _proto.getScopeHandler = function getScopeHandler() {
        return FlowScopeHandler;
      };
      _proto.shouldParseTypes = function shouldParseTypes() {
        return this.getPluginOption("flow", "all") || this.flowPragma === "flow";
      };
      _proto.finishToken = function finishToken(type, val) {
        if (type !== 134 && type !== 13 && type !== 28) {
          if (this.flowPragma === undefined) {
            this.flowPragma = null;
          }
        }
        _superClass.prototype.finishToken.call(this, type, val);
      };
      _proto.addComment = function addComment(comment) {
        if (this.flowPragma === undefined) {
          var matches = FLOW_PRAGMA_REGEX.exec(comment.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");
          }
        }
        _superClass.prototype.addComment.call(this, comment);
      };
      _proto.flowParseTypeInitialiser = function flowParseTypeInitialiser(tok) {
        var oldInType = this.state.inType;
        this.state.inType = true;
        this.expect(tok || 14);
        var type = this.flowParseType();
        this.state.inType = oldInType;
        return type;
      };
      _proto.flowParsePredicate = function flowParsePredicate() {
        var node = this.startNode();
        var moduloLoc = this.state.startLoc;
        this.next();
        this.expectContextual(110);
        if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) {
          this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, moduloLoc);
        }
        if (this.eat(10)) {
          node.value = _superClass.prototype.parseExpression.call(this);
          this.expect(11);
          return this.finishNode(node, "DeclaredPredicate");
        } else {
          return this.finishNode(node, "InferredPredicate");
        }
      };
      _proto.flowParseTypeAndPredicateInitialiser = function flowParseTypeAndPredicateInitialiser() {
        var oldInType = this.state.inType;
        this.state.inType = true;
        this.expect(14);
        var type = null;
        var 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];
      };
      _proto.flowParseDeclareClass = function flowParseDeclareClass(node) {
        this.next();
        this.flowParseInterfaceish(node, true);
        return this.finishNode(node, "DeclareClass");
      };
      _proto.flowParseDeclareFunction = function flowParseDeclareFunction(node) {
        this.next();
        var id = node.id = this.parseIdentifier();
        var typeNode = this.startNode();
        var typeContainer = this.startNode();
        if (this.match(47)) {
          typeNode.typeParameters = this.flowParseTypeParameterDeclaration();
        } else {
          typeNode.typeParameters = null;
        }
        this.expect(10);
        var tmp = this.flowParseFunctionTypeParams();
        typeNode.params = tmp.params;
        typeNode.rest = tmp.rest;
        typeNode["this"] = tmp._this;
        this.expect(11);
        var _this$flowParseTypeAn = this.flowParseTypeAndPredicateInitialiser();
        typeNode.returnType = _this$flowParseTypeAn[0];
        node.predicate = _this$flowParseTypeAn[1];
        typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation");
        id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation");
        this.resetEndLocation(id);
        this.semicolon();
        this.scope.declareName(node.id.name, BindingFlag.TYPE_FLOW_DECLARE_FN, node.id.loc.start);
        return this.finishNode(node, "DeclareFunction");
      };
      _proto.flowParseDeclare = function flowParseDeclare(node, insideModule) {
        if (this.match(80)) {
          return this.flowParseDeclareClass(node);
        } else if (this.match(68)) {
          return this.flowParseDeclareFunction(node);
        } else if (this.match(74)) {
          return this.flowParseDeclareVariable(node);
        } else if (this.eatContextual(127)) {
          if (this.match(16)) {
            return this.flowParseDeclareModuleExports(node);
          } else {
            if (insideModule) {
              this.raise(FlowErrors.NestedDeclareModule, this.state.lastTokStartLoc);
            }
            return this.flowParseDeclareModule(node);
          }
        } else if (this.isContextual(130)) {
          return this.flowParseDeclareTypeAlias(node);
        } else if (this.isContextual(131)) {
          return this.flowParseDeclareOpaqueType(node);
        } else if (this.isContextual(129)) {
          return this.flowParseDeclareInterface(node);
        } else if (this.match(82)) {
          return this.flowParseDeclareExportDeclaration(node, insideModule);
        } else {
          this.unexpected();
        }
      };
      _proto.flowParseDeclareVariable = function flowParseDeclareVariable(node) {
        this.next();
        node.id = this.flowParseTypeAnnotatableIdentifier(true);
        this.scope.declareName(node.id.name, BindingFlag.TYPE_VAR, node.id.loc.start);
        this.semicolon();
        return this.finishNode(node, "DeclareVariable");
      };
      _proto.flowParseDeclareModule = function flowParseDeclareModule(node) {
        var _this3 = this;
        this.scope.enter(ScopeFlag.OTHER);
        if (this.match(134)) {
          node.id = _superClass.prototype.parseExprAtom.call(this);
        } else {
          node.id = this.parseIdentifier();
        }
        var bodyNode = node.body = this.startNode();
        var body = bodyNode.body = [];
        this.expect(5);
        while (!this.match(8)) {
          var _bodyNode = this.startNode();
          if (this.match(83)) {
            this.next();
            if (!this.isContextual(130) && !this.match(87)) {
              this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc);
            }
            _superClass.prototype.parseImport.call(this, _bodyNode);
          } else {
            this.expectContextual(125, FlowErrors.UnsupportedStatementInDeclareModule);
            _bodyNode = this.flowParseDeclare(_bodyNode, true);
          }
          body.push(_bodyNode);
        }
        this.scope.exit();
        this.expect(8);
        this.finishNode(bodyNode, "BlockStatement");
        var kind = null;
        var hasModuleExport = false;
        body.forEach(function (bodyElement) {
          if (isEsModuleType(bodyElement)) {
            if (kind === "CommonJS") {
              _this3.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
            }
            kind = "ES";
          } else if (bodyElement.type === "DeclareModuleExports") {
            if (hasModuleExport) {
              _this3.raise(FlowErrors.DuplicateDeclareModuleExports, bodyElement);
            }
            if (kind === "ES") {
              _this3.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
            }
            kind = "CommonJS";
            hasModuleExport = true;
          }
        });
        node.kind = kind || "CommonJS";
        return this.finishNode(node, "DeclareModule");
      };
      _proto.flowParseDeclareExportDeclaration = function flowParseDeclareExportDeclaration(node, insideModule) {
        this.expect(82);
        if (this.eat(65)) {
          if (this.match(68) || this.match(80)) {
            node.declaration = this.flowParseDeclare(this.startNode());
          } else {
            node.declaration = this.flowParseType();
            this.semicolon();
          }
          node["default"] = true;
          return this.finishNode(node, "DeclareExportDeclaration");
        } else {
          if (this.match(75) || this.isLet() || (this.isContextual(130) || this.isContextual(129)) && !insideModule) {
            var label = this.state.value;
            throw this.raise(FlowErrors.UnsupportedDeclareExportKind, this.state.startLoc, {
              unsupportedExportKind: label,
              suggestion: exportSuggestions[label]
            });
          }
          if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(131)) {
            node.declaration = this.flowParseDeclare(this.startNode());
            node["default"] = false;
            return this.finishNode(node, "DeclareExportDeclaration");
          } else if (this.match(55) || this.match(5) || this.isContextual(129) || this.isContextual(130) || this.isContextual(131)) {
            node = this.parseExport(node, null);
            if (node.type === "ExportNamedDeclaration") {
              node.type = "ExportDeclaration";
              node["default"] = false;
              delete node.exportKind;
            }
            node.type = "Declare" + node.type;
            return node;
          }
        }
        this.unexpected();
      };
      _proto.flowParseDeclareModuleExports = function flowParseDeclareModuleExports(node) {
        this.next();
        this.expectContextual(111);
        node.typeAnnotation = this.flowParseTypeAnnotation();
        this.semicolon();
        return this.finishNode(node, "DeclareModuleExports");
      };
      _proto.flowParseDeclareTypeAlias = function flowParseDeclareTypeAlias(node) {
        this.next();
        var finished = this.flowParseTypeAlias(node);
        finished.type = "DeclareTypeAlias";
        return finished;
      };
      _proto.flowParseDeclareOpaqueType = function flowParseDeclareOpaqueType(node) {
        this.next();
        var finished = this.flowParseOpaqueType(node, true);
        finished.type = "DeclareOpaqueType";
        return finished;
      };
      _proto.flowParseDeclareInterface = function flowParseDeclareInterface(node) {
        this.next();
        this.flowParseInterfaceish(node, false);
        return this.finishNode(node, "DeclareInterface");
      };
      _proto.flowParseInterfaceish = function flowParseInterfaceish(node, isClass) {
        node.id = this.flowParseRestrictedIdentifier(!isClass, true);
        this.scope.declareName(node.id.name, isClass ? BindingFlag.TYPE_FUNCTION : BindingFlag.TYPE_LEXICAL, node.id.loc.start);
        if (this.match(47)) {
          node.typeParameters = this.flowParseTypeParameterDeclaration();
        } else {
          node.typeParameters = null;
        }
        node["extends"] = [];
        if (this.eat(81)) {
          do {
            node["extends"].push(this.flowParseInterfaceExtends());
          } while (!isClass && this.eat(12));
        }
        if (isClass) {
          node["implements"] = [];
          node.mixins = [];
          if (this.eatContextual(117)) {
            do {
              node.mixins.push(this.flowParseInterfaceExtends());
            } while (this.eat(12));
          }
          if (this.eatContextual(113)) {
            do {
              node["implements"].push(this.flowParseInterfaceExtends());
            } while (this.eat(12));
          }
        }
        node.body = this.flowParseObjectType({
          allowStatic: isClass,
          allowExact: false,
          allowSpread: false,
          allowProto: isClass,
          allowInexact: false
        });
      };
      _proto.flowParseInterfaceExtends = function flowParseInterfaceExtends() {
        var node = this.startNode();
        node.id = this.flowParseQualifiedTypeIdentifier();
        if (this.match(47)) {
          node.typeParameters = this.flowParseTypeParameterInstantiation();
        } else {
          node.typeParameters = null;
        }
        return this.finishNode(node, "InterfaceExtends");
      };
      _proto.flowParseInterface = function flowParseInterface(node) {
        this.flowParseInterfaceish(node, false);
        return this.finishNode(node, "InterfaceDeclaration");
      };
      _proto.checkNotUnderscore = function checkNotUnderscore(word) {
        if (word === "_") {
          this.raise(FlowErrors.UnexpectedReservedUnderscore, this.state.startLoc);
        }
      };
      _proto.checkReservedType = function checkReservedType(word, startLoc, declaration) {
        if (!reservedTypes.has(word)) return;
        this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, startLoc, {
          reservedType: word
        });
      };
      _proto.flowParseRestrictedIdentifier = function flowParseRestrictedIdentifier(liberal, declaration) {
        this.checkReservedType(this.state.value, this.state.startLoc, declaration);
        return this.parseIdentifier(liberal);
      };
      _proto.flowParseTypeAlias = function flowParseTypeAlias(node) {
        node.id = this.flowParseRestrictedIdentifier(false, true);
        this.scope.declareName(node.id.name, BindingFlag.TYPE_LEXICAL, node.id.loc.start);
        if (this.match(47)) {
          node.typeParameters = this.flowParseTypeParameterDeclaration();
        } else {
          node.typeParameters = null;
        }
        node.right = this.flowParseTypeInitialiser(29);
        this.semicolon();
        return this.finishNode(node, "TypeAlias");
      };
      _proto.flowParseOpaqueType = function flowParseOpaqueType(node, declare) {
        this.expectContextual(130);
        node.id = this.flowParseRestrictedIdentifier(true, true);
        this.scope.declareName(node.id.name, BindingFlag.TYPE_LEXICAL, node.id.loc.start);
        if (this.match(47)) {
          node.typeParameters = this.flowParseTypeParameterDeclaration();
        } else {
          node.typeParameters = null;
        }
        node.supertype = null;
        if (this.match(14)) {
          node.supertype = this.flowParseTypeInitialiser(14);
        }
        node.impltype = null;
        if (!declare) {
          node.impltype = this.flowParseTypeInitialiser(29);
        }
        this.semicolon();
        return this.finishNode(node, "OpaqueType");
      };
      _proto.flowParseTypeParameter = function flowParseTypeParameter(requireDefault) {
        if (requireDefault === void 0) {
          requireDefault = false;
        }
        var nodeStartLoc = this.state.startLoc;
        var node = this.startNode();
        var variance = this.flowParseVariance();
        var ident = this.flowParseTypeAnnotatableIdentifier();
        node.name = ident.name;
        node.variance = variance;
        node.bound = ident.typeAnnotation;
        if (this.match(29)) {
          this.eat(29);
          node["default"] = this.flowParseType();
        } else {
          if (requireDefault) {
            this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc);
          }
        }
        return this.finishNode(node, "TypeParameter");
      };
      _proto.flowParseTypeParameterDeclaration = function flowParseTypeParameterDeclaration() {
        var oldInType = this.state.inType;
        var node = this.startNode();
        node.params = [];
        this.state.inType = true;
        if (this.match(47) || this.match(143)) {
          this.next();
        } else {
          this.unexpected();
        }
        var defaultRequired = false;
        do {
          var typeParameter = this.flowParseTypeParameter(defaultRequired);
          node.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(node, "TypeParameterDeclaration");
      };
      _proto.flowInTopLevelContext = function flowInTopLevelContext(cb) {
        if (this.curContext() !== types.brace) {
          var oldContext = this.state.context;
          this.state.context = [oldContext[0]];
          try {
            return cb();
          } finally {
            this.state.context = oldContext;
          }
        } else {
          return cb();
        }
      };
      _proto.flowParseTypeParameterInstantiationInExpression = function flowParseTypeParameterInstantiationInExpression() {
        if (this.reScan_lt() !== 47) return;
        return this.flowParseTypeParameterInstantiation();
      };
      _proto.flowParseTypeParameterInstantiation = function flowParseTypeParameterInstantiation() {
        var _this4 = this;
        var node = this.startNode();
        var oldInType = this.state.inType;
        this.state.inType = true;
        node.params = [];
        this.flowInTopLevelContext(function () {
          _this4.expect(47);
          var oldNoAnonFunctionType = _this4.state.noAnonFunctionType;
          _this4.state.noAnonFunctionType = false;
          while (!_this4.match(48)) {
            node.params.push(_this4.flowParseType());
            if (!_this4.match(48)) {
              _this4.expect(12);
            }
          }
          _this4.state.noAnonFunctionType = oldNoAnonFunctionType;
        });
        this.state.inType = oldInType;
        if (!this.state.inType && this.curContext() === types.brace) {
          this.reScan_lt_gt();
        }
        this.expect(48);
        return this.finishNode(node, "TypeParameterInstantiation");
      };
      _proto.flowParseTypeParameterInstantiationCallOrNew = function flowParseTypeParameterInstantiationCallOrNew() {
        if (this.reScan_lt() !== 47) return;
        var node = this.startNode();
        var oldInType = this.state.inType;
        node.params = [];
        this.state.inType = true;
        this.expect(47);
        while (!this.match(48)) {
          node.params.push(this.flowParseTypeOrImplicitInstantiation());
          if (!this.match(48)) {
            this.expect(12);
          }
        }
        this.expect(48);
        this.state.inType = oldInType;
        return this.finishNode(node, "TypeParameterInstantiation");
      };
      _proto.flowParseInterfaceType = function flowParseInterfaceType() {
        var node = this.startNode();
        this.expectContextual(129);
        node["extends"] = [];
        if (this.eat(81)) {
          do {
            node["extends"].push(this.flowParseInterfaceExtends());
          } while (this.eat(12));
        }
        node.body = this.flowParseObjectType({
          allowStatic: false,
          allowExact: false,
          allowSpread: false,
          allowProto: false,
          allowInexact: false
        });
        return this.finishNode(node, "InterfaceTypeAnnotation");
      };
      _proto.flowParseObjectPropertyKey = function flowParseObjectPropertyKey() {
        return this.match(135) || this.match(134) ? _superClass.prototype.parseExprAtom.call(this) : this.parseIdentifier(true);
      };
      _proto.flowParseObjectTypeIndexer = function flowParseObjectTypeIndexer(node, isStatic, variance) {
        node["static"] = isStatic;
        if (this.lookahead().type === 14) {
          node.id = this.flowParseObjectPropertyKey();
          node.key = this.flowParseTypeInitialiser();
        } else {
          node.id = null;
          node.key = this.flowParseType();
        }
        this.expect(3);
        node.value = this.flowParseTypeInitialiser();
        node.variance = variance;
        return this.finishNode(node, "ObjectTypeIndexer");
      };
      _proto.flowParseObjectTypeInternalSlot = function flowParseObjectTypeInternalSlot(node, isStatic) {
        node["static"] = isStatic;
        node.id = this.flowParseObjectPropertyKey();
        this.expect(3);
        this.expect(3);
        if (this.match(47) || this.match(10)) {
          node.method = true;
          node.optional = false;
          node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
        } else {
          node.method = false;
          if (this.eat(17)) {
            node.optional = true;
          }
          node.value = this.flowParseTypeInitialiser();
        }
        return this.finishNode(node, "ObjectTypeInternalSlot");
      };
      _proto.flowParseObjectTypeMethodish = function flowParseObjectTypeMethodish(node) {
        node.params = [];
        node.rest = null;
        node.typeParameters = null;
        node["this"] = null;
        if (this.match(47)) {
          node.typeParameters = this.flowParseTypeParameterDeclaration();
        }
        this.expect(10);
        if (this.match(78)) {
          node["this"] = this.flowParseFunctionTypeParam(true);
          node["this"].name = null;
          if (!this.match(11)) {
            this.expect(12);
          }
        }
        while (!this.match(11) && !this.match(21)) {
          node.params.push(this.flowParseFunctionTypeParam(false));
          if (!this.match(11)) {
            this.expect(12);
          }
        }
        if (this.eat(21)) {
          node.rest = this.flowParseFunctionTypeParam(false);
        }
        this.expect(11);
        node.returnType = this.flowParseTypeInitialiser();
        return this.finishNode(node, "FunctionTypeAnnotation");
      };
      _proto.flowParseObjectTypeCallProperty = function flowParseObjectTypeCallProperty(node, isStatic) {
        var valueNode = this.startNode();
        node["static"] = isStatic;
        node.value = this.flowParseObjectTypeMethodish(valueNode);
        return this.finishNode(node, "ObjectTypeCallProperty");
      };
      _proto.flowParseObjectType = function flowParseObjectType(_ref15) {
        var allowStatic = _ref15.allowStatic,
          allowExact = _ref15.allowExact,
          allowSpread = _ref15.allowSpread,
          allowProto = _ref15.allowProto,
          allowInexact = _ref15.allowInexact;
        var oldInType = this.state.inType;
        this.state.inType = true;
        var nodeStart = this.startNode();
        nodeStart.callProperties = [];
        nodeStart.properties = [];
        nodeStart.indexers = [];
        nodeStart.internalSlots = [];
        var endDelim;
        var exact;
        var 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)) {
          var isStatic = false;
          var protoStartLoc = null;
          var inexactStartLoc = null;
          var node = this.startNode();
          if (allowProto && this.isContextual(118)) {
            var lookahead = this.lookahead();
            if (lookahead.type !== 14 && lookahead.type !== 17) {
              this.next();
              protoStartLoc = this.state.startLoc;
              allowStatic = false;
            }
          }
          if (allowStatic && this.isContextual(106)) {
            var _lookahead = this.lookahead();
            if (_lookahead.type !== 14 && _lookahead.type !== 17) {
              this.next();
              isStatic = true;
            }
          }
          var 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(node, isStatic));
            } else {
              nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, 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(node, isStatic));
          } else {
            var kind = "init";
            if (this.isContextual(99) || this.isContextual(104)) {
              var _lookahead2 = this.lookahead();
              if (tokenIsLiteralPropertyName(_lookahead2.type)) {
                kind = this.state.value;
                this.next();
              }
            }
            var propOrInexact = this.flowParseObjectTypeProperty(node, 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, inexactStartLoc);
          }
        }
        this.expect(endDelim);
        if (allowSpread) {
          nodeStart.inexact = inexact;
        }
        var out = this.finishNode(nodeStart, "ObjectTypeAnnotation");
        this.state.inType = oldInType;
        return out;
      };
      _proto.flowParseObjectTypeProperty = function flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) {
        if (this.eat(21)) {
          var isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9);
          if (isInexactToken) {
            if (!allowSpread) {
              this.raise(FlowErrors.InexactInsideNonObject, this.state.lastTokStartLoc);
            } else if (!allowInexact) {
              this.raise(FlowErrors.InexactInsideExact, this.state.lastTokStartLoc);
            }
            if (variance) {
              this.raise(FlowErrors.InexactVariance, variance);
            }
            return null;
          }
          if (!allowSpread) {
            this.raise(FlowErrors.UnexpectedSpreadType, this.state.lastTokStartLoc);
          }
          if (protoStartLoc != null) {
            this.unexpected(protoStartLoc);
          }
          if (variance) {
            this.raise(FlowErrors.SpreadVariance, variance);
          }
          node.argument = this.flowParseType();
          return this.finishNode(node, "ObjectTypeSpreadProperty");
        } else {
          node.key = this.flowParseObjectPropertyKey();
          node["static"] = isStatic;
          node.proto = protoStartLoc != null;
          node.kind = kind;
          var optional = false;
          if (this.match(47) || this.match(10)) {
            node.method = true;
            if (protoStartLoc != null) {
              this.unexpected(protoStartLoc);
            }
            if (variance) {
              this.unexpected(variance.loc.start);
            }
            node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
            if (kind === "get" || kind === "set") {
              this.flowCheckGetterSetterParams(node);
            }
            if (!allowSpread && node.key.name === "constructor" && node.value["this"]) {
              this.raise(FlowErrors.ThisParamBannedInConstructor, node.value["this"]);
            }
          } else {
            if (kind !== "init") this.unexpected();
            node.method = false;
            if (this.eat(17)) {
              optional = true;
            }
            node.value = this.flowParseTypeInitialiser();
            node.variance = variance;
          }
          node.optional = optional;
          return this.finishNode(node, "ObjectTypeProperty");
        }
      };
      _proto.flowCheckGetterSetterParams = function flowCheckGetterSetterParams(property) {
        var paramCount = property.kind === "get" ? 0 : 1;
        var length = property.value.params.length + (property.value.rest ? 1 : 0);
        if (property.value["this"]) {
          this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, property.value["this"]);
        }
        if (length !== paramCount) {
          this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, property);
        }
        if (property.kind === "set" && property.value.rest) {
          this.raise(Errors.BadSetterRestParameter, property);
        }
      };
      _proto.flowObjectTypeSemicolon = function flowObjectTypeSemicolon() {
        if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) {
          this.unexpected();
        }
      };
      _proto.flowParseQualifiedTypeIdentifier = function flowParseQualifiedTypeIdentifier(startLoc, id) {
        var _startLoc;
        (_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
        var node = id || this.flowParseRestrictedIdentifier(true);
        while (this.eat(16)) {
          var node2 = this.startNodeAt(startLoc);
          node2.qualification = node;
          node2.id = this.flowParseRestrictedIdentifier(true);
          node = this.finishNode(node2, "QualifiedTypeIdentifier");
        }
        return node;
      };
      _proto.flowParseGenericType = function flowParseGenericType(startLoc, id) {
        var node = this.startNodeAt(startLoc);
        node.typeParameters = null;
        node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);
        if (this.match(47)) {
          node.typeParameters = this.flowParseTypeParameterInstantiation();
        }
        return this.finishNode(node, "GenericTypeAnnotation");
      };
      _proto.flowParseTypeofType = function flowParseTypeofType() {
        var node = this.startNode();
        this.expect(87);
        node.argument = this.flowParsePrimaryType();
        return this.finishNode(node, "TypeofTypeAnnotation");
      };
      _proto.flowParseTupleType = function flowParseTupleType() {
        var node = this.startNode();
        node.types = [];
        this.expect(0);
        while (this.state.pos < this.length && !this.match(3)) {
          node.types.push(this.flowParseType());
          if (this.match(3)) break;
          this.expect(12);
        }
        this.expect(3);
        return this.finishNode(node, "TupleTypeAnnotation");
      };
      _proto.flowParseFunctionTypeParam = function flowParseFunctionTypeParam(first) {
        var name = null;
        var optional = false;
        var typeAnnotation = null;
        var node = this.startNode();
        var lh = this.lookahead();
        var isThis = this.state.type === 78;
        if (lh.type === 14 || lh.type === 17) {
          if (isThis && !first) {
            this.raise(FlowErrors.ThisParamMustBeFirst, node);
          }
          name = this.parseIdentifier(isThis);
          if (this.eat(17)) {
            optional = true;
            if (isThis) {
              this.raise(FlowErrors.ThisParamMayNotBeOptional, node);
            }
          }
          typeAnnotation = this.flowParseTypeInitialiser();
        } else {
          typeAnnotation = this.flowParseType();
        }
        node.name = name;
        node.optional = optional;
        node.typeAnnotation = typeAnnotation;
        return this.finishNode(node, "FunctionTypeParam");
      };
      _proto.reinterpretTypeAsFunctionTypeParam = function reinterpretTypeAsFunctionTypeParam(type) {
        var node = this.startNodeAt(type.loc.start);
        node.name = null;
        node.optional = false;
        node.typeAnnotation = type;
        return this.finishNode(node, "FunctionTypeParam");
      };
      _proto.flowParseFunctionTypeParams = function flowParseFunctionTypeParams(params) {
        if (params === void 0) {
          params = [];
        }
        var rest = null;
        var _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: params,
          rest: rest,
          _this: _this
        };
      };
      _proto.flowIdentToTypeAnnotation = function flowIdentToTypeAnnotation(startLoc, node, id) {
        switch (id.name) {
          case "any":
            return this.finishNode(node, "AnyTypeAnnotation");
          case "bool":
          case "boolean":
            return this.finishNode(node, "BooleanTypeAnnotation");
          case "mixed":
            return this.finishNode(node, "MixedTypeAnnotation");
          case "empty":
            return this.finishNode(node, "EmptyTypeAnnotation");
          case "number":
            return this.finishNode(node, "NumberTypeAnnotation");
          case "string":
            return this.finishNode(node, "StringTypeAnnotation");
          case "symbol":
            return this.finishNode(node, "SymbolTypeAnnotation");
          default:
            this.checkNotUnderscore(id.name);
            return this.flowParseGenericType(startLoc, id);
        }
      };
      _proto.flowParsePrimaryType = function flowParsePrimaryType() {
        var startLoc = this.state.startLoc;
        var node = this.startNode();
        var tmp;
        var type;
        var isGroupedType = false;
        var 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:
            {
              var _node = this.startNode();
              _node.typeParameters = this.flowParseTypeParameterDeclaration();
              this.expect(10);
              tmp = this.flowParseFunctionTypeParams();
              _node.params = tmp.params;
              _node.rest = tmp.rest;
              _node["this"] = tmp._this;
              this.expect(11);
              this.expect(19);
              _node.returnType = this.flowParseType();
              return this.finishNode(_node, "FunctionTypeAnnotation");
            }
          case 10:
            {
              var _node2 = this.startNode();
              this.next();
              if (!this.match(11) && !this.match(21)) {
                if (tokenIsIdentifier(this.state.type) || this.match(78)) {
                  var token = this.lookahead().type;
                  isGroupedType = token !== 17 && token !== 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 134:
            return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation");
          case 85:
          case 86:
            node.value = this.match(85);
            this.next();
            return this.finishNode(node, "BooleanLiteralTypeAnnotation");
          case 53:
            if (this.state.value === "-") {
              this.next();
              if (this.match(135)) {
                return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node);
              }
              if (this.match(136)) {
                return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node);
              }
              throw this.raise(FlowErrors.UnexpectedSubtractionOperand, this.state.startLoc);
            }
            this.unexpected();
            return;
          case 135:
            return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation");
          case 136:
            return this.parseLiteral(this.state.value, "BigIntLiteralTypeAnnotation");
          case 88:
            this.next();
            return this.finishNode(node, "VoidTypeAnnotation");
          case 84:
            this.next();
            return this.finishNode(node, "NullLiteralTypeAnnotation");
          case 78:
            this.next();
            return this.finishNode(node, "ThisTypeAnnotation");
          case 55:
            this.next();
            return this.finishNode(node, "ExistsTypeAnnotation");
          case 87:
            return this.flowParseTypeofType();
          default:
            if (tokenIsKeyword(this.state.type)) {
              var label = tokenLabelName(this.state.type);
              this.next();
              return _superClass.prototype.createIdentifier.call(this, node, label);
            } else if (tokenIsIdentifier(this.state.type)) {
              if (this.isContextual(129)) {
                return this.flowParseInterfaceType();
              }
              return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier());
            }
        }
        this.unexpected();
      };
      _proto.flowParsePostfixType = function flowParsePostfixType() {
        var startLoc = this.state.startLoc;
        var type = this.flowParsePrimaryType();
        var seenOptionalIndexedAccess = false;
        while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) {
          var node = this.startNodeAt(startLoc);
          var optional = this.eat(18);
          seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;
          this.expect(0);
          if (!optional && this.match(3)) {
            node.elementType = type;
            this.next();
            type = this.finishNode(node, "ArrayTypeAnnotation");
          } else {
            node.objectType = type;
            node.indexType = this.flowParseType();
            this.expect(3);
            if (seenOptionalIndexedAccess) {
              node.optional = optional;
              type = this.finishNode(node, "OptionalIndexedAccessType");
            } else {
              type = this.finishNode(node, "IndexedAccessType");
            }
          }
        }
        return type;
      };
      _proto.flowParsePrefixType = function flowParsePrefixType() {
        var node = this.startNode();
        if (this.eat(17)) {
          node.typeAnnotation = this.flowParsePrefixType();
          return this.finishNode(node, "NullableTypeAnnotation");
        } else {
          return this.flowParsePostfixType();
        }
      };
      _proto.flowParseAnonFunctionWithoutParens = function flowParseAnonFunctionWithoutParens() {
        var param = this.flowParsePrefixType();
        if (!this.state.noAnonFunctionType && this.eat(19)) {
          var node = this.startNodeAt(param.loc.start);
          node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];
          node.rest = null;
          node["this"] = null;
          node.returnType = this.flowParseType();
          node.typeParameters = null;
          return this.finishNode(node, "FunctionTypeAnnotation");
        }
        return param;
      };
      _proto.flowParseIntersectionType = function flowParseIntersectionType() {
        var node = this.startNode();
        this.eat(45);
        var type = this.flowParseAnonFunctionWithoutParens();
        node.types = [type];
        while (this.eat(45)) {
          node.types.push(this.flowParseAnonFunctionWithoutParens());
        }
        return node.types.length === 1 ? type : this.finishNode(node, "IntersectionTypeAnnotation");
      };
      _proto.flowParseUnionType = function flowParseUnionType() {
        var node = this.startNode();
        this.eat(43);
        var type = this.flowParseIntersectionType();
        node.types = [type];
        while (this.eat(43)) {
          node.types.push(this.flowParseIntersectionType());
        }
        return node.types.length === 1 ? type : this.finishNode(node, "UnionTypeAnnotation");
      };
      _proto.flowParseType = function flowParseType() {
        var oldInType = this.state.inType;
        this.state.inType = true;
        var type = this.flowParseUnionType();
        this.state.inType = oldInType;
        return type;
      };
      _proto.flowParseTypeOrImplicitInstantiation = function flowParseTypeOrImplicitInstantiation() {
        if (this.state.type === 132 && this.state.value === "_") {
          var startLoc = this.state.startLoc;
          var node = this.parseIdentifier();
          return this.flowParseGenericType(startLoc, node);
        } else {
          return this.flowParseType();
        }
      };
      _proto.flowParseTypeAnnotation = function flowParseTypeAnnotation() {
        var node = this.startNode();
        node.typeAnnotation = this.flowParseTypeInitialiser();
        return this.finishNode(node, "TypeAnnotation");
      };
      _proto.flowParseTypeAnnotatableIdentifier = function flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) {
        var ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();
        if (this.match(14)) {
          ident.typeAnnotation = this.flowParseTypeAnnotation();
          this.resetEndLocation(ident);
        }
        return ident;
      };
      _proto.typeCastToParameter = function typeCastToParameter(node) {
        node.expression.typeAnnotation = node.typeAnnotation;
        this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
        return node.expression;
      };
      _proto.flowParseVariance = function flowParseVariance() {
        var 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;
      };
      _proto.parseFunctionBody = function parseFunctionBody(node, allowExpressionBody, isMethod) {
        var _this5 = this;
        if (isMethod === void 0) {
          isMethod = false;
        }
        if (allowExpressionBody) {
          this.forwardNoArrowParamsConversionAt(node, function () {
            return _superClass.prototype.parseFunctionBody.call(_this5, node, true, isMethod);
          });
          return;
        }
        _superClass.prototype.parseFunctionBody.call(this, node, false, isMethod);
      };
      _proto.parseFunctionBodyAndFinish = function parseFunctionBodyAndFinish(node, type, isMethod) {
        if (isMethod === void 0) {
          isMethod = false;
        }
        if (this.match(14)) {
          var typeNode = this.startNode();
          var _this$flowParseTypeAn2 = this.flowParseTypeAndPredicateInitialiser();
          typeNode.typeAnnotation = _this$flowParseTypeAn2[0];
          node.predicate = _this$flowParseTypeAn2[1];
          node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, "TypeAnnotation") : null;
        }
        return _superClass.prototype.parseFunctionBodyAndFinish.call(this, node, type, isMethod);
      };
      _proto.parseStatementLike = function parseStatementLike(flags) {
        if (this.state.strict && this.isContextual(129)) {
          var lookahead = this.lookahead();
          if (tokenIsKeywordOrIdentifier(lookahead.type)) {
            var node = this.startNode();
            this.next();
            return this.flowParseInterface(node);
          }
        } else if (this.isContextual(126)) {
          var _node3 = this.startNode();
          this.next();
          return this.flowParseEnumDeclaration(_node3);
        }
        var stmt = _superClass.prototype.parseStatementLike.call(this, flags);
        if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {
          this.flowPragma = null;
        }
        return stmt;
      };
      _proto.parseExpressionStatement = function parseExpressionStatement(node, 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(node);
            }
          } else if (tokenIsIdentifier(this.state.type)) {
            if (expr.name === "interface") {
              return this.flowParseInterface(node);
            } else if (expr.name === "type") {
              return this.flowParseTypeAlias(node);
            } else if (expr.name === "opaque") {
              return this.flowParseOpaqueType(node, false);
            }
          }
        }
        return _superClass.prototype.parseExpressionStatement.call(this, node, expr, decorators);
      };
      _proto.shouldParseExportDeclaration = function shouldParseExportDeclaration() {
        var type = this.state.type;
        if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {
          return !this.state.containsEsc;
        }
        return _superClass.prototype.shouldParseExportDeclaration.call(this);
      };
      _proto.isExportDefaultSpecifier = function isExportDefaultSpecifier() {
        var type = this.state.type;
        if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) {
          return this.state.containsEsc;
        }
        return _superClass.prototype.isExportDefaultSpecifier.call(this);
      };
      _proto.parseExportDefaultExpression = function parseExportDefaultExpression() {
        if (this.isContextual(126)) {
          var node = this.startNode();
          this.next();
          return this.flowParseEnumDeclaration(node);
        }
        return _superClass.prototype.parseExportDefaultExpression.call(this);
      };
      _proto.parseConditional = function parseConditional(expr, startLoc, refExpressionErrors) {
        var _this6 = this;
        if (!this.match(17)) return expr;
        if (this.state.maybeInArrowParameters) {
          var nextCh = this.lookaheadCharCode();
          if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {
            this.setOptionalParametersError(refExpressionErrors);
            return expr;
          }
        }
        this.expect(17);
        var state = this.state.clone();
        var originalNoArrowAt = this.state.noArrowAt;
        var node = this.startNodeAt(startLoc);
        var _this$tryParseConditi = this.tryParseConditionalConsequent(),
          consequent = _this$tryParseConditi.consequent,
          failed = _this$tryParseConditi.failed;
        var _this$getArrowLikeExp = this.getArrowLikeExpressions(consequent),
          valid = _this$getArrowLikeExp[0],
          invalid = _this$getArrowLikeExp[1];
        if (failed || invalid.length > 0) {
          var noArrowAt = [].concat(originalNoArrowAt);
          if (invalid.length > 0) {
            this.state = state;
            this.state.noArrowAt = noArrowAt;
            for (var i = 0; i < invalid.length; i++) {
              noArrowAt.push(invalid[i].start);
            }
            var _this$tryParseConditi2 = this.tryParseConditionalConsequent();
            consequent = _this$tryParseConditi2.consequent;
            failed = _this$tryParseConditi2.failed;
            var _this$getArrowLikeExp2 = this.getArrowLikeExpressions(consequent);
            valid = _this$getArrowLikeExp2[0];
            invalid = _this$getArrowLikeExp2[1];
          }
          if (failed && valid.length > 1) {
            this.raise(FlowErrors.AmbiguousConditionalArrow, state.startLoc);
          }
          if (failed && valid.length === 1) {
            this.state = state;
            noArrowAt.push(valid[0].start);
            this.state.noArrowAt = noArrowAt;
            var _this$tryParseConditi3 = this.tryParseConditionalConsequent();
            consequent = _this$tryParseConditi3.consequent;
            failed = _this$tryParseConditi3.failed;
          }
        }
        this.getArrowLikeExpressions(consequent, true);
        this.state.noArrowAt = originalNoArrowAt;
        this.expect(14);
        node.test = expr;
        node.consequent = consequent;
        node.alternate = this.forwardNoArrowParamsConversionAt(node, function () {
          return _this6.parseMaybeAssign(undefined, undefined);
        });
        return this.finishNode(node, "ConditionalExpression");
      };
      _proto.tryParseConditionalConsequent = function tryParseConditionalConsequent() {
        this.state.noArrowParamsConversionAt.push(this.state.start);
        var consequent = this.parseMaybeAssignAllowIn();
        var failed = !this.match(14);
        this.state.noArrowParamsConversionAt.pop();
        return {
          consequent: consequent,
          failed: failed
        };
      };
      _proto.getArrowLikeExpressions = function getArrowLikeExpressions(node, disallowInvalid) {
        var _this7 = this;
        var stack = [node];
        var arrows = [];
        while (stack.length !== 0) {
          var _node4 = stack.pop();
          if (_node4.type === "ArrowFunctionExpression" && _node4.body.type !== "BlockStatement") {
            if (_node4.typeParameters || !_node4.returnType) {
              this.finishArrowValidation(_node4);
            } else {
              arrows.push(_node4);
            }
            stack.push(_node4.body);
          } else if (_node4.type === "ConditionalExpression") {
            stack.push(_node4.consequent);
            stack.push(_node4.alternate);
          }
        }
        if (disallowInvalid) {
          arrows.forEach(function (node) {
            return _this7.finishArrowValidation(node);
          });
          return [arrows, []];
        }
        return partition(arrows, function (node) {
          return node.params.every(function (param) {
            return _this7.isAssignable(param, true);
          });
        });
      };
      _proto.finishArrowValidation = function finishArrowValidation(node) {
        var _node$extra;
        this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false);
        this.scope.enter(ScopeFlag.FUNCTION | ScopeFlag.ARROW);
        _superClass.prototype.checkParams.call(this, node, false, true);
        this.scope.exit();
      };
      _proto.forwardNoArrowParamsConversionAt = function forwardNoArrowParamsConversionAt(node, parse) {
        var result;
        if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
          this.state.noArrowParamsConversionAt.push(this.state.start);
          result = parse();
          this.state.noArrowParamsConversionAt.pop();
        } else {
          result = parse();
        }
        return result;
      };
      _proto.parseParenItem = function parseParenItem(node, startLoc) {
        var newNode = _superClass.prototype.parseParenItem.call(this, node, startLoc);
        if (this.eat(17)) {
          newNode.optional = true;
          this.resetEndLocation(node);
        }
        if (this.match(14)) {
          var typeCastNode = this.startNodeAt(startLoc);
          typeCastNode.expression = newNode;
          typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();
          return this.finishNode(typeCastNode, "TypeCastExpression");
        }
        return newNode;
      };
      _proto.assertModuleNodeAllowed = function assertModuleNodeAllowed(node) {
        if (node.type === "ImportDeclaration" && (node.importKind === "type" || node.importKind === "typeof") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "ExportAllDeclaration" && node.exportKind === "type") {
          return;
        }
        _superClass.prototype.assertModuleNodeAllowed.call(this, node);
      };
      _proto.parseExportDeclaration = function parseExportDeclaration(node) {
        if (this.isContextual(130)) {
          node.exportKind = "type";
          var declarationNode = this.startNode();
          this.next();
          if (this.match(5)) {
            node.specifiers = this.parseExportSpecifiers(true);
            _superClass.prototype.parseExportFrom.call(this, node);
            return null;
          } else {
            return this.flowParseTypeAlias(declarationNode);
          }
        } else if (this.isContextual(131)) {
          node.exportKind = "type";
          var _declarationNode = this.startNode();
          this.next();
          return this.flowParseOpaqueType(_declarationNode, false);
        } else if (this.isContextual(129)) {
          node.exportKind = "type";
          var _declarationNode2 = this.startNode();
          this.next();
          return this.flowParseInterface(_declarationNode2);
        } else if (this.isContextual(126)) {
          node.exportKind = "value";
          var _declarationNode3 = this.startNode();
          this.next();
          return this.flowParseEnumDeclaration(_declarationNode3);
        } else {
          return _superClass.prototype.parseExportDeclaration.call(this, node);
        }
      };
      _proto.eatExportStar = function eatExportStar(node) {
        if (_superClass.prototype.eatExportStar.call(this, node)) return true;
        if (this.isContextual(130) && this.lookahead().type === 55) {
          node.exportKind = "type";
          this.next();
          this.next();
          return true;
        }
        return false;
      };
      _proto.maybeParseExportNamespaceSpecifier = function maybeParseExportNamespaceSpecifier(node) {
        var startLoc = this.state.startLoc;
        var hasNamespace = _superClass.prototype.maybeParseExportNamespaceSpecifier.call(this, node);
        if (hasNamespace && node.exportKind === "type") {
          this.unexpected(startLoc);
        }
        return hasNamespace;
      };
      _proto.parseClassId = function parseClassId(node, isStatement, optionalId) {
        _superClass.prototype.parseClassId.call(this, node, isStatement, optionalId);
        if (this.match(47)) {
          node.typeParameters = this.flowParseTypeParameterDeclaration();
        }
      };
      _proto.parseClassMember = function parseClassMember(classBody, member, state) {
        var startLoc = this.state.startLoc;
        if (this.isContextual(125)) {
          if (_superClass.prototype.parseClassMemberFromModifier.call(this, classBody, member)) {
            return;
          }
          member.declare = true;
        }
        _superClass.prototype.parseClassMember.call(this, classBody, member, state);
        if (member.declare) {
          if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") {
            this.raise(FlowErrors.DeclareClassElement, startLoc);
          } else if (member.value) {
            this.raise(FlowErrors.DeclareClassFieldInitializer, member.value);
          }
        }
      };
      _proto.isIterator = function isIterator(word) {
        return word === "iterator" || word === "asyncIterator";
      };
      _proto.readIterator = function readIterator() {
        var word = _superClass.prototype.readWord1.call(this);
        var fullWord = "@@" + word;
        if (!this.isIterator(word) || !this.state.inType) {
          this.raise(Errors.InvalidIdentifier, this.state.curPosition(), {
            identifierName: fullWord
          });
        }
        this.finishToken(132, fullWord);
      };
      _proto.getTokenFromCode = function getTokenFromCode(code) {
        var next = this.input.charCodeAt(this.state.pos + 1);
        if (code === 123 && next === 124) {
          this.finishOp(6, 2);
        } else if (this.state.inType && (code === 62 || code === 60)) {
          this.finishOp(code === 62 ? 48 : 47, 1);
        } else if (this.state.inType && code === 63) {
          if (next === 46) {
            this.finishOp(18, 2);
          } else {
            this.finishOp(17, 1);
          }
        } else if (isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))) {
          this.state.pos += 2;
          this.readIterator();
        } else {
          _superClass.prototype.getTokenFromCode.call(this, code);
        }
      };
      _proto.isAssignable = function isAssignable(node, isBinding) {
        if (node.type === "TypeCastExpression") {
          return this.isAssignable(node.expression, isBinding);
        } else {
          return _superClass.prototype.isAssignable.call(this, node, isBinding);
        }
      };
      _proto.toAssignable = function toAssignable(node, isLHS) {
        if (isLHS === void 0) {
          isLHS = false;
        }
        if (!isLHS && node.type === "AssignmentExpression" && node.left.type === "TypeCastExpression") {
          node.left = this.typeCastToParameter(node.left);
        }
        _superClass.prototype.toAssignable.call(this, node, isLHS);
      };
      _proto.toAssignableList = function toAssignableList(exprList, trailingCommaLoc, isLHS) {
        for (var i = 0; i < exprList.length; i++) {
          var expr = exprList[i];
          if ((expr == null ? void 0 : expr.type) === "TypeCastExpression") {
            exprList[i] = this.typeCastToParameter(expr);
          }
        }
        _superClass.prototype.toAssignableList.call(this, exprList, trailingCommaLoc, isLHS);
      };
      _proto.toReferencedList = function toReferencedList(exprList, isParenthesizedExpr) {
        for (var i = 0; i < exprList.length; i++) {
          var _expr$extra;
          var expr = exprList[i];
          if (expr && expr.type === "TypeCastExpression" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) {
            this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation);
          }
        }
        return exprList;
      };
      _proto.parseArrayLike = function parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
        var node = _superClass.prototype.parseArrayLike.call(this, close, canBePattern, isTuple, refExpressionErrors);
        if (canBePattern && !this.state.maybeInArrowParameters) {
          this.toReferencedList(node.elements);
        }
        return node;
      };
      _proto.isValidLVal = function isValidLVal(type, isParenthesized, binding) {
        return type === "TypeCastExpression" || _superClass.prototype.isValidLVal.call(this, type, isParenthesized, binding);
      };
      _proto.parseClassProperty = function parseClassProperty(node) {
        if (this.match(14)) {
          node.typeAnnotation = this.flowParseTypeAnnotation();
        }
        return _superClass.prototype.parseClassProperty.call(this, node);
      };
      _proto.parseClassPrivateProperty = function parseClassPrivateProperty(node) {
        if (this.match(14)) {
          node.typeAnnotation = this.flowParseTypeAnnotation();
        }
        return _superClass.prototype.parseClassPrivateProperty.call(this, node);
      };
      _proto.isClassMethod = function isClassMethod() {
        return this.match(47) || _superClass.prototype.isClassMethod.call(this);
      };
      _proto.isClassProperty = function isClassProperty() {
        return this.match(14) || _superClass.prototype.isClassProperty.call(this);
      };
      _proto.isNonstaticConstructor = function isNonstaticConstructor(method) {
        return !this.match(14) && _superClass.prototype.isNonstaticConstructor.call(this, method);
      };
      _proto.pushClassMethod = function 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();
        }
        _superClass.prototype.pushClassMethod.call(this, classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
        if (method.params && isConstructor) {
          var params = method.params;
          if (params.length > 0 && this.isThisParam(params[0])) {
            this.raise(FlowErrors.ThisParamBannedInConstructor, method);
          }
        } else if (method.type === "MethodDefinition" && isConstructor && method.value.params) {
          var _params = method.value.params;
          if (_params.length > 0 && this.isThisParam(_params[0])) {
            this.raise(FlowErrors.ThisParamBannedInConstructor, method);
          }
        }
      };
      _proto.pushClassPrivateMethod = function 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();
        }
        _superClass.prototype.pushClassPrivateMethod.call(this, classBody, method, isGenerator, isAsync);
      };
      _proto.parseClassSuper = function parseClassSuper(node) {
        _superClass.prototype.parseClassSuper.call(this, node);
        if (node.superClass && (this.match(47) || this.match(51))) {
          {
            node.superTypeParameters = this.flowParseTypeParameterInstantiationInExpression();
          }
        }
        if (this.isContextual(113)) {
          this.next();
          var implemented = node["implements"] = [];
          do {
            var _node5 = this.startNode();
            _node5.id = this.flowParseRestrictedIdentifier(true);
            if (this.match(47)) {
              _node5.typeParameters = this.flowParseTypeParameterInstantiation();
            } else {
              _node5.typeParameters = null;
            }
            implemented.push(this.finishNode(_node5, "ClassImplements"));
          } while (this.eat(12));
        }
      };
      _proto.checkGetterSetterParams = function checkGetterSetterParams(method) {
        _superClass.prototype.checkGetterSetterParams.call(this, method);
        var params = this.getObjectOrClassMethodParams(method);
        if (params.length > 0) {
          var param = params[0];
          if (this.isThisParam(param) && method.kind === "get") {
            this.raise(FlowErrors.GetterMayNotHaveThisParam, param);
          } else if (this.isThisParam(param)) {
            this.raise(FlowErrors.SetterMayNotHaveThisParam, param);
          }
        }
      };
      _proto.parsePropertyNamePrefixOperator = function parsePropertyNamePrefixOperator(node) {
        node.variance = this.flowParseVariance();
      };
      _proto.parseObjPropValue = function parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
        if (prop.variance) {
          this.unexpected(prop.variance.loc.start);
        }
        delete prop.variance;
        var typeParameters;
        if (this.match(47) && !isAccessor) {
          typeParameters = this.flowParseTypeParameterDeclaration();
          if (!this.match(10)) this.unexpected();
        }
        var result = _superClass.prototype.parseObjPropValue.call(this, prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
        if (typeParameters) {
          (result.value || result).typeParameters = typeParameters;
        }
        return result;
      };
      _proto.parseFunctionParamType = function parseFunctionParamType(param) {
        if (this.eat(17)) {
          if (param.type !== "Identifier") {
            this.raise(FlowErrors.PatternIsOptional, param);
          }
          if (this.isThisParam(param)) {
            this.raise(FlowErrors.ThisParamMayNotBeOptional, param);
          }
          param.optional = true;
        }
        if (this.match(14)) {
          param.typeAnnotation = this.flowParseTypeAnnotation();
        } else if (this.isThisParam(param)) {
          this.raise(FlowErrors.ThisParamAnnotationRequired, param);
        }
        if (this.match(29) && this.isThisParam(param)) {
          this.raise(FlowErrors.ThisParamNoDefault, param);
        }
        this.resetEndLocation(param);
        return param;
      };
      _proto.parseMaybeDefault = function parseMaybeDefault(startLoc, left) {
        var node = _superClass.prototype.parseMaybeDefault.call(this, startLoc, left);
        if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
          this.raise(FlowErrors.TypeBeforeInitializer, node.typeAnnotation);
        }
        return node;
      };
      _proto.checkImportReflection = function checkImportReflection(node) {
        _superClass.prototype.checkImportReflection.call(this, node);
        if (node.module && node.importKind !== "value") {
          this.raise(FlowErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);
        }
      };
      _proto.parseImportSpecifierLocal = function parseImportSpecifierLocal(node, specifier, type) {
        specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
        node.specifiers.push(this.finishImportSpecifier(specifier, type));
      };
      _proto.isPotentialImportPhase = function isPotentialImportPhase(isExport) {
        if (_superClass.prototype.isPotentialImportPhase.call(this, isExport)) return true;
        if (this.isContextual(130)) {
          if (!isExport) return true;
          var ch = this.lookaheadCharCode();
          return ch === 123 || ch === 42;
        }
        return !isExport && this.isContextual(87);
      };
      _proto.applyImportPhase = function applyImportPhase(node, isExport, phase, loc) {
        _superClass.prototype.applyImportPhase.call(this, node, isExport, phase, loc);
        if (isExport) {
          if (!phase && this.match(65)) {
            return;
          }
          node.exportKind = phase === "type" ? phase : "value";
        } else {
          if (phase === "type" && this.match(55)) this.unexpected();
          node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
        }
      };
      _proto.parseImportSpecifier = function parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
        var firstIdent = specifier.imported;
        var specifierTypeKind = null;
        if (firstIdent.type === "Identifier") {
          if (firstIdent.name === "type") {
            specifierTypeKind = "type";
          } else if (firstIdent.name === "typeof") {
            specifierTypeKind = "typeof";
          }
        }
        var isBinding = false;
        if (this.isContextual(93) && !this.isLookaheadContextual("as")) {
          var 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, 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);
          }
        }
        var specifierIsTypeImport = hasTypeImportKind(specifier);
        if (isInTypeOnlyImport && specifierIsTypeImport) {
          this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, 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");
      };
      _proto.parseBindingAtom = function parseBindingAtom() {
        switch (this.state.type) {
          case 78:
            return this.parseIdentifier(true);
          default:
            return _superClass.prototype.parseBindingAtom.call(this);
        }
      };
      _proto.parseFunctionParams = function parseFunctionParams(node, isConstructor) {
        var kind = node.kind;
        if (kind !== "get" && kind !== "set" && this.match(47)) {
          node.typeParameters = this.flowParseTypeParameterDeclaration();
        }
        _superClass.prototype.parseFunctionParams.call(this, node, isConstructor);
      };
      _proto.parseVarId = function parseVarId(decl, kind) {
        _superClass.prototype.parseVarId.call(this, decl, kind);
        if (this.match(14)) {
          decl.id.typeAnnotation = this.flowParseTypeAnnotation();
          this.resetEndLocation(decl.id);
        }
      };
      _proto.parseAsyncArrowFromCallExpression = function parseAsyncArrowFromCallExpression(node, call) {
        if (this.match(14)) {
          var oldNoAnonFunctionType = this.state.noAnonFunctionType;
          this.state.noAnonFunctionType = true;
          node.returnType = this.flowParseTypeAnnotation();
          this.state.noAnonFunctionType = oldNoAnonFunctionType;
        }
        return _superClass.prototype.parseAsyncArrowFromCallExpression.call(this, node, call);
      };
      _proto.shouldParseAsyncArrow = function shouldParseAsyncArrow() {
        return this.match(14) || _superClass.prototype.shouldParseAsyncArrow.call(this);
      };
      _proto.parseMaybeAssign = function parseMaybeAssign(refExpressionErrors, afterLeftParse) {
        var _this8 = this,
          _jsx;
        var state = null;
        var jsx;
        if (this.hasPlugin("jsx") && (this.match(143) || this.match(47))) {
          state = this.state.clone();
          jsx = this.tryParse(function () {
            return _superClass.prototype.parseMaybeAssign.call(_this8, refExpressionErrors, afterLeftParse);
          }, state);
          if (!jsx.error) return jsx.node;
          var context = this.state.context;
          var currentContext = context[context.length - 1];
          if (currentContext === types.j_oTag || currentContext === types.j_expr) {
            context.pop();
          }
        }
        if ((_jsx = jsx) != null && _jsx.error || this.match(47)) {
          var _jsx2, _jsx3;
          state = state || this.state.clone();
          var typeParameters;
          var arrow = this.tryParse(function (abort) {
            var _arrowExpression$extr;
            typeParameters = _this8.flowParseTypeParameterDeclaration();
            var arrowExpression = _this8.forwardNoArrowParamsConversionAt(typeParameters, function () {
              var result = _superClass.prototype.parseMaybeAssign.call(_this8, refExpressionErrors, afterLeftParse);
              _this8.resetStartLocationFromNode(result, typeParameters);
              return result;
            });
            if ((_arrowExpression$extr = arrowExpression.extra) != null && _arrowExpression$extr.parenthesized) abort();
            var expr = _this8.maybeUnwrapTypeCastExpression(arrowExpression);
            if (expr.type !== "ArrowFunctionExpression") abort();
            expr.typeParameters = typeParameters;
            _this8.resetStartLocationFromNode(expr, typeParameters);
            return arrowExpression;
          }, state);
          var arrowExpression = null;
          if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") {
            if (!arrow.error && !arrow.aborted) {
              if (arrow.node.async) {
                this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, typeParameters);
              }
              return arrow.node;
            }
            arrowExpression = arrow.node;
          }
          if ((_jsx2 = jsx) != null && _jsx2.node) {
            this.state = jsx.failState;
            return jsx.node;
          }
          if (arrowExpression) {
            this.state = arrow.failState;
            return arrowExpression;
          }
          if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;
          if (arrow.thrown) throw arrow.error;
          throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, typeParameters);
        }
        return _superClass.prototype.parseMaybeAssign.call(this, refExpressionErrors, afterLeftParse);
      };
      _proto.parseArrow = function parseArrow(node) {
        var _this9 = this;
        if (this.match(14)) {
          var result = this.tryParse(function () {
            var oldNoAnonFunctionType = _this9.state.noAnonFunctionType;
            _this9.state.noAnonFunctionType = true;
            var typeNode = _this9.startNode();
            var _this9$flowParseTypeA = _this9.flowParseTypeAndPredicateInitialiser();
            typeNode.typeAnnotation = _this9$flowParseTypeA[0];
            node.predicate = _this9$flowParseTypeA[1];
            _this9.state.noAnonFunctionType = oldNoAnonFunctionType;
            if (_this9.canInsertSemicolon()) _this9.unexpected();
            if (!_this9.match(19)) _this9.unexpected();
            return typeNode;
          });
          if (result.thrown) return null;
          if (result.error) this.state = result.failState;
          node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, "TypeAnnotation") : null;
        }
        return _superClass.prototype.parseArrow.call(this, node);
      };
      _proto.shouldParseArrow = function shouldParseArrow(params) {
        return this.match(14) || _superClass.prototype.shouldParseArrow.call(this, params);
      };
      _proto.setArrowFunctionParameters = function setArrowFunctionParameters(node, params) {
        if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
          node.params = params;
        } else {
          _superClass.prototype.setArrowFunctionParameters.call(this, node, params);
        }
      };
      _proto.checkParams = function checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged) {
        if (strictModeChanged === void 0) {
          strictModeChanged = true;
        }
        if (isArrowFunction && this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
          return;
        }
        for (var i = 0; i < node.params.length; i++) {
          if (this.isThisParam(node.params[i]) && i > 0) {
            this.raise(FlowErrors.ThisParamMustBeFirst, node.params[i]);
          }
        }
        _superClass.prototype.checkParams.call(this, node, allowDuplicates, isArrowFunction, strictModeChanged);
      };
      _proto.parseParenAndDistinguishExpression = function parseParenAndDistinguishExpression(canBeArrow) {
        return _superClass.prototype.parseParenAndDistinguishExpression.call(this, canBeArrow && !this.state.noArrowAt.includes(this.sourceToOffsetPos(this.state.start)));
      };
      _proto.parseSubscripts = function parseSubscripts(base, startLoc, noCalls) {
        var _this10 = this;
        if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.includes(startLoc.index)) {
          this.next();
          var node = this.startNodeAt(startLoc);
          node.callee = base;
          node.arguments = _superClass.prototype.parseCallExpressionArguments.call(this, 11);
          base = this.finishNode(node, "CallExpression");
        } else if (base.type === "Identifier" && base.name === "async" && this.match(47)) {
          var state = this.state.clone();
          var arrow = this.tryParse(function (abort) {
            return _this10.parseAsyncArrowWithTypeParameters(startLoc) || abort();
          }, state);
          if (!arrow.error && !arrow.aborted) return arrow.node;
          var result = this.tryParse(function () {
            return _superClass.prototype.parseSubscripts.call(_this10, base, 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 _superClass.prototype.parseSubscripts.call(this, base, startLoc, noCalls);
      };
      _proto.parseSubscript = function parseSubscript(base, startLoc, noCalls, subscriptState) {
        var _this11 = this;
        if (this.match(18) && this.isLookaheadToken_lt()) {
          subscriptState.optionalChainMember = true;
          if (noCalls) {
            subscriptState.stop = true;
            return base;
          }
          this.next();
          var node = this.startNodeAt(startLoc);
          node.callee = base;
          node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
          this.expect(10);
          node.arguments = this.parseCallExpressionArguments(11);
          node.optional = true;
          return this.finishCallExpression(node, true);
        } else if (!noCalls && this.shouldParseTypes() && (this.match(47) || this.match(51))) {
          var _node6 = this.startNodeAt(startLoc);
          _node6.callee = base;
          var result = this.tryParse(function () {
            _node6.typeArguments = _this11.flowParseTypeParameterInstantiationCallOrNew();
            _this11.expect(10);
            _node6.arguments = _superClass.prototype.parseCallExpressionArguments.call(_this11, 11);
            if (subscriptState.optionalChainMember) {
              _node6.optional = false;
            }
            return _this11.finishCallExpression(_node6, subscriptState.optionalChainMember);
          });
          if (result.node) {
            if (result.error) this.state = result.failState;
            return result.node;
          }
        }
        return _superClass.prototype.parseSubscript.call(this, base, startLoc, noCalls, subscriptState);
      };
      _proto.parseNewCallee = function parseNewCallee(node) {
        var _this12 = this;
        _superClass.prototype.parseNewCallee.call(this, node);
        var targs = null;
        if (this.shouldParseTypes() && this.match(47)) {
          targs = this.tryParse(function () {
            return _this12.flowParseTypeParameterInstantiationCallOrNew();
          }).node;
        }
        node.typeArguments = targs;
      };
      _proto.parseAsyncArrowWithTypeParameters = function parseAsyncArrowWithTypeParameters(startLoc) {
        var node = this.startNodeAt(startLoc);
        this.parseFunctionParams(node, false);
        if (!this.parseArrow(node)) return;
        return _superClass.prototype.parseArrowExpression.call(this, node, undefined, true);
      };
      _proto.readToken_mult_modulo = function readToken_mult_modulo(code) {
        var next = this.input.charCodeAt(this.state.pos + 1);
        if (code === 42 && next === 47 && this.state.hasFlowComment) {
          this.state.hasFlowComment = false;
          this.state.pos += 2;
          this.nextToken();
          return;
        }
        _superClass.prototype.readToken_mult_modulo.call(this, code);
      };
      _proto.readToken_pipe_amp = function readToken_pipe_amp(code) {
        var next = this.input.charCodeAt(this.state.pos + 1);
        if (code === 124 && next === 125) {
          this.finishOp(9, 2);
          return;
        }
        _superClass.prototype.readToken_pipe_amp.call(this, code);
      };
      _proto.parseTopLevel = function parseTopLevel(file, program) {
        var fileNode = _superClass.prototype.parseTopLevel.call(this, file, program);
        if (this.state.hasFlowComment) {
          this.raise(FlowErrors.UnterminatedFlowComment, this.state.curPosition());
        }
        return fileNode;
      };
      _proto.skipBlockComment = function skipBlockComment() {
        if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
          if (this.state.hasFlowComment) {
            throw this.raise(FlowErrors.NestedFlowComment, this.state.startLoc);
          }
          this.hasFlowCommentCompletion();
          var commentSkip = this.skipFlowComment();
          if (commentSkip) {
            this.state.pos += commentSkip;
            this.state.hasFlowComment = true;
          }
          return;
        }
        return _superClass.prototype.skipBlockComment.call(this, this.state.hasFlowComment ? "*-/" : "*/");
      };
      _proto.skipFlowComment = function skipFlowComment() {
        var pos = this.state.pos;
        var shiftToFirstNonWhiteSpace = 2;
        while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {
          shiftToFirstNonWhiteSpace++;
        }
        var ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
        var ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);
        if (ch2 === 58 && ch3 === 58) {
          return shiftToFirstNonWhiteSpace + 2;
        }
        if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === "flow-include") {
          return shiftToFirstNonWhiteSpace + 12;
        }
        if (ch2 === 58 && ch3 !== 58) {
          return shiftToFirstNonWhiteSpace;
        }
        return false;
      };
      _proto.hasFlowCommentCompletion = function hasFlowCommentCompletion() {
        var end = this.input.indexOf("*/", this.state.pos);
        if (end === -1) {
          throw this.raise(Errors.UnterminatedComment, this.state.curPosition());
        }
      };
      _proto.flowEnumErrorBooleanMemberNotInitialized = function flowEnumErrorBooleanMemberNotInitialized(loc, _ref16) {
        var enumName = _ref16.enumName,
          memberName = _ref16.memberName;
        this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, {
          memberName: memberName,
          enumName: enumName
        });
      };
      _proto.flowEnumErrorInvalidMemberInitializer = function flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
        return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, loc, enumContext);
      };
      _proto.flowEnumErrorNumberMemberNotInitialized = function flowEnumErrorNumberMemberNotInitialized(loc, details) {
        this.raise(FlowErrors.EnumNumberMemberNotInitialized, loc, details);
      };
      _proto.flowEnumErrorStringMemberInconsistentlyInitialized = function flowEnumErrorStringMemberInconsistentlyInitialized(node, details) {
        this.raise(FlowErrors.EnumStringMemberInconsistentlyInitialized, node, details);
      };
      _proto.flowEnumMemberInit = function flowEnumMemberInit() {
        var _this13 = this;
        var startLoc = this.state.startLoc;
        var endOfInit = function endOfInit() {
          return _this13.match(12) || _this13.match(8);
        };
        switch (this.state.type) {
          case 135:
            {
              var literal = this.parseNumericLiteral(this.state.value);
              if (endOfInit()) {
                return {
                  type: "number",
                  loc: literal.loc.start,
                  value: literal
                };
              }
              return {
                type: "invalid",
                loc: startLoc
              };
            }
          case 134:
            {
              var _literal = this.parseStringLiteral(this.state.value);
              if (endOfInit()) {
                return {
                  type: "string",
                  loc: _literal.loc.start,
                  value: _literal
                };
              }
              return {
                type: "invalid",
                loc: startLoc
              };
            }
          case 85:
          case 86:
            {
              var _literal2 = this.parseBooleanLiteral(this.match(85));
              if (endOfInit()) {
                return {
                  type: "boolean",
                  loc: _literal2.loc.start,
                  value: _literal2
                };
              }
              return {
                type: "invalid",
                loc: startLoc
              };
            }
          default:
            return {
              type: "invalid",
              loc: startLoc
            };
        }
      };
      _proto.flowEnumMemberRaw = function flowEnumMemberRaw() {
        var loc = this.state.startLoc;
        var id = this.parseIdentifier(true);
        var init = this.eat(29) ? this.flowEnumMemberInit() : {
          type: "none",
          loc: loc
        };
        return {
          id: id,
          init: init
        };
      };
      _proto.flowEnumCheckExplicitTypeMismatch = function flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
        var explicitType = context.explicitType;
        if (explicitType === null) {
          return;
        }
        if (explicitType !== expectedType) {
          this.flowEnumErrorInvalidMemberInitializer(loc, context);
        }
      };
      _proto.flowEnumMembers = function flowEnumMembers(_ref17) {
        var enumName = _ref17.enumName,
          explicitType = _ref17.explicitType;
        var seenNames = new Set();
        var members = {
          booleanMembers: [],
          numberMembers: [],
          stringMembers: [],
          defaultedMembers: []
        };
        var hasUnknownMembers = false;
        while (!this.match(8)) {
          if (this.eat(21)) {
            hasUnknownMembers = true;
            break;
          }
          var memberNode = this.startNode();
          var _this$flowEnumMemberR = this.flowEnumMemberRaw(),
            id = _this$flowEnumMemberR.id,
            init = _this$flowEnumMemberR.init;
          var memberName = id.name;
          if (memberName === "") {
            continue;
          }
          if (/^[a-z]/.test(memberName)) {
            this.raise(FlowErrors.EnumInvalidMemberName, id, {
              memberName: memberName,
              suggestion: memberName[0].toUpperCase() + memberName.slice(1),
              enumName: enumName
            });
          }
          if (seenNames.has(memberName)) {
            this.raise(FlowErrors.EnumDuplicateMemberName, id, {
              memberName: memberName,
              enumName: enumName
            });
          }
          seenNames.add(memberName);
          var context = {
            enumName: enumName,
            explicitType: explicitType,
            memberName: 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: members,
          hasUnknownMembers: hasUnknownMembers
        };
      };
      _proto.flowEnumStringMembers = function flowEnumStringMembers(initializedMembers, defaultedMembers, _ref18) {
        var enumName = _ref18.enumName;
        if (initializedMembers.length === 0) {
          return defaultedMembers;
        } else if (defaultedMembers.length === 0) {
          return initializedMembers;
        } else if (defaultedMembers.length > initializedMembers.length) {
          for (var _i2 = 0; _i2 < initializedMembers.length; _i2++) {
            var member = initializedMembers[_i2];
            this.flowEnumErrorStringMemberInconsistentlyInitialized(member, {
              enumName: enumName
            });
          }
          return defaultedMembers;
        } else {
          for (var _i4 = 0; _i4 < defaultedMembers.length; _i4++) {
            var _member = defaultedMembers[_i4];
            this.flowEnumErrorStringMemberInconsistentlyInitialized(_member, {
              enumName: enumName
            });
          }
          return initializedMembers;
        }
      };
      _proto.flowEnumParseExplicitType = function flowEnumParseExplicitType(_ref19) {
        var enumName = _ref19.enumName;
        if (!this.eatContextual(102)) return null;
        if (!tokenIsIdentifier(this.state.type)) {
          throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, this.state.startLoc, {
            enumName: enumName
          });
        }
        var value = this.state.value;
        this.next();
        if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") {
          this.raise(FlowErrors.EnumInvalidExplicitType, this.state.startLoc, {
            enumName: enumName,
            invalidEnumType: value
          });
        }
        return value;
      };
      _proto.flowEnumBody = function flowEnumBody(node, id) {
        var _this14 = this;
        var enumName = id.name;
        var nameLoc = id.loc.start;
        var explicitType = this.flowEnumParseExplicitType({
          enumName: enumName
        });
        this.expect(5);
        var _this$flowEnumMembers = this.flowEnumMembers({
            enumName: enumName,
            explicitType: explicitType
          }),
          members = _this$flowEnumMembers.members,
          hasUnknownMembers = _this$flowEnumMembers.hasUnknownMembers;
        node.hasUnknownMembers = hasUnknownMembers;
        switch (explicitType) {
          case "boolean":
            node.explicitType = true;
            node.members = members.booleanMembers;
            this.expect(8);
            return this.finishNode(node, "EnumBooleanBody");
          case "number":
            node.explicitType = true;
            node.members = members.numberMembers;
            this.expect(8);
            return this.finishNode(node, "EnumNumberBody");
          case "string":
            node.explicitType = true;
            node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
              enumName: enumName
            });
            this.expect(8);
            return this.finishNode(node, "EnumStringBody");
          case "symbol":
            node.members = members.defaultedMembers;
            this.expect(8);
            return this.finishNode(node, "EnumSymbolBody");
          default:
            {
              var empty = function empty() {
                node.members = [];
                _this14.expect(8);
                return _this14.finishNode(node, "EnumStringBody");
              };
              node.explicitType = false;
              var boolsLen = members.booleanMembers.length;
              var numsLen = members.numberMembers.length;
              var strsLen = members.stringMembers.length;
              var defaultedLen = members.defaultedMembers.length;
              if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {
                return empty();
              } else if (!boolsLen && !numsLen) {
                node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
                  enumName: enumName
                });
                this.expect(8);
                return this.finishNode(node, "EnumStringBody");
              } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
                for (var _i6 = 0, _members$defaultedMem2 = members.defaultedMembers; _i6 < _members$defaultedMem2.length; _i6++) {
                  var member = _members$defaultedMem2[_i6];
                  this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {
                    enumName: enumName,
                    memberName: member.id.name
                  });
                }
                node.members = members.booleanMembers;
                this.expect(8);
                return this.finishNode(node, "EnumBooleanBody");
              } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
                for (var _i8 = 0, _members$defaultedMem4 = members.defaultedMembers; _i8 < _members$defaultedMem4.length; _i8++) {
                  var _member2 = _members$defaultedMem4[_i8];
                  this.flowEnumErrorNumberMemberNotInitialized(_member2.loc.start, {
                    enumName: enumName,
                    memberName: _member2.id.name
                  });
                }
                node.members = members.numberMembers;
                this.expect(8);
                return this.finishNode(node, "EnumNumberBody");
              } else {
                this.raise(FlowErrors.EnumInconsistentMemberValues, nameLoc, {
                  enumName: enumName
                });
                return empty();
              }
            }
        }
      };
      _proto.flowParseEnumDeclaration = function flowParseEnumDeclaration(node) {
        var id = this.parseIdentifier();
        node.id = id;
        node.body = this.flowEnumBody(this.startNode(), id);
        return this.finishNode(node, "EnumDeclaration");
      };
      _proto.jsxParseOpeningElementAfterName = function jsxParseOpeningElementAfterName(node) {
        if (this.shouldParseTypes()) {
          if (this.match(47) || this.match(51)) {
            node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
          }
        }
        return _superClass.prototype.jsxParseOpeningElementAfterName.call(this, node);
      };
      _proto.isLookaheadToken_lt = function isLookaheadToken_lt() {
        var next = this.nextTokenStart();
        if (this.input.charCodeAt(next) === 60) {
          var afterNext = this.input.charCodeAt(next + 1);
          return afterNext !== 60 && afterNext !== 61;
        }
        return false;
      };
      _proto.reScan_lt_gt = function reScan_lt_gt() {
        var type = this.state.type;
        if (type === 47) {
          this.state.pos -= 1;
          this.readToken_lt();
        } else if (type === 48) {
          this.state.pos -= 1;
          this.readToken_gt();
        }
      };
      _proto.reScan_lt = function reScan_lt() {
        var type = this.state.type;
        if (type === 51) {
          this.state.pos -= 2;
          this.finishOp(47, 1);
          return 47;
        }
        return type;
      };
      _proto.maybeUnwrapTypeCastExpression = function maybeUnwrapTypeCastExpression(node) {
        return node.type === "TypeCastExpression" ? node.expression : node;
      };
      return _createClass(FlowParserMixin);
    }(superClass);
  });

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 _templateObject$I;
  var JsxErrors = ParseErrorEnum(_templateObject$I || (_templateObject$I = _taggedTemplateLiteralLoose(["jsx"])))({
    AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
    MissingClosingTagElement: function MissingClosingTagElement(_ref) {
      var openingTagName = _ref.openingTagName;
      return "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: function UnexpectedToken(_ref2) {
      var unexpected = _ref2.unexpected,
        HTMLEntity = _ref2.HTMLEntity;
      return "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 jsx = (function (superClass) {
    return function (_superClass) {
      function JSXParserMixin() {
        return _superClass.apply(this, arguments) || this;
      }
      _inherits(JSXParserMixin, _superClass);
      var _proto = JSXParserMixin.prototype;
      _proto.jsxReadToken = function jsxReadToken() {
        var out = "";
        var chunkStart = this.state.pos;
        for (;;) {
          if (this.state.pos >= this.length) {
            throw this.raise(JsxErrors.UnterminatedJsxContent, this.state.startLoc);
          }
          var 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(143);
                } else {
                  _superClass.prototype.getTokenFromCode.call(this, ch);
                }
                return;
              }
              out += this.input.slice(chunkStart, this.state.pos);
              this.finishToken(142, 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 (isNewLine(ch)) {
                out += this.input.slice(chunkStart, this.state.pos);
                out += this.jsxReadNewLine(true);
                chunkStart = this.state.pos;
              } else {
                ++this.state.pos;
              }
          }
        }
      };
      _proto.jsxReadNewLine = function jsxReadNewLine(normalizeCRLF) {
        var ch = this.input.charCodeAt(this.state.pos);
        var 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;
      };
      _proto.jsxReadString = function jsxReadString(quote) {
        var out = "";
        var chunkStart = ++this.state.pos;
        for (;;) {
          if (this.state.pos >= this.length) {
            throw this.raise(Errors.UnterminatedString, this.state.startLoc);
          }
          var 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 (isNewLine(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(134, out);
      };
      _proto.jsxReadEntity = function jsxReadEntity() {
        var startPos = ++this.state.pos;
        if (this.codePointAtPos(this.state.pos) === 35) {
          ++this.state.pos;
          var radix = 10;
          if (this.codePointAtPos(this.state.pos) === 120) {
            radix = 16;
            ++this.state.pos;
          }
          var codePoint = this.readInt(radix, undefined, false, "bail");
          if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) {
            ++this.state.pos;
            return String.fromCodePoint(codePoint);
          }
        } else {
          var count = 0;
          var semi = false;
          while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) === 59)) {
            ++this.state.pos;
          }
          if (semi) {
            var desc = this.input.slice(startPos, this.state.pos);
            var entity = entities[desc];
            ++this.state.pos;
            if (entity) {
              return entity;
            }
          }
        }
        this.state.pos = startPos;
        return "&";
      };
      _proto.jsxReadWord = function jsxReadWord() {
        var ch;
        var start = this.state.pos;
        do {
          ch = this.input.charCodeAt(++this.state.pos);
        } while (isIdentifierChar(ch) || ch === 45);
        this.finishToken(141, this.input.slice(start, this.state.pos));
      };
      _proto.jsxParseIdentifier = function jsxParseIdentifier() {
        var node = this.startNode();
        if (this.match(141)) {
          node.name = this.state.value;
        } else if (tokenIsKeyword(this.state.type)) {
          node.name = tokenLabelName(this.state.type);
        } else {
          this.unexpected();
        }
        this.next();
        return this.finishNode(node, "JSXIdentifier");
      };
      _proto.jsxParseNamespacedName = function jsxParseNamespacedName() {
        var startLoc = this.state.startLoc;
        var name = this.jsxParseIdentifier();
        if (!this.eat(14)) return name;
        var node = this.startNodeAt(startLoc);
        node.namespace = name;
        node.name = this.jsxParseIdentifier();
        return this.finishNode(node, "JSXNamespacedName");
      };
      _proto.jsxParseElementName = function jsxParseElementName() {
        var startLoc = this.state.startLoc;
        var node = this.jsxParseNamespacedName();
        if (node.type === "JSXNamespacedName") {
          return node;
        }
        while (this.eat(16)) {
          var newNode = this.startNodeAt(startLoc);
          newNode.object = node;
          newNode.property = this.jsxParseIdentifier();
          node = this.finishNode(newNode, "JSXMemberExpression");
        }
        return node;
      };
      _proto.jsxParseAttributeValue = function jsxParseAttributeValue() {
        var node;
        switch (this.state.type) {
          case 5:
            node = this.startNode();
            this.setContext(types.brace);
            this.next();
            node = this.jsxParseExpressionContainer(node, types.j_oTag);
            if (node.expression.type === "JSXEmptyExpression") {
              this.raise(JsxErrors.AttributeIsEmpty, node);
            }
            return node;
          case 143:
          case 134:
            return this.parseExprAtom();
          default:
            throw this.raise(JsxErrors.UnsupportedJsxValue, this.state.startLoc);
        }
      };
      _proto.jsxParseEmptyExpression = function jsxParseEmptyExpression() {
        var node = this.startNodeAt(this.state.lastTokEndLoc);
        return this.finishNodeAt(node, "JSXEmptyExpression", this.state.startLoc);
      };
      _proto.jsxParseSpreadChild = function jsxParseSpreadChild(node) {
        this.next();
        node.expression = this.parseExpression();
        this.setContext(types.j_expr);
        this.state.canStartJSXElement = true;
        this.expect(8);
        return this.finishNode(node, "JSXSpreadChild");
      };
      _proto.jsxParseExpressionContainer = function jsxParseExpressionContainer(node, previousContext) {
        if (this.match(8)) {
          node.expression = this.jsxParseEmptyExpression();
        } else {
          var expression = this.parseExpression();
          node.expression = expression;
        }
        this.setContext(previousContext);
        this.state.canStartJSXElement = true;
        this.expect(8);
        return this.finishNode(node, "JSXExpressionContainer");
      };
      _proto.jsxParseAttribute = function jsxParseAttribute() {
        var node = this.startNode();
        if (this.match(5)) {
          this.setContext(types.brace);
          this.next();
          this.expect(21);
          node.argument = this.parseMaybeAssignAllowIn();
          this.setContext(types.j_oTag);
          this.state.canStartJSXElement = true;
          this.expect(8);
          return this.finishNode(node, "JSXSpreadAttribute");
        }
        node.name = this.jsxParseNamespacedName();
        node.value = this.eat(29) ? this.jsxParseAttributeValue() : null;
        return this.finishNode(node, "JSXAttribute");
      };
      _proto.jsxParseOpeningElementAt = function jsxParseOpeningElementAt(startLoc) {
        var node = this.startNodeAt(startLoc);
        if (this.eat(144)) {
          return this.finishNode(node, "JSXOpeningFragment");
        }
        node.name = this.jsxParseElementName();
        return this.jsxParseOpeningElementAfterName(node);
      };
      _proto.jsxParseOpeningElementAfterName = function jsxParseOpeningElementAfterName(node) {
        var attributes = [];
        while (!this.match(56) && !this.match(144)) {
          attributes.push(this.jsxParseAttribute());
        }
        node.attributes = attributes;
        node.selfClosing = this.eat(56);
        this.expect(144);
        return this.finishNode(node, "JSXOpeningElement");
      };
      _proto.jsxParseClosingElementAt = function jsxParseClosingElementAt(startLoc) {
        var node = this.startNodeAt(startLoc);
        if (this.eat(144)) {
          return this.finishNode(node, "JSXClosingFragment");
        }
        node.name = this.jsxParseElementName();
        this.expect(144);
        return this.finishNode(node, "JSXClosingElement");
      };
      _proto.jsxParseElementAt = function jsxParseElementAt(startLoc) {
        var node = this.startNodeAt(startLoc);
        var children = [];
        var openingElement = this.jsxParseOpeningElementAt(startLoc);
        var closingElement = null;
        if (!openingElement.selfClosing) {
          contents: for (;;) {
            switch (this.state.type) {
              case 143:
                startLoc = this.state.startLoc;
                this.next();
                if (this.eat(56)) {
                  closingElement = this.jsxParseClosingElementAt(startLoc);
                  break contents;
                }
                children.push(this.jsxParseElementAt(startLoc));
                break;
              case 142:
                children.push(this.parseLiteral(this.state.value, "JSXText"));
                break;
              case 5:
                {
                  var _node = this.startNode();
                  this.setContext(types.brace);
                  this.next();
                  if (this.match(21)) {
                    children.push(this.jsxParseSpreadChild(_node));
                  } else {
                    children.push(this.jsxParseExpressionContainer(_node, types.j_expr));
                  }
                  break;
                }
              default:
                this.unexpected();
            }
          }
          if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) {
            this.raise(JsxErrors.MissingClosingTagFragment, closingElement);
          } else if (!isFragment(openingElement) && isFragment(closingElement)) {
            this.raise(JsxErrors.MissingClosingTagElement, closingElement, {
              openingTagName: getQualifiedJSXName(openingElement.name)
            });
          } else if (!isFragment(openingElement) && !isFragment(closingElement)) {
            if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
              this.raise(JsxErrors.MissingClosingTagElement, closingElement, {
                openingTagName: getQualifiedJSXName(openingElement.name)
              });
            }
          }
        }
        if (isFragment(openingElement)) {
          node.openingFragment = openingElement;
          node.closingFragment = closingElement;
        } else {
          node.openingElement = openingElement;
          node.closingElement = closingElement;
        }
        node.children = children;
        if (this.match(47)) {
          throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, this.state.startLoc);
        }
        return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement");
      };
      _proto.jsxParseElement = function jsxParseElement() {
        var startLoc = this.state.startLoc;
        this.next();
        return this.jsxParseElementAt(startLoc);
      };
      _proto.setContext = function setContext(newContext) {
        var context = this.state.context;
        context[context.length - 1] = newContext;
      };
      _proto.parseExprAtom = function parseExprAtom(refExpressionErrors) {
        if (this.match(143)) {
          return this.jsxParseElement();
        } else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {
          this.replaceToken(143);
          return this.jsxParseElement();
        } else {
          return _superClass.prototype.parseExprAtom.call(this, refExpressionErrors);
        }
      };
      _proto.skipSpace = function skipSpace() {
        var curContext = this.curContext();
        if (!curContext.preserveSpace) _superClass.prototype.skipSpace.call(this);
      };
      _proto.getTokenFromCode = function getTokenFromCode(code) {
        var context = this.curContext();
        if (context === types.j_expr) {
          this.jsxReadToken();
          return;
        }
        if (context === types.j_oTag || context === types.j_cTag) {
          if (isIdentifierStart(code)) {
            this.jsxReadWord();
            return;
          }
          if (code === 62) {
            ++this.state.pos;
            this.finishToken(144);
            return;
          }
          if ((code === 34 || code === 39) && context === types.j_oTag) {
            this.jsxReadString(code);
            return;
          }
        }
        if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {
          ++this.state.pos;
          this.finishToken(143);
          return;
        }
        _superClass.prototype.getTokenFromCode.call(this, code);
      };
      _proto.updateContext = function updateContext(prevType) {
        var _this$state = this.state,
          context = _this$state.context,
          type = _this$state.type;
        if (type === 56 && prevType === 143) {
          context.splice(-2, 2, types.j_cTag);
          this.state.canStartJSXElement = false;
        } else if (type === 143) {
          context.push(types.j_oTag);
        } else if (type === 144) {
          var out = context[context.length - 1];
          if (out === types.j_oTag && prevType === 56 || out === types.j_cTag) {
            context.pop();
            this.state.canStartJSXElement = context[context.length - 1] === types.j_expr;
          } else {
            this.setContext(types.j_expr);
            this.state.canStartJSXElement = true;
          }
        } else {
          this.state.canStartJSXElement = tokenComesBeforeExpression(type);
        }
      };
      return _createClass(JSXParserMixin);
    }(superClass);
  });

var _templateObject$H;
  function nonNull(x) {
    if (x == null) {
      throw new Error("Unexpected " + x + " value.");
    }
    return x;
  }
  function assert$1(x) {
    if (!x) {
      throw new Error("Assert fail");
    }
  }
  var TSErrors = ParseErrorEnum(_templateObject$H || (_templateObject$H = _taggedTemplateLiteralLoose(["typescript"])))({
    AbstractMethodHasImplementation: function AbstractMethodHasImplementation(_ref) {
      var methodName = _ref.methodName;
      return "Method '" + methodName + "' cannot have an implementation because it is marked abstract.";
    },
    AbstractPropertyHasInitializer: function AbstractPropertyHasInitializer(_ref2) {
      var propertyName = _ref2.propertyName;
      return "Property '" + propertyName + "' cannot have an initializer because it is marked abstract.";
    },
    AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
    AccessorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
    AccessorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
    ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
    ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
    ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "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: function DeclareAccessor(_ref3) {
      var kind = _ref3.kind;
      return "'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: function DuplicateAccessibilityModifier(_ref4) {
      _ref4.modifier;
      return "Accessibility modifier already seen.";
    },
    DuplicateModifier: function DuplicateModifier(_ref5) {
      var modifier = _ref5.modifier;
      return "Duplicate modifier: '" + modifier + "'.";
    },
    EmptyHeritageClauseType: function EmptyHeritageClauseType(_ref6) {
      var token = _ref6.token;
      return "'" + token + "' 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: function IncompatibleModifiers(_ref7) {
      var modifiers = _ref7.modifiers;
      return "'" + modifiers[0] + "' modifier cannot be used with '" + modifiers[1] + "' modifier.";
    },
    IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
    IndexSignatureHasAccessibility: function IndexSignatureHasAccessibility(_ref8) {
      var modifier = _ref8.modifier;
      return "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: function InvalidModifierOnTypeMember(_ref9) {
      var modifier = _ref9.modifier;
      return "'" + modifier + "' modifier cannot appear on a type member.";
    },
    InvalidModifierOnTypeParameter: function InvalidModifierOnTypeParameter(_ref10) {
      var modifier = _ref10.modifier;
      return "'" + modifier + "' modifier cannot appear on a type parameter.";
    },
    InvalidModifierOnTypeParameterPositions: function InvalidModifierOnTypeParameterPositions(_ref11) {
      var modifier = _ref11.modifier;
      return "'" + modifier + "' modifier can only appear on a type parameter of a class, interface or type alias.";
    },
    InvalidModifiersOrder: function InvalidModifiersOrder(_ref12) {
      var orderedModifiers = _ref12.orderedModifiers;
      return "'" + 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.",
    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: function PrivateElementHasAccessibility(_ref13) {
      var modifier = _ref13.modifier;
      return "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.",
    SetAccessorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
    SetAccessorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
    SetAccessorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
    SingleTypeParameterWithoutTrailingComma: function SingleTypeParameterWithoutTrailingComma(_ref14) {
      var typeParameterName = _ref14.typeParameterName;
      return "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: function UnsupportedSignatureParameterKind(_ref15) {
      var type = _ref15.type;
      return "Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got " + type + ".";
    }
  });
  function keywordTypeFromName(value) {
    switch (value) {
      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 undefined;
    }
  }
  function tsIsAccessModifier(modifier) {
    return modifier === "private" || modifier === "public" || modifier === "protected";
  }
  function tsIsVarianceAnnotations(modifier) {
    return modifier === "in" || modifier === "out";
  }
  var tsParseEntityNameFlags = {
    NONE: 0,
    ALLOW_RESERVED_WORDS: 1,
    LEADING_THIS_AS_IDENTIFIER: 2
  };
  var typescript = (function (superClass) {
    return function (_superClass) {
      function TypeScriptParserMixin() {
        var _this;
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }
        _this = _superClass.call.apply(_superClass, [this].concat(args)) || this;
        _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
        });
        return _this;
      }
      _inherits(TypeScriptParserMixin, _superClass);
      var _proto = TypeScriptParserMixin.prototype;
      _proto.getScopeHandler = function getScopeHandler() {
        return TypeScriptScopeHandler;
      };
      _proto.tsIsIdentifier = function tsIsIdentifier() {
        return tokenIsIdentifier(this.state.type);
      };
      _proto.tsTokenCanFollowModifier = function tsTokenCanFollowModifier() {
        return this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(139) || this.isLiteralPropertyName();
      };
      _proto.tsNextTokenOnSameLineAndCanFollowModifier = function tsNextTokenOnSameLineAndCanFollowModifier() {
        this.next();
        if (this.hasPrecedingLineBreak()) {
          return false;
        }
        return this.tsTokenCanFollowModifier();
      };
      _proto.tsNextTokenCanFollowModifier = function tsNextTokenCanFollowModifier() {
        if (this.match(106)) {
          this.next();
          return this.tsTokenCanFollowModifier();
        }
        return this.tsNextTokenOnSameLineAndCanFollowModifier();
      };
      _proto.tsParseModifier = function tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
        if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) {
          return undefined;
        }
        var modifier = this.state.value;
        if (allowedModifiers.includes(modifier)) {
          if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {
            return undefined;
          }
          if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {
            return modifier;
          }
        }
        return undefined;
      };
      _proto.tsParseModifiers = function tsParseModifiers(_ref16, modified) {
        var _this2 = this;
        var allowedModifiers = _ref16.allowedModifiers,
          disallowedModifiers = _ref16.disallowedModifiers,
          stopOnStartOfClassStaticBlock = _ref16.stopOnStartOfClassStaticBlock,
          _ref16$errorTemplate = _ref16.errorTemplate,
          errorTemplate = _ref16$errorTemplate === void 0 ? TSErrors.InvalidModifierOnTypeMember : _ref16$errorTemplate;
        var enforceOrder = function enforceOrder(loc, modifier, before, after) {
          if (modifier === before && modified[after]) {
            _this2.raise(TSErrors.InvalidModifiersOrder, loc, {
              orderedModifiers: [before, after]
            });
          }
        };
        var incompatible = function incompatible(loc, modifier, mod1, mod2) {
          if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {
            _this2.raise(TSErrors.IncompatibleModifiers, loc, {
              modifiers: [mod1, mod2]
            });
          }
        };
        for (;;) {
          var startLoc = this.state.startLoc;
          var modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock);
          if (!modifier) break;
          if (tsIsAccessModifier(modifier)) {
            if (modified.accessibility) {
              this.raise(TSErrors.DuplicateAccessibilityModifier, startLoc, {
                modifier: 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, startLoc, {
                modifier: modifier
              });
            }
            modified[modifier] = true;
            enforceOrder(startLoc, modifier, "in", "out");
          } else {
            if (hasOwnProperty.call(modified, modifier)) {
              this.raise(TSErrors.DuplicateModifier, startLoc, {
                modifier: 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, startLoc, {
              modifier: modifier
            });
          }
        }
      };
      _proto.tsIsListTerminator = function 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);
        }
      };
      _proto.tsParseList = function tsParseList(kind, parseElement) {
        var result = [];
        while (!this.tsIsListTerminator(kind)) {
          result.push(parseElement());
        }
        return result;
      };
      _proto.tsParseDelimitedList = function tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) {
        return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos));
      };
      _proto.tsParseDelimitedListWorker = function tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) {
        var result = [];
        var trailingCommaPos = -1;
        for (;;) {
          if (this.tsIsListTerminator(kind)) {
            break;
          }
          trailingCommaPos = -1;
          var element = parseElement();
          if (element == null) {
            return undefined;
          }
          result.push(element);
          if (this.eat(12)) {
            trailingCommaPos = this.state.lastTokStartLoc.index;
            continue;
          }
          if (this.tsIsListTerminator(kind)) {
            break;
          }
          if (expectSuccess) {
            this.expect(12);
          }
          return undefined;
        }
        if (refTrailingCommaPos) {
          refTrailingCommaPos.value = trailingCommaPos;
        }
        return result;
      };
      _proto.tsParseBracketedList = function tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) {
        if (!skipFirstToken) {
          if (bracket) {
            this.expect(0);
          } else {
            this.expect(47);
          }
        }
        var result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos);
        if (bracket) {
          this.expect(3);
        } else {
          this.expect(48);
        }
        return result;
      };
      _proto.tsParseImportType = function tsParseImportType() {
        var node = this.startNode();
        this.expect(83);
        this.expect(10);
        if (!this.match(134)) {
          this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc);
          {
            node.argument = _superClass.prototype.parseExprAtom.call(this);
          }
        } else {
          {
            node.argument = this.parseStringLiteral(this.state.value);
          }
        }
        if (this.eat(12) && !this.match(11)) {
          node.options = _superClass.prototype.parseMaybeAssignAllowIn.call(this);
          this.eat(12);
        } else {
          node.options = null;
        }
        this.expect(11);
        if (this.eat(16)) {
          node.qualifier = this.tsParseEntityName(tsParseEntityNameFlags.ALLOW_RESERVED_WORDS | tsParseEntityNameFlags.LEADING_THIS_AS_IDENTIFIER);
        }
        if (this.match(47)) {
          {
            node.typeParameters = this.tsParseTypeArguments();
          }
        }
        return this.finishNode(node, "TSImportType");
      };
      _proto.tsParseEntityName = function tsParseEntityName(flags) {
        var entity;
        if (flags & tsParseEntityNameFlags.ALLOW_RESERVED_WORDS && this.match(78)) {
          if (flags & tsParseEntityNameFlags.LEADING_THIS_AS_IDENTIFIER) {
            entity = this.parseIdentifier(true);
          } else {
            var node = this.startNode();
            this.next();
            entity = this.finishNode(node, "ThisExpression");
          }
        } else {
          entity = this.parseIdentifier(!!(flags & tsParseEntityNameFlags.ALLOW_RESERVED_WORDS));
        }
        while (this.eat(16)) {
          var _node = this.startNodeAtNode(entity);
          _node.left = entity;
          _node.right = this.parseIdentifier(!!(flags & tsParseEntityNameFlags.ALLOW_RESERVED_WORDS));
          entity = this.finishNode(_node, "TSQualifiedName");
        }
        return entity;
      };
      _proto.tsParseTypeReference = function tsParseTypeReference() {
        var node = this.startNode();
        node.typeName = this.tsParseEntityName(tsParseEntityNameFlags.ALLOW_RESERVED_WORDS);
        if (!this.hasPrecedingLineBreak() && this.match(47)) {
          {
            node.typeParameters = this.tsParseTypeArguments();
          }
        }
        return this.finishNode(node, "TSTypeReference");
      };
      _proto.tsParseThisTypePredicate = function tsParseThisTypePredicate(lhs) {
        this.next();
        var node = this.startNodeAtNode(lhs);
        node.parameterName = lhs;
        node.typeAnnotation = this.tsParseTypeAnnotation(false);
        node.asserts = false;
        return this.finishNode(node, "TSTypePredicate");
      };
      _proto.tsParseThisTypeNode = function tsParseThisTypeNode() {
        var node = this.startNode();
        this.next();
        return this.finishNode(node, "TSThisType");
      };
      _proto.tsParseTypeQuery = function tsParseTypeQuery() {
        var node = this.startNode();
        this.expect(87);
        if (this.match(83)) {
          node.exprName = this.tsParseImportType();
        } else {
          {
            node.exprName = this.tsParseEntityName(tsParseEntityNameFlags.ALLOW_RESERVED_WORDS | tsParseEntityNameFlags.LEADING_THIS_AS_IDENTIFIER);
          }
        }
        if (!this.hasPrecedingLineBreak() && this.match(47)) {
          {
            node.typeParameters = this.tsParseTypeArguments();
          }
        }
        return this.finishNode(node, "TSTypeQuery");
      };
      _proto.tsParseTypeParameter = function tsParseTypeParameter(parseModifiers) {
        var node = this.startNode();
        parseModifiers(node);
        node.name = this.tsParseTypeParameterName();
        node.constraint = this.tsEatThenParseType(81);
        node["default"] = this.tsEatThenParseType(29);
        return this.finishNode(node, "TSTypeParameter");
      };
      _proto.tsTryParseTypeParameters = function tsTryParseTypeParameters(parseModifiers) {
        if (this.match(47)) {
          return this.tsParseTypeParameters(parseModifiers);
        }
      };
      _proto.tsParseTypeParameters = function tsParseTypeParameters(parseModifiers) {
        var node = this.startNode();
        if (this.match(47) || this.match(143)) {
          this.next();
        } else {
          this.unexpected();
        }
        var refTrailingCommaPos = {
          value: -1
        };
        node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
        if (node.params.length === 0) {
          this.raise(TSErrors.EmptyTypeParameters, node);
        }
        if (refTrailingCommaPos.value !== -1) {
          this.addExtra(node, "trailingComma", refTrailingCommaPos.value);
        }
        return this.finishNode(node, "TSTypeParameterDeclaration");
      };
      _proto.tsFillSignature = function tsFillSignature(returnToken, signature) {
        var returnTokenRequired = returnToken === 19;
        var paramsKey = "parameters";
        var 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);
        }
      };
      _proto.tsParseBindingListForSignature = function tsParseBindingListForSignature() {
        var list = _superClass.prototype.parseBindingList.call(this, 11, 41, ParseBindingListFlags.IS_FUNCTION_PARAMS);
        for (var _i2 = 0; _i2 < list.length; _i2++) {
          var pattern = list[_i2];
          var type = pattern.type;
          if (type === "AssignmentPattern" || type === "TSParameterProperty") {
            this.raise(TSErrors.UnsupportedSignatureParameterKind, pattern, {
              type: type
            });
          }
        }
        return list;
      };
      _proto.tsParseTypeMemberSemicolon = function tsParseTypeMemberSemicolon() {
        if (!this.eat(12) && !this.isLineTerminator()) {
          this.expect(13);
        }
      };
      _proto.tsParseSignatureMember = function tsParseSignatureMember(kind, node) {
        this.tsFillSignature(14, node);
        this.tsParseTypeMemberSemicolon();
        return this.finishNode(node, kind);
      };
      _proto.tsIsUnambiguouslyIndexSignature = function tsIsUnambiguouslyIndexSignature() {
        this.next();
        if (tokenIsIdentifier(this.state.type)) {
          this.next();
          return this.match(14);
        }
        return false;
      };
      _proto.tsTryParseIndexSignature = function tsTryParseIndexSignature(node) {
        if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) {
          return;
        }
        this.expect(0);
        var id = this.parseIdentifier();
        id.typeAnnotation = this.tsParseTypeAnnotation();
        this.resetEndLocation(id);
        this.expect(3);
        node.parameters = [id];
        var type = this.tsTryParseTypeAnnotation();
        if (type) node.typeAnnotation = type;
        this.tsParseTypeMemberSemicolon();
        return this.finishNode(node, "TSIndexSignature");
      };
      _proto.tsParsePropertyOrMethodSignature = function tsParsePropertyOrMethodSignature(node, readonly) {
        if (this.eat(17)) node.optional = true;
        var nodeAny = node;
        if (this.match(10) || this.match(47)) {
          if (readonly) {
            this.raise(TSErrors.ReadonlyForMethodSignature, node);
          }
          var method = nodeAny;
          if (method.kind && this.match(47)) {
            this.raise(TSErrors.AccessorCannotHaveTypeParameters, this.state.curPosition());
          }
          this.tsFillSignature(14, method);
          this.tsParseTypeMemberSemicolon();
          var paramsKey = "parameters";
          var returnTypeKey = "typeAnnotation";
          if (method.kind === "get") {
            if (method[paramsKey].length > 0) {
              this.raise(Errors.BadGetterArity, this.state.curPosition());
              if (this.isThisParam(method[paramsKey][0])) {
                this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());
              }
            }
          } else if (method.kind === "set") {
            if (method[paramsKey].length !== 1) {
              this.raise(Errors.BadSetterArity, this.state.curPosition());
            } else {
              var firstParameter = method[paramsKey][0];
              if (this.isThisParam(firstParameter)) {
                this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());
              }
              if (firstParameter.type === "Identifier" && firstParameter.optional) {
                this.raise(TSErrors.SetAccessorCannotHaveOptionalParameter, this.state.curPosition());
              }
              if (firstParameter.type === "RestElement") {
                this.raise(TSErrors.SetAccessorCannotHaveRestParameter, this.state.curPosition());
              }
            }
            if (method[returnTypeKey]) {
              this.raise(TSErrors.SetAccessorCannotHaveReturnType, method[returnTypeKey]);
            }
          } else {
            method.kind = "method";
          }
          return this.finishNode(method, "TSMethodSignature");
        } else {
          var property = nodeAny;
          if (readonly) property.readonly = true;
          var type = this.tsTryParseTypeAnnotation();
          if (type) property.typeAnnotation = type;
          this.tsParseTypeMemberSemicolon();
          return this.finishNode(property, "TSPropertySignature");
        }
      };
      _proto.tsParseTypeMember = function tsParseTypeMember() {
        var node = this.startNode();
        if (this.match(10) || this.match(47)) {
          return this.tsParseSignatureMember("TSCallSignatureDeclaration", node);
        }
        if (this.match(77)) {
          var id = this.startNode();
          this.next();
          if (this.match(10) || this.match(47)) {
            return this.tsParseSignatureMember("TSConstructSignatureDeclaration", node);
          } else {
            node.key = this.createIdentifier(id, "new");
            return this.tsParsePropertyOrMethodSignature(node, false);
          }
        }
        this.tsParseModifiers({
          allowedModifiers: ["readonly"],
          disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"]
        }, node);
        var idx = this.tsTryParseIndexSignature(node);
        if (idx) {
          return idx;
        }
        _superClass.prototype.parsePropertyName.call(this, node);
        if (!node.computed && node.key.type === "Identifier" && (node.key.name === "get" || node.key.name === "set") && this.tsTokenCanFollowModifier()) {
          node.kind = node.key.name;
          _superClass.prototype.parsePropertyName.call(this, node);
        }
        return this.tsParsePropertyOrMethodSignature(node, !!node.readonly);
      };
      _proto.tsParseTypeLiteral = function tsParseTypeLiteral() {
        var node = this.startNode();
        node.members = this.tsParseObjectTypeMembers();
        return this.finishNode(node, "TSTypeLiteral");
      };
      _proto.tsParseObjectTypeMembers = function tsParseObjectTypeMembers() {
        this.expect(5);
        var members = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this));
        this.expect(8);
        return members;
      };
      _proto.tsIsStartOfMappedType = function tsIsStartOfMappedType() {
        this.next();
        if (this.eat(53)) {
          return this.isContextual(122);
        }
        if (this.isContextual(122)) {
          this.next();
        }
        if (!this.match(0)) {
          return false;
        }
        this.next();
        if (!this.tsIsIdentifier()) {
          return false;
        }
        this.next();
        return this.match(58);
      };
      _proto.tsParseMappedType = function tsParseMappedType() {
        var node = this.startNode();
        this.expect(5);
        if (this.match(53)) {
          node.readonly = this.state.value;
          this.next();
          this.expectContextual(122);
        } else if (this.eatContextual(122)) {
          node.readonly = true;
        }
        this.expect(0);
        {
          var typeParameter = this.startNode();
          typeParameter.name = this.tsParseTypeParameterName();
          typeParameter.constraint = this.tsExpectThenParseType(58);
          node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
        }
        node.nameType = this.eatContextual(93) ? this.tsParseType() : null;
        this.expect(3);
        if (this.match(53)) {
          node.optional = this.state.value;
          this.next();
          this.expect(17);
        } else if (this.eat(17)) {
          node.optional = true;
        }
        node.typeAnnotation = this.tsTryParseType();
        this.semicolon();
        this.expect(8);
        return this.finishNode(node, "TSMappedType");
      };
      _proto.tsParseTupleType = function tsParseTupleType() {
        var _this3 = this;
        var node = this.startNode();
        node.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), true, false);
        var seenOptionalElement = false;
        node.elementTypes.forEach(function (elementNode) {
          var type = elementNode.type;
          if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) {
            _this3.raise(TSErrors.OptionalTypeBeforeRequired, elementNode);
          }
          seenOptionalElement || (seenOptionalElement = type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType");
        });
        return this.finishNode(node, "TSTupleType");
      };
      _proto.tsParseTupleElementType = function tsParseTupleElementType() {
        var startLoc = this.state.startLoc;
        var rest = this.eat(21);
        var labeled;
        var label;
        var optional;
        var type;
        var isWord = tokenIsKeywordOrIdentifier(this.state.type);
        var 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;
          var _startLoc = this.state.startLoc;
          var wordName = this.state.value;
          var typeOrLabel = this.tsParseNonArrayType();
          if (this.lookaheadCharCode() === 58) {
            labeled = true;
            label = this.createIdentifier(this.startNodeAt(_startLoc), 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) {
          var 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, this.state.lastTokStartLoc);
            }
          } else {
            labeledNode = this.startNodeAtNode(type);
            labeledNode.optional = optional;
            this.raise(TSErrors.InvalidTupleMemberLabel, type);
            labeledNode.label = type;
            labeledNode.elementType = this.tsParseType();
          }
          type = this.finishNode(labeledNode, "TSNamedTupleMember");
        } else if (optional) {
          var optionalTypeNode = this.startNodeAtNode(type);
          optionalTypeNode.typeAnnotation = type;
          type = this.finishNode(optionalTypeNode, "TSOptionalType");
        }
        if (rest) {
          var restNode = this.startNodeAt(startLoc);
          restNode.typeAnnotation = type;
          type = this.finishNode(restNode, "TSRestType");
        }
        return type;
      };
      _proto.tsParseParenthesizedType = function tsParseParenthesizedType() {
        var node = this.startNode();
        this.expect(10);
        node.typeAnnotation = this.tsParseType();
        this.expect(11);
        return this.finishNode(node, "TSParenthesizedType");
      };
      _proto.tsParseFunctionOrConstructorType = function tsParseFunctionOrConstructorType(type, _abstract) {
        var _this4 = this;
        var node = this.startNode();
        if (type === "TSConstructorType") {
          node["abstract"] = !!_abstract;
          if (_abstract) this.next();
          this.next();
        }
        this.tsInAllowConditionalTypesContext(function () {
          return _this4.tsFillSignature(19, node);
        });
        return this.finishNode(node, type);
      };
      _proto.tsParseLiteralTypeNode = function tsParseLiteralTypeNode() {
        var node = this.startNode();
        switch (this.state.type) {
          case 135:
          case 136:
          case 134:
          case 85:
          case 86:
            node.literal = _superClass.prototype.parseExprAtom.call(this);
            break;
          default:
            this.unexpected();
        }
        return this.finishNode(node, "TSLiteralType");
      };
      _proto.tsParseTemplateLiteralType = function tsParseTemplateLiteralType() {
        var node = this.startNode();
        node.literal = _superClass.prototype.parseTemplate.call(this, false);
        return this.finishNode(node, "TSLiteralType");
      };
      _proto.parseTemplateSubstitution = function parseTemplateSubstitution() {
        if (this.state.inType) return this.tsParseType();
        return _superClass.prototype.parseTemplateSubstitution.call(this);
      };
      _proto.tsParseThisTypeOrThisTypePredicate = function tsParseThisTypeOrThisTypePredicate() {
        var thisKeyword = this.tsParseThisTypeNode();
        if (this.isContextual(116) && !this.hasPrecedingLineBreak()) {
          return this.tsParseThisTypePredicate(thisKeyword);
        } else {
          return thisKeyword;
        }
      };
      _proto.tsParseNonArrayType = function tsParseNonArrayType() {
        switch (this.state.type) {
          case 134:
          case 135:
          case 136:
          case 85:
          case 86:
            return this.tsParseLiteralTypeNode();
          case 53:
            if (this.state.value === "-") {
              var node = this.startNode();
              var nextToken = this.lookahead();
              if (nextToken.type !== 135 && nextToken.type !== 136) {
                this.unexpected();
              }
              node.literal = this.parseMaybeUnary();
              return this.finishNode(node, "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:
            {
              var type = this.state.type;
              if (tokenIsIdentifier(type) || type === 88 || type === 84) {
                var nodeType = type === 88 ? "TSVoidKeyword" : type === 84 ? "TSNullKeyword" : keywordTypeFromName(this.state.value);
                if (nodeType !== undefined && this.lookaheadCharCode() !== 46) {
                  var _node2 = this.startNode();
                  this.next();
                  return this.finishNode(_node2, nodeType);
                }
                return this.tsParseTypeReference();
              }
            }
        }
        this.unexpected();
      };
      _proto.tsParseArrayTypeOrHigher = function tsParseArrayTypeOrHigher() {
        var type = this.tsParseNonArrayType();
        while (!this.hasPrecedingLineBreak() && this.eat(0)) {
          if (this.match(3)) {
            var node = this.startNodeAtNode(type);
            node.elementType = type;
            this.expect(3);
            type = this.finishNode(node, "TSArrayType");
          } else {
            var _node3 = this.startNodeAtNode(type);
            _node3.objectType = type;
            _node3.indexType = this.tsParseType();
            this.expect(3);
            type = this.finishNode(_node3, "TSIndexedAccessType");
          }
        }
        return type;
      };
      _proto.tsParseTypeOperator = function tsParseTypeOperator() {
        var node = this.startNode();
        var operator = this.state.value;
        this.next();
        node.operator = operator;
        node.typeAnnotation = this.tsParseTypeOperatorOrHigher();
        if (operator === "readonly") {
          this.tsCheckTypeAnnotationForReadOnly(node);
        }
        return this.finishNode(node, "TSTypeOperator");
      };
      _proto.tsCheckTypeAnnotationForReadOnly = function tsCheckTypeAnnotationForReadOnly(node) {
        switch (node.typeAnnotation.type) {
          case "TSTupleType":
          case "TSArrayType":
            return;
          default:
            this.raise(TSErrors.UnexpectedReadonly, node);
        }
      };
      _proto.tsParseInferType = function tsParseInferType() {
        var _this5 = this;
        var node = this.startNode();
        this.expectContextual(115);
        var typeParameter = this.startNode();
        typeParameter.name = this.tsParseTypeParameterName();
        typeParameter.constraint = this.tsTryParse(function () {
          return _this5.tsParseConstraintForInferType();
        });
        node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
        return this.finishNode(node, "TSInferType");
      };
      _proto.tsParseConstraintForInferType = function tsParseConstraintForInferType() {
        var _this6 = this;
        if (this.eat(81)) {
          var constraint = this.tsInDisallowConditionalTypesContext(function () {
            return _this6.tsParseType();
          });
          if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {
            return constraint;
          }
        }
      };
      _proto.tsParseTypeOperatorOrHigher = function tsParseTypeOperatorOrHigher() {
        var _this7 = this;
        var isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;
        return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(115) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(function () {
          return _this7.tsParseArrayTypeOrHigher();
        });
      };
      _proto.tsParseUnionOrIntersectionType = function tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
        var node = this.startNode();
        var hasLeadingOperator = this.eat(operator);
        var types = [];
        do {
          types.push(parseConstituentType());
        } while (this.eat(operator));
        if (types.length === 1 && !hasLeadingOperator) {
          return types[0];
        }
        node.types = types;
        return this.finishNode(node, kind);
      };
      _proto.tsParseIntersectionTypeOrHigher = function tsParseIntersectionTypeOrHigher() {
        return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), 45);
      };
      _proto.tsParseUnionTypeOrHigher = function tsParseUnionTypeOrHigher() {
        return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), 43);
      };
      _proto.tsIsStartOfFunctionType = function tsIsStartOfFunctionType() {
        if (this.match(47)) {
          return true;
        }
        return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
      };
      _proto.tsSkipParameterStart = function tsSkipParameterStart() {
        if (tokenIsIdentifier(this.state.type) || this.match(78)) {
          this.next();
          return true;
        }
        if (this.match(5)) {
          var errors = this.state.errors;
          var previousErrorCount = errors.length;
          try {
            this.parseObjectLike(8, true);
            return errors.length === previousErrorCount;
          } catch (_unused) {
            return false;
          }
        }
        if (this.match(0)) {
          this.next();
          var _errors = this.state.errors;
          var _previousErrorCount = _errors.length;
          try {
            _superClass.prototype.parseBindingList.call(this, 3, 93, ParseBindingListFlags.ALLOW_EMPTY);
            return _errors.length === _previousErrorCount;
          } catch (_unused2) {
            return false;
          }
        }
        return false;
      };
      _proto.tsIsUnambiguouslyStartOfFunctionType = function 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;
      };
      _proto.tsParseTypeOrTypePredicateAnnotation = function tsParseTypeOrTypePredicateAnnotation(returnToken) {
        var _this8 = this;
        return this.tsInType(function () {
          var t = _this8.startNode();
          _this8.expect(returnToken);
          var node = _this8.startNode();
          var asserts = !!_this8.tsTryParse(_this8.tsParseTypePredicateAsserts.bind(_this8));
          if (asserts && _this8.match(78)) {
            var thisTypePredicate = _this8.tsParseThisTypeOrThisTypePredicate();
            if (thisTypePredicate.type === "TSThisType") {
              node.parameterName = thisTypePredicate;
              node.asserts = true;
              node.typeAnnotation = null;
              thisTypePredicate = _this8.finishNode(node, "TSTypePredicate");
            } else {
              _this8.resetStartLocationFromNode(thisTypePredicate, node);
              thisTypePredicate.asserts = true;
            }
            t.typeAnnotation = thisTypePredicate;
            return _this8.finishNode(t, "TSTypeAnnotation");
          }
          var typePredicateVariable = _this8.tsIsIdentifier() && _this8.tsTryParse(_this8.tsParseTypePredicatePrefix.bind(_this8));
          if (!typePredicateVariable) {
            if (!asserts) {
              return _this8.tsParseTypeAnnotation(false, t);
            }
            node.parameterName = _this8.parseIdentifier();
            node.asserts = asserts;
            node.typeAnnotation = null;
            t.typeAnnotation = _this8.finishNode(node, "TSTypePredicate");
            return _this8.finishNode(t, "TSTypeAnnotation");
          }
          var type = _this8.tsParseTypeAnnotation(false);
          node.parameterName = typePredicateVariable;
          node.typeAnnotation = type;
          node.asserts = asserts;
          t.typeAnnotation = _this8.finishNode(node, "TSTypePredicate");
          return _this8.finishNode(t, "TSTypeAnnotation");
        });
      };
      _proto.tsTryParseTypeOrTypePredicateAnnotation = function tsTryParseTypeOrTypePredicateAnnotation() {
        if (this.match(14)) {
          return this.tsParseTypeOrTypePredicateAnnotation(14);
        }
      };
      _proto.tsTryParseTypeAnnotation = function tsTryParseTypeAnnotation() {
        if (this.match(14)) {
          return this.tsParseTypeAnnotation();
        }
      };
      _proto.tsTryParseType = function tsTryParseType() {
        return this.tsEatThenParseType(14);
      };
      _proto.tsParseTypePredicatePrefix = function tsParseTypePredicatePrefix() {
        var id = this.parseIdentifier();
        if (this.isContextual(116) && !this.hasPrecedingLineBreak()) {
          this.next();
          return id;
        }
      };
      _proto.tsParseTypePredicateAsserts = function tsParseTypePredicateAsserts() {
        if (this.state.type !== 109) {
          return false;
        }
        var containsEsc = this.state.containsEsc;
        this.next();
        if (!tokenIsIdentifier(this.state.type) && !this.match(78)) {
          return false;
        }
        if (containsEsc) {
          this.raise(Errors.InvalidEscapedReservedWord, this.state.lastTokStartLoc, {
            reservedWord: "asserts"
          });
        }
        return true;
      };
      _proto.tsParseTypeAnnotation = function tsParseTypeAnnotation(eatColon, t) {
        var _this9 = this;
        if (eatColon === void 0) {
          eatColon = true;
        }
        if (t === void 0) {
          t = this.startNode();
        }
        this.tsInType(function () {
          if (eatColon) _this9.expect(14);
          t.typeAnnotation = _this9.tsParseType();
        });
        return this.finishNode(t, "TSTypeAnnotation");
      };
      _proto.tsParseType = function tsParseType() {
        var _this10 = this;
        assert$1(this.state.inType);
        var type = this.tsParseNonConditionalType();
        if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {
          return type;
        }
        var node = this.startNodeAtNode(type);
        node.checkType = type;
        node.extendsType = this.tsInDisallowConditionalTypesContext(function () {
          return _this10.tsParseNonConditionalType();
        });
        this.expect(17);
        node.trueType = this.tsInAllowConditionalTypesContext(function () {
          return _this10.tsParseType();
        });
        this.expect(14);
        node.falseType = this.tsInAllowConditionalTypesContext(function () {
          return _this10.tsParseType();
        });
        return this.finishNode(node, "TSConditionalType");
      };
      _proto.isAbstractConstructorSignature = function isAbstractConstructorSignature() {
        return this.isContextual(124) && this.lookahead().type === 77;
      };
      _proto.tsParseNonConditionalType = function 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();
      };
      _proto.tsParseTypeAssertion = function tsParseTypeAssertion() {
        var _this11 = this;
        if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
          this.raise(TSErrors.ReservedTypeAssertion, this.state.startLoc);
        }
        var node = this.startNode();
        node.typeAnnotation = this.tsInType(function () {
          _this11.next();
          return _this11.match(75) ? _this11.tsParseTypeReference() : _this11.tsParseType();
        });
        this.expect(48);
        node.expression = this.parseMaybeUnary();
        return this.finishNode(node, "TSTypeAssertion");
      };
      _proto.tsParseHeritageClause = function tsParseHeritageClause(token) {
        var _this12 = this;
        var originalStartLoc = this.state.startLoc;
        var delimitedList = this.tsParseDelimitedList("HeritageClauseElement", function () {
          var node = _this12.startNode();
          {
            node.expression = _this12.tsParseEntityName(tsParseEntityNameFlags.ALLOW_RESERVED_WORDS | tsParseEntityNameFlags.LEADING_THIS_AS_IDENTIFIER);
            if (_this12.match(47)) {
              node.typeParameters = _this12.tsParseTypeArguments();
            }
            return _this12.finishNode(node, "TSExpressionWithTypeArguments");
          }
        });
        if (!delimitedList.length) {
          this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, {
            token: token
          });
        }
        return delimitedList;
      };
      _proto.tsParseInterfaceDeclaration = function tsParseInterfaceDeclaration(node, properties) {
        if (properties === void 0) {
          properties = {};
        }
        if (this.hasFollowingLineBreak()) return null;
        this.expectContextual(129);
        if (properties.declare) node.declare = true;
        if (tokenIsIdentifier(this.state.type)) {
          node.id = this.parseIdentifier();
          this.checkIdentifier(node.id, BindingFlag.TYPE_TS_INTERFACE);
        } else {
          node.id = null;
          this.raise(TSErrors.MissingInterfaceName, this.state.startLoc);
        }
        node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
        if (this.eat(81)) {
          node["extends"] = this.tsParseHeritageClause("extends");
        }
        var body = this.startNode();
        body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));
        node.body = this.finishNode(body, "TSInterfaceBody");
        return this.finishNode(node, "TSInterfaceDeclaration");
      };
      _proto.tsParseTypeAliasDeclaration = function tsParseTypeAliasDeclaration(node) {
        var _this13 = this;
        node.id = this.parseIdentifier();
        this.checkIdentifier(node.id, BindingFlag.TYPE_TS_TYPE);
        node.typeAnnotation = this.tsInType(function () {
          node.typeParameters = _this13.tsTryParseTypeParameters(_this13.tsParseInOutModifiers);
          _this13.expect(29);
          if (_this13.isContextual(114) && _this13.lookahead().type !== 16) {
            var _node4 = _this13.startNode();
            _this13.next();
            return _this13.finishNode(_node4, "TSIntrinsicKeyword");
          }
          return _this13.tsParseType();
        });
        this.semicolon();
        return this.finishNode(node, "TSTypeAliasDeclaration");
      };
      _proto.tsInTopLevelContext = function tsInTopLevelContext(cb) {
        if (this.curContext() !== types.brace) {
          var oldContext = this.state.context;
          this.state.context = [oldContext[0]];
          try {
            return cb();
          } finally {
            this.state.context = oldContext;
          }
        } else {
          return cb();
        }
      };
      _proto.tsInType = function tsInType(cb) {
        var oldInType = this.state.inType;
        this.state.inType = true;
        try {
          return cb();
        } finally {
          this.state.inType = oldInType;
        }
      };
      _proto.tsInDisallowConditionalTypesContext = function tsInDisallowConditionalTypesContext(cb) {
        var oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
        this.state.inDisallowConditionalTypesContext = true;
        try {
          return cb();
        } finally {
          this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
        }
      };
      _proto.tsInAllowConditionalTypesContext = function tsInAllowConditionalTypesContext(cb) {
        var oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
        this.state.inDisallowConditionalTypesContext = false;
        try {
          return cb();
        } finally {
          this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
        }
      };
      _proto.tsEatThenParseType = function tsEatThenParseType(token) {
        if (this.match(token)) {
          return this.tsNextThenParseType();
        }
      };
      _proto.tsExpectThenParseType = function tsExpectThenParseType(token) {
        var _this14 = this;
        return this.tsInType(function () {
          _this14.expect(token);
          return _this14.tsParseType();
        });
      };
      _proto.tsNextThenParseType = function tsNextThenParseType() {
        var _this15 = this;
        return this.tsInType(function () {
          _this15.next();
          return _this15.tsParseType();
        });
      };
      _proto.tsParseEnumMember = function tsParseEnumMember() {
        var node = this.startNode();
        node.id = this.match(134) ? _superClass.prototype.parseStringLiteral.call(this, this.state.value) : this.parseIdentifier(true);
        if (this.eat(29)) {
          node.initializer = _superClass.prototype.parseMaybeAssignAllowIn.call(this);
        }
        return this.finishNode(node, "TSEnumMember");
      };
      _proto.tsParseEnumDeclaration = function tsParseEnumDeclaration(node, properties) {
        if (properties === void 0) {
          properties = {};
        }
        if (properties["const"]) node["const"] = true;
        if (properties.declare) node.declare = true;
        this.expectContextual(126);
        node.id = this.parseIdentifier();
        this.checkIdentifier(node.id, node["const"] ? BindingFlag.TYPE_TS_CONST_ENUM : BindingFlag.TYPE_TS_ENUM);
        {
          this.expect(5);
          node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
          this.expect(8);
        }
        return this.finishNode(node, "TSEnumDeclaration");
      };
      _proto.tsParseEnumBody = function tsParseEnumBody() {
        var node = this.startNode();
        this.expect(5);
        node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
        this.expect(8);
        return this.finishNode(node, "TSEnumBody");
      };
      _proto.tsParseModuleBlock = function tsParseModuleBlock() {
        var node = this.startNode();
        this.scope.enter(ScopeFlag.OTHER);
        this.expect(5);
        _superClass.prototype.parseBlockOrModuleBlockBody.call(this, node.body = [], undefined, true, 8);
        this.scope.exit();
        return this.finishNode(node, "TSModuleBlock");
      };
      _proto.tsParseModuleOrNamespaceDeclaration = function tsParseModuleOrNamespaceDeclaration(node, nested) {
        if (nested === void 0) {
          nested = false;
        }
        node.id = this.parseIdentifier();
        if (!nested) {
          this.checkIdentifier(node.id, BindingFlag.TYPE_TS_NAMESPACE);
        }
        if (this.eat(16)) {
          var inner = this.startNode();
          this.tsParseModuleOrNamespaceDeclaration(inner, true);
          node.body = inner;
        } else {
          this.scope.enter(ScopeFlag.TS_MODULE);
          this.prodParam.enter(ParamKind.PARAM);
          node.body = this.tsParseModuleBlock();
          this.prodParam.exit();
          this.scope.exit();
        }
        return this.finishNode(node, "TSModuleDeclaration");
      };
      _proto.tsParseAmbientExternalModuleDeclaration = function tsParseAmbientExternalModuleDeclaration(node) {
        if (this.isContextual(112)) {
          node.kind = "global";
          {
            node.global = true;
          }
          node.id = this.parseIdentifier();
        } else if (this.match(134)) {
          node.kind = "module";
          node.id = _superClass.prototype.parseStringLiteral.call(this, this.state.value);
        } else {
          this.unexpected();
        }
        if (this.match(5)) {
          this.scope.enter(ScopeFlag.TS_MODULE);
          this.prodParam.enter(ParamKind.PARAM);
          node.body = this.tsParseModuleBlock();
          this.prodParam.exit();
          this.scope.exit();
        } else {
          this.semicolon();
        }
        return this.finishNode(node, "TSModuleDeclaration");
      };
      _proto.tsParseImportEqualsDeclaration = function tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) {
        node.isExport = isExport || false;
        node.id = maybeDefaultIdentifier || this.parseIdentifier();
        this.checkIdentifier(node.id, BindingFlag.TYPE_TS_VALUE_IMPORT);
        this.expect(29);
        var moduleReference = this.tsParseModuleReference();
        if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") {
          this.raise(TSErrors.ImportAliasHasImportType, moduleReference);
        }
        node.moduleReference = moduleReference;
        this.semicolon();
        return this.finishNode(node, "TSImportEqualsDeclaration");
      };
      _proto.tsIsExternalModuleReference = function tsIsExternalModuleReference() {
        return this.isContextual(119) && this.lookaheadCharCode() === 40;
      };
      _proto.tsParseModuleReference = function tsParseModuleReference() {
        return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(tsParseEntityNameFlags.NONE);
      };
      _proto.tsParseExternalModuleReference = function tsParseExternalModuleReference() {
        var node = this.startNode();
        this.expectContextual(119);
        this.expect(10);
        if (!this.match(134)) {
          this.unexpected();
        }
        node.expression = _superClass.prototype.parseExprAtom.call(this);
        this.expect(11);
        this.sawUnambiguousESM = true;
        return this.finishNode(node, "TSExternalModuleReference");
      };
      _proto.tsLookAhead = function tsLookAhead(f) {
        var state = this.state.clone();
        var res = f();
        this.state = state;
        return res;
      };
      _proto.tsTryParseAndCatch = function tsTryParseAndCatch(f) {
        var result = this.tryParse(function (abort) {
          return (f() || abort()
          );
        });
        if (result.aborted || !result.node) return;
        if (result.error) this.state = result.failState;
        return result.node;
      };
      _proto.tsTryParse = function tsTryParse(f) {
        var state = this.state.clone();
        var result = f();
        if (result !== undefined && result !== false) {
          return result;
        }
        this.state = state;
      };
      _proto.tsTryParseDeclare = function tsTryParseDeclare(nany) {
        var _this16 = this;
        if (this.isLineTerminator()) {
          return;
        }
        var startType = this.state.type;
        var kind;
        if (this.isContextual(100)) {
          startType = 74;
          kind = "let";
        }
        return this.tsInAmbientContext(function () {
          switch (startType) {
            case 68:
              nany.declare = true;
              return _superClass.prototype.parseFunctionStatement.call(_this16, nany, false, false);
            case 80:
              nany.declare = true;
              return _this16.parseClass(nany, true, false);
            case 126:
              return _this16.tsParseEnumDeclaration(nany, {
                declare: true
              });
            case 112:
              return _this16.tsParseAmbientExternalModuleDeclaration(nany);
            case 75:
            case 74:
              if (!_this16.match(75) || !_this16.isLookaheadContextual("enum")) {
                nany.declare = true;
                return _this16.parseVarStatement(nany, kind || _this16.state.value, true);
              }
              _this16.expect(75);
              return _this16.tsParseEnumDeclaration(nany, {
                "const": true,
                declare: true
              });
            case 129:
              {
                var result = _this16.tsParseInterfaceDeclaration(nany, {
                  declare: true
                });
                if (result) return result;
              }
            default:
              if (tokenIsIdentifier(startType)) {
                return _this16.tsParseDeclaration(nany, _this16.state.value, true, null);
              }
          }
        });
      };
      _proto.tsTryParseExportDeclaration = function tsTryParseExportDeclaration() {
        return this.tsParseDeclaration(this.startNode(), this.state.value, true, null);
      };
      _proto.tsParseExpressionStatement = function tsParseExpressionStatement(node, expr, decorators) {
        switch (expr.name) {
          case "declare":
            {
              var declaration = this.tsTryParseDeclare(node);
              if (declaration) {
                declaration.declare = true;
              }
              return declaration;
            }
          case "global":
            if (this.match(5)) {
              this.scope.enter(ScopeFlag.TS_MODULE);
              this.prodParam.enter(ParamKind.PARAM);
              var mod = node;
              mod.kind = "global";
              {
                node.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(node, expr.name, false, decorators);
        }
      };
      _proto.tsParseDeclaration = function tsParseDeclaration(node, value, next, decorators) {
        switch (value) {
          case "abstract":
            if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) {
              return this.tsParseAbstractDeclaration(node, decorators);
            }
            break;
          case "module":
            if (this.tsCheckLineTerminator(next)) {
              if (this.match(134)) {
                return this.tsParseAmbientExternalModuleDeclaration(node);
              } else if (tokenIsIdentifier(this.state.type)) {
                node.kind = "module";
                return this.tsParseModuleOrNamespaceDeclaration(node);
              }
            }
            break;
          case "namespace":
            if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
              node.kind = "namespace";
              return this.tsParseModuleOrNamespaceDeclaration(node);
            }
            break;
          case "type":
            if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
              return this.tsParseTypeAliasDeclaration(node);
            }
            break;
        }
      };
      _proto.tsCheckLineTerminator = function tsCheckLineTerminator(next) {
        if (next) {
          if (this.hasFollowingLineBreak()) return false;
          this.next();
          return true;
        }
        return !this.isLineTerminator();
      };
      _proto.tsTryParseGenericAsyncArrowFunction = function tsTryParseGenericAsyncArrowFunction(startLoc) {
        var _this17 = this;
        if (!this.match(47)) return;
        var oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
        this.state.maybeInArrowParameters = true;
        var res = this.tsTryParseAndCatch(function () {
          var node = _this17.startNodeAt(startLoc);
          node.typeParameters = _this17.tsParseTypeParameters(_this17.tsParseConstModifier);
          _superClass.prototype.parseFunctionParams.call(_this17, node);
          node.returnType = _this17.tsTryParseTypeOrTypePredicateAnnotation();
          _this17.expect(19);
          return node;
        });
        this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
        if (!res) return;
        return _superClass.prototype.parseArrowExpression.call(this, res, null, true);
      };
      _proto.tsParseTypeArgumentsInExpression = function tsParseTypeArgumentsInExpression() {
        if (this.reScan_lt() !== 47) return;
        return this.tsParseTypeArguments();
      };
      _proto.tsParseTypeArguments = function tsParseTypeArguments() {
        var _this18 = this;
        var node = this.startNode();
        node.params = this.tsInType(function () {
          return _this18.tsInTopLevelContext(function () {
            _this18.expect(47);
            return _this18.tsParseDelimitedList("TypeParametersOrArguments", _this18.tsParseType.bind(_this18));
          });
        });
        if (node.params.length === 0) {
          this.raise(TSErrors.EmptyTypeArguments, node);
        } else if (!this.state.inType && this.curContext() === types.brace) {
          this.reScan_lt_gt();
        }
        this.expect(48);
        return this.finishNode(node, "TSTypeParameterInstantiation");
      };
      _proto.tsIsDeclarationStart = function tsIsDeclarationStart() {
        return tokenIsTSDeclarationStart(this.state.type);
      };
      _proto.isExportDefaultSpecifier = function isExportDefaultSpecifier() {
        if (this.tsIsDeclarationStart()) return false;
        return _superClass.prototype.isExportDefaultSpecifier.call(this);
      };
      _proto.parseAssignableListItem = function parseAssignableListItem(flags, decorators) {
        var startLoc = this.state.startLoc;
        var modified = {};
        this.tsParseModifiers({
          allowedModifiers: ["public", "private", "protected", "override", "readonly"]
        }, modified);
        var accessibility = modified.accessibility;
        var override = modified.override;
        var readonly = modified.readonly;
        if (!(flags & ParseBindingListFlags.IS_CONSTRUCTOR_PARAMS) && (accessibility || readonly || override)) {
          this.raise(TSErrors.UnexpectedParameterModifier, startLoc);
        }
        var left = this.parseMaybeDefault();
        if (flags & ParseBindingListFlags.IS_FUNCTION_PARAMS) {
          this.parseFunctionParamType(left);
        }
        var elt = this.parseMaybeDefault(left.loc.start, left);
        if (accessibility || readonly || override) {
          var pp = this.startNodeAt(startLoc);
          if (decorators.length) {
            pp.decorators = decorators;
          }
          if (accessibility) pp.accessibility = accessibility;
          if (readonly) pp.readonly = readonly;
          if (override) pp.override = override;
          if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") {
            this.raise(TSErrors.UnsupportedParameterPropertyKind, pp);
          }
          pp.parameter = elt;
          return this.finishNode(pp, "TSParameterProperty");
        }
        if (decorators.length) {
          left.decorators = decorators;
        }
        return elt;
      };
      _proto.isSimpleParameter = function isSimpleParameter(node) {
        return node.type === "TSParameterProperty" && _superClass.prototype.isSimpleParameter.call(this, node.parameter) || _superClass.prototype.isSimpleParameter.call(this, node);
      };
      _proto.tsDisallowOptionalPattern = function tsDisallowOptionalPattern(node) {
        for (var _i4 = 0, _node$params2 = node.params; _i4 < _node$params2.length; _i4++) {
          var param = _node$params2[_i4];
          if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) {
            this.raise(TSErrors.PatternIsOptional, param);
          }
        }
      };
      _proto.setArrowFunctionParameters = function setArrowFunctionParameters(node, params, trailingCommaLoc) {
        _superClass.prototype.setArrowFunctionParameters.call(this, node, params, trailingCommaLoc);
        this.tsDisallowOptionalPattern(node);
      };
      _proto.parseFunctionBodyAndFinish = function parseFunctionBodyAndFinish(node, type, isMethod) {
        if (isMethod === void 0) {
          isMethod = false;
        }
        if (this.match(14)) {
          node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
        }
        var bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" || type === "ClassPrivateMethod" ? "TSDeclareMethod" : undefined;
        if (bodilessType && !this.match(5) && this.isLineTerminator()) {
          return this.finishNode(node, bodilessType);
        }
        if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) {
          this.raise(TSErrors.DeclareFunctionHasImplementation, node);
          if (node.declare) {
            return _superClass.prototype.parseFunctionBodyAndFinish.call(this, node, bodilessType, isMethod);
          }
        }
        this.tsDisallowOptionalPattern(node);
        return _superClass.prototype.parseFunctionBodyAndFinish.call(this, node, type, isMethod);
      };
      _proto.registerFunctionStatementId = function registerFunctionStatementId(node) {
        if (!node.body && node.id) {
          this.checkIdentifier(node.id, BindingFlag.TYPE_TS_AMBIENT);
        } else {
          _superClass.prototype.registerFunctionStatementId.call(this, node);
        }
      };
      _proto.tsCheckForInvalidTypeCasts = function tsCheckForInvalidTypeCasts(items) {
        var _this19 = this;
        items.forEach(function (node) {
          if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") {
            _this19.raise(TSErrors.UnexpectedTypeAnnotation, node.typeAnnotation);
          }
        });
      };
      _proto.toReferencedList = function toReferencedList(exprList, isInParens) {
        this.tsCheckForInvalidTypeCasts(exprList);
        return exprList;
      };
      _proto.parseArrayLike = function parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
        var node = _superClass.prototype.parseArrayLike.call(this, close, canBePattern, isTuple, refExpressionErrors);
        if (node.type === "ArrayExpression") {
          this.tsCheckForInvalidTypeCasts(node.elements);
        }
        return node;
      };
      _proto.parseSubscript = function parseSubscript(base, startLoc, noCalls, state) {
        var _this20 = this;
        if (!this.hasPrecedingLineBreak() && this.match(35)) {
          this.state.canStartJSXElement = false;
          this.next();
          var nonNullExpression = this.startNodeAt(startLoc);
          nonNullExpression.expression = base;
          return this.finishNode(nonNullExpression, "TSNonNullExpression");
        }
        var isOptionalCall = false;
        if (this.match(18) && this.lookaheadCharCode() === 60) {
          if (noCalls) {
            state.stop = true;
            return base;
          }
          state.optionalChainMember = isOptionalCall = true;
          this.next();
        }
        if (this.match(47) || this.match(51)) {
          var missingParenErrorLoc;
          var result = this.tsTryParseAndCatch(function () {
            if (!noCalls && _this20.atPossibleAsyncArrow(base)) {
              var asyncArrowFn = _this20.tsTryParseGenericAsyncArrowFunction(startLoc);
              if (asyncArrowFn) {
                return asyncArrowFn;
              }
            }
            var typeArguments = _this20.tsParseTypeArgumentsInExpression();
            if (!typeArguments) return;
            if (isOptionalCall && !_this20.match(10)) {
              missingParenErrorLoc = _this20.state.curPosition();
              return;
            }
            if (tokenIsTemplate(_this20.state.type)) {
              var _result = _superClass.prototype.parseTaggedTemplateExpression.call(_this20, base, startLoc, state);
              {
                _result.typeParameters = typeArguments;
              }
              return _result;
            }
            if (!noCalls && _this20.eat(10)) {
              var _node5 = _this20.startNodeAt(startLoc);
              _node5.callee = base;
              _node5.arguments = _this20.parseCallExpressionArguments(11);
              _this20.tsCheckForInvalidTypeCasts(_node5.arguments);
              {
                _node5.typeParameters = typeArguments;
              }
              if (state.optionalChainMember) {
                _node5.optional = isOptionalCall;
              }
              return _this20.finishCallExpression(_node5, state.optionalChainMember);
            }
            var tokenType = _this20.state.type;
            if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && tokenCanStartExpression(tokenType) && !_this20.hasPrecedingLineBreak()) {
              return;
            }
            var node = _this20.startNodeAt(startLoc);
            node.expression = base;
            {
              node.typeParameters = typeArguments;
            }
            return _this20.finishNode(node, "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, this.state.startLoc);
            }
            return result;
          }
        }
        return _superClass.prototype.parseSubscript.call(this, base, startLoc, noCalls, state);
      };
      _proto.parseNewCallee = function parseNewCallee(node) {
        var _callee$extra;
        _superClass.prototype.parseNewCallee.call(this, node);
        var callee = node.callee;
        if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {
          {
            node.typeParameters = callee.typeParameters;
          }
          node.callee = callee.expression;
        }
      };
      _proto.parseExprOp = function parseExprOp(left, leftStartLoc, minPrec) {
        var _this21 = this;
        var isSatisfies;
        if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(120)))) {
          var node = this.startNodeAt(leftStartLoc);
          node.expression = left;
          node.typeAnnotation = this.tsInType(function () {
            _this21.next();
            if (_this21.match(75)) {
              if (isSatisfies) {
                _this21.raise(Errors.UnexpectedKeyword, _this21.state.startLoc, {
                  keyword: "const"
                });
              }
              return _this21.tsParseTypeReference();
            }
            return _this21.tsParseType();
          });
          this.finishNode(node, isSatisfies ? "TSSatisfiesExpression" : "TSAsExpression");
          this.reScan_lt_gt();
          return this.parseExprOp(node, leftStartLoc, minPrec);
        }
        return _superClass.prototype.parseExprOp.call(this, left, leftStartLoc, minPrec);
      };
      _proto.checkReservedWord = function checkReservedWord(word, startLoc, checkKeywords, isBinding) {
        if (!this.state.isAmbientContext) {
          _superClass.prototype.checkReservedWord.call(this, word, startLoc, checkKeywords, isBinding);
        }
      };
      _proto.checkImportReflection = function checkImportReflection(node) {
        _superClass.prototype.checkImportReflection.call(this, node);
        if (node.module && node.importKind !== "value") {
          this.raise(TSErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);
        }
      };
      _proto.checkDuplicateExports = function checkDuplicateExports() {};
      _proto.isPotentialImportPhase = function isPotentialImportPhase(isExport) {
        if (_superClass.prototype.isPotentialImportPhase.call(this, isExport)) return true;
        if (this.isContextual(130)) {
          var ch = this.lookaheadCharCode();
          return isExport ? ch === 123 || ch === 42 : ch !== 61;
        }
        return !isExport && this.isContextual(87);
      };
      _proto.applyImportPhase = function applyImportPhase(node, isExport, phase, loc) {
        _superClass.prototype.applyImportPhase.call(this, node, isExport, phase, loc);
        if (isExport) {
          node.exportKind = phase === "type" ? "type" : "value";
        } else {
          node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
        }
      };
      _proto.parseImport = function parseImport(node) {
        if (this.match(134)) {
          node.importKind = "value";
          return _superClass.prototype.parseImport.call(this, node);
        }
        var importNode;
        if (tokenIsIdentifier(this.state.type) && this.lookaheadCharCode() === 61) {
          node.importKind = "value";
          return this.tsParseImportEqualsDeclaration(node);
        } else if (this.isContextual(130)) {
          var maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
          if (this.lookaheadCharCode() === 61) {
            return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier);
          } else {
            importNode = _superClass.prototype.parseImportSpecifiersAndAfter.call(this, node, maybeDefaultIdentifier);
          }
        } else {
          importNode = _superClass.prototype.parseImport.call(this, node);
        }
        if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
          this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, importNode);
        }
        return importNode;
      };
      _proto.parseExport = function parseExport(node, decorators) {
        if (this.match(83)) {
          this.next();
          var nodeImportEquals = node;
          var maybeDefaultIdentifier = null;
          if (this.isContextual(130) && this.isPotentialImportPhase(false)) {
            maybeDefaultIdentifier = this.parseMaybeImportPhase(nodeImportEquals, false);
          } else {
            nodeImportEquals.importKind = "value";
          }
          return this.tsParseImportEqualsDeclaration(nodeImportEquals, maybeDefaultIdentifier, true);
        } else if (this.eat(29)) {
          var assign = node;
          assign.expression = _superClass.prototype.parseExpression.call(this);
          this.semicolon();
          this.sawUnambiguousESM = true;
          return this.finishNode(assign, "TSExportAssignment");
        } else if (this.eatContextual(93)) {
          var decl = node;
          this.expectContextual(128);
          decl.id = this.parseIdentifier();
          this.semicolon();
          return this.finishNode(decl, "TSNamespaceExportDeclaration");
        } else {
          return _superClass.prototype.parseExport.call(this, node, decorators);
        }
      };
      _proto.isAbstractClass = function isAbstractClass() {
        return this.isContextual(124) && this.lookahead().type === 80;
      };
      _proto.parseExportDefaultExpression = function parseExportDefaultExpression() {
        if (this.isAbstractClass()) {
          var cls = this.startNode();
          this.next();
          cls["abstract"] = true;
          return this.parseClass(cls, true, true);
        }
        if (this.match(129)) {
          var result = this.tsParseInterfaceDeclaration(this.startNode());
          if (result) return result;
        }
        return _superClass.prototype.parseExportDefaultExpression.call(this);
      };
      _proto.parseVarStatement = function parseVarStatement(node, kind, allowMissingInitializer) {
        if (allowMissingInitializer === void 0) {
          allowMissingInitializer = false;
        }
        var isAmbientContext = this.state.isAmbientContext;
        var declaration = _superClass.prototype.parseVarStatement.call(this, node, kind, allowMissingInitializer || isAmbientContext);
        if (!isAmbientContext) return declaration;
        for (var _i6 = 0, _declaration$declarat2 = declaration.declarations; _i6 < _declaration$declarat2.length; _i6++) {
          var _declaration$declarat3 = _declaration$declarat2[_i6],
            id = _declaration$declarat3.id,
            init = _declaration$declarat3.init;
          if (!init) continue;
          if (kind !== "const" || !!id.typeAnnotation) {
            this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);
          } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
            this.raise(TSErrors.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
          }
        }
        return declaration;
      };
      _proto.parseStatementContent = function parseStatementContent(flags, decorators) {
        if (this.match(75) && this.isLookaheadContextual("enum")) {
          var node = this.startNode();
          this.expect(75);
          return this.tsParseEnumDeclaration(node, {
            "const": true
          });
        }
        if (this.isContextual(126)) {
          return this.tsParseEnumDeclaration(this.startNode());
        }
        if (this.isContextual(129)) {
          var result = this.tsParseInterfaceDeclaration(this.startNode());
          if (result) return result;
        }
        return _superClass.prototype.parseStatementContent.call(this, flags, decorators);
      };
      _proto.parseAccessModifier = function parseAccessModifier() {
        return this.tsParseModifier(["public", "protected", "private"]);
      };
      _proto.tsHasSomeModifiers = function tsHasSomeModifiers(member, modifiers) {
        return modifiers.some(function (modifier) {
          if (tsIsAccessModifier(modifier)) {
            return member.accessibility === modifier;
          }
          return !!member[modifier];
        });
      };
      _proto.tsIsStartOfStaticBlocks = function tsIsStartOfStaticBlocks() {
        return this.isContextual(106) && this.lookaheadCharCode() === 123;
      };
      _proto.parseClassMember = function parseClassMember(classBody, member, state) {
        var _this22 = this;
        var modifiers = ["declare", "private", "public", "protected", "override", "abstract", "readonly", "static"];
        this.tsParseModifiers({
          allowedModifiers: modifiers,
          disallowedModifiers: ["in", "out"],
          stopOnStartOfClassStaticBlock: true,
          errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
        }, member);
        var callParseClassMemberWithIsStatic = function callParseClassMemberWithIsStatic() {
          if (_this22.tsIsStartOfStaticBlocks()) {
            _this22.next();
            _this22.next();
            if (_this22.tsHasSomeModifiers(member, modifiers)) {
              _this22.raise(TSErrors.StaticBlockCannotHaveModifier, _this22.state.curPosition());
            }
            _superClass.prototype.parseClassStaticBlock.call(_this22, classBody, member);
          } else {
            _this22.parseClassMemberWithIsStatic(classBody, member, state, !!member["static"]);
          }
        };
        if (member.declare) {
          this.tsInAmbientContext(callParseClassMemberWithIsStatic);
        } else {
          callParseClassMemberWithIsStatic();
        }
      };
      _proto.parseClassMemberWithIsStatic = function parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
        var idx = this.tsTryParseIndexSignature(member);
        if (idx) {
          classBody.body.push(idx);
          if (member["abstract"]) {
            this.raise(TSErrors.IndexSignatureHasAbstract, member);
          }
          if (member.accessibility) {
            this.raise(TSErrors.IndexSignatureHasAccessibility, member, {
              modifier: member.accessibility
            });
          }
          if (member.declare) {
            this.raise(TSErrors.IndexSignatureHasDeclare, member);
          }
          if (member.override) {
            this.raise(TSErrors.IndexSignatureHasOverride, member);
          }
          return;
        }
        if (!this.state.inAbstractClass && member["abstract"]) {
          this.raise(TSErrors.NonAbstractClassHasAbstractMethod, member);
        }
        if (member.override) {
          if (!state.hadSuperClass) {
            this.raise(TSErrors.OverrideNotInSubClass, member);
          }
        }
        _superClass.prototype.parseClassMemberWithIsStatic.call(this, classBody, member, state, isStatic);
      };
      _proto.parsePostMemberNameModifiers = function parsePostMemberNameModifiers(methodOrProp) {
        var optional = this.eat(17);
        if (optional) methodOrProp.optional = true;
        if (methodOrProp.readonly && this.match(10)) {
          this.raise(TSErrors.ClassMethodHasReadonly, methodOrProp);
        }
        if (methodOrProp.declare && this.match(10)) {
          this.raise(TSErrors.ClassMethodHasDeclare, methodOrProp);
        }
      };
      _proto.parseExpressionStatement = function parseExpressionStatement(node, expr, decorators) {
        var decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node, expr, decorators) : undefined;
        return decl || _superClass.prototype.parseExpressionStatement.call(this, node, expr, decorators);
      };
      _proto.shouldParseExportDeclaration = function shouldParseExportDeclaration() {
        if (this.tsIsDeclarationStart()) return true;
        return _superClass.prototype.shouldParseExportDeclaration.call(this);
      };
      _proto.parseConditional = function parseConditional(expr, startLoc, refExpressionErrors) {
        var _this23 = this;
        if (!this.state.maybeInArrowParameters || !this.match(17)) {
          return _superClass.prototype.parseConditional.call(this, expr, startLoc, refExpressionErrors);
        }
        var result = this.tryParse(function () {
          return _superClass.prototype.parseConditional.call(_this23, expr, startLoc);
        });
        if (!result.node) {
          if (result.error) {
            _superClass.prototype.setOptionalParametersError.call(this, refExpressionErrors, result.error);
          }
          return expr;
        }
        if (result.error) this.state = result.failState;
        return result.node;
      };
      _proto.parseParenItem = function parseParenItem(node, startLoc) {
        var newNode = _superClass.prototype.parseParenItem.call(this, node, startLoc);
        if (this.eat(17)) {
          newNode.optional = true;
          this.resetEndLocation(node);
        }
        if (this.match(14)) {
          var typeCastNode = this.startNodeAt(startLoc);
          typeCastNode.expression = node;
          typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();
          return this.finishNode(typeCastNode, "TSTypeCastExpression");
        }
        return node;
      };
      _proto.parseExportDeclaration = function parseExportDeclaration(node) {
        var _this24 = this;
        if (!this.state.isAmbientContext && this.isContextual(125)) {
          return this.tsInAmbientContext(function () {
            return _this24.parseExportDeclaration(node);
          });
        }
        var startLoc = this.state.startLoc;
        var isDeclare = this.eatContextual(125);
        if (isDeclare && (this.isContextual(125) || !this.shouldParseExportDeclaration())) {
          throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, this.state.startLoc);
        }
        var isIdentifier = tokenIsIdentifier(this.state.type);
        var declaration = isIdentifier && this.tsTryParseExportDeclaration() || _superClass.prototype.parseExportDeclaration.call(this, node);
        if (!declaration) return null;
        if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) {
          node.exportKind = "type";
        }
        if (isDeclare) {
          this.resetStartLocation(declaration, startLoc);
          declaration.declare = true;
        }
        return declaration;
      };
      _proto.parseClassId = function parseClassId(node, isStatement, optionalId, bindingType) {
        if ((!isStatement || optionalId) && this.isContextual(113)) {
          return;
        }
        _superClass.prototype.parseClassId.call(this, node, isStatement, optionalId, node.declare ? BindingFlag.TYPE_TS_AMBIENT : BindingFlag.TYPE_CLASS);
        var typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
        if (typeParameters) node.typeParameters = typeParameters;
      };
      _proto.parseClassPropertyAnnotation = function parseClassPropertyAnnotation(node) {
        if (!node.optional) {
          if (this.eat(35)) {
            node.definite = true;
          } else if (this.eat(17)) {
            node.optional = true;
          }
        }
        var type = this.tsTryParseTypeAnnotation();
        if (type) node.typeAnnotation = type;
      };
      _proto.parseClassProperty = function parseClassProperty(node) {
        this.parseClassPropertyAnnotation(node);
        if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) {
          this.raise(TSErrors.DeclareClassFieldHasInitializer, this.state.startLoc);
        }
        if (node["abstract"] && this.match(29)) {
          var _key2 = node.key;
          this.raise(TSErrors.AbstractPropertyHasInitializer, this.state.startLoc, {
            propertyName: _key2.type === "Identifier" && !node.computed ? _key2.name : "[" + this.input.slice(this.offsetToSourcePos(_key2.start), this.offsetToSourcePos(_key2.end)) + "]"
          });
        }
        return _superClass.prototype.parseClassProperty.call(this, node);
      };
      _proto.parseClassPrivateProperty = function parseClassPrivateProperty(node) {
        if (node["abstract"]) {
          this.raise(TSErrors.PrivateElementHasAbstract, node);
        }
        if (node.accessibility) {
          this.raise(TSErrors.PrivateElementHasAccessibility, node, {
            modifier: node.accessibility
          });
        }
        this.parseClassPropertyAnnotation(node);
        return _superClass.prototype.parseClassPrivateProperty.call(this, node);
      };
      _proto.parseClassAccessorProperty = function parseClassAccessorProperty(node) {
        this.parseClassPropertyAnnotation(node);
        if (node.optional) {
          this.raise(TSErrors.AccessorCannotBeOptional, node);
        }
        return _superClass.prototype.parseClassAccessorProperty.call(this, node);
      };
      _proto.pushClassMethod = function pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
        var typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
        if (typeParameters && isConstructor) {
          this.raise(TSErrors.ConstructorHasTypeParameters, typeParameters);
        }
        var _method$declare = method.declare,
          declare = _method$declare === void 0 ? false : _method$declare,
          kind = method.kind;
        if (declare && (kind === "get" || kind === "set")) {
          this.raise(TSErrors.DeclareAccessor, method, {
            kind: kind
          });
        }
        if (typeParameters) method.typeParameters = typeParameters;
        _superClass.prototype.pushClassMethod.call(this, classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
      };
      _proto.pushClassPrivateMethod = function pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
        var typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
        if (typeParameters) method.typeParameters = typeParameters;
        _superClass.prototype.pushClassPrivateMethod.call(this, classBody, method, isGenerator, isAsync);
      };
      _proto.declareClassPrivateMethodInScope = function declareClassPrivateMethodInScope(node, kind) {
        if (node.type === "TSDeclareMethod") return;
        if (node.type === "MethodDefinition" && !hasOwnProperty.call(node.value, "body")) {
          return;
        }
        _superClass.prototype.declareClassPrivateMethodInScope.call(this, node, kind);
      };
      _proto.parseClassSuper = function parseClassSuper(node) {
        _superClass.prototype.parseClassSuper.call(this, node);
        if (node.superClass && (this.match(47) || this.match(51))) {
          {
            node.superTypeParameters = this.tsParseTypeArgumentsInExpression();
          }
        }
        if (this.eatContextual(113)) {
          node["implements"] = this.tsParseHeritageClause("implements");
        }
      };
      _proto.parseObjPropValue = function parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
        var typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
        if (typeParameters) prop.typeParameters = typeParameters;
        return _superClass.prototype.parseObjPropValue.call(this, prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
      };
      _proto.parseFunctionParams = function parseFunctionParams(node, isConstructor) {
        var typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
        if (typeParameters) node.typeParameters = typeParameters;
        _superClass.prototype.parseFunctionParams.call(this, node, isConstructor);
      };
      _proto.parseVarId = function parseVarId(decl, kind) {
        _superClass.prototype.parseVarId.call(this, decl, kind);
        if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) {
          decl.definite = true;
        }
        var type = this.tsTryParseTypeAnnotation();
        if (type) {
          decl.id.typeAnnotation = type;
          this.resetEndLocation(decl.id);
        }
      };
      _proto.parseAsyncArrowFromCallExpression = function parseAsyncArrowFromCallExpression(node, call) {
        if (this.match(14)) {
          node.returnType = this.tsParseTypeAnnotation();
        }
        return _superClass.prototype.parseAsyncArrowFromCallExpression.call(this, node, call);
      };
      _proto.parseMaybeAssign = function parseMaybeAssign(refExpressionErrors, afterLeftParse) {
        var _this25 = this,
          _jsx,
          _jsx2,
          _typeCast,
          _jsx3,
          _typeCast2;
        var state;
        var jsx;
        var typeCast;
        if (this.hasPlugin("jsx") && (this.match(143) || this.match(47))) {
          state = this.state.clone();
          jsx = this.tryParse(function () {
            return _superClass.prototype.parseMaybeAssign.call(_this25, refExpressionErrors, afterLeftParse);
          }, state);
          if (!jsx.error) return jsx.node;
          var context = this.state.context;
          var currentContext = context[context.length - 1];
          if (currentContext === types.j_oTag || currentContext === types.j_expr) {
            context.pop();
          }
        }
        if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) {
          return _superClass.prototype.parseMaybeAssign.call(this, refExpressionErrors, afterLeftParse);
        }
        if (!state || state === this.state) state = this.state.clone();
        var typeParameters;
        var arrow = this.tryParse(function (abort) {
          var _expr$extra, _typeParameters;
          typeParameters = _this25.tsParseTypeParameters(_this25.tsParseConstModifier);
          var expr = _superClass.prototype.parseMaybeAssign.call(_this25, 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) {
            _this25.resetStartLocationFromNode(expr, typeParameters);
          }
          expr.typeParameters = typeParameters;
          return expr;
        }, state);
        if (!arrow.error && !arrow.aborted) {
          if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
          return arrow.node;
        }
        if (!jsx) {
          assert$1(!this.hasPlugin("jsx"));
          typeCast = this.tryParse(function () {
            return _superClass.prototype.parseMaybeAssign.call(_this25, refExpressionErrors, afterLeftParse);
          }, state);
          if (!typeCast.error) return typeCast.node;
        }
        if ((_jsx2 = jsx) != null && _jsx2.node) {
          this.state = jsx.failState;
          return jsx.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;
        }
        throw ((_jsx3 = jsx) == null ? void 0 : _jsx3.error) || arrow.error || ((_typeCast2 = typeCast) == null ? void 0 : _typeCast2.error);
      };
      _proto.reportReservedArrowTypeParam = function reportReservedArrowTypeParam(node) {
        var _node$extra;
        if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
          this.raise(TSErrors.ReservedArrowTypeParam, node);
        }
      };
      _proto.parseMaybeUnary = function parseMaybeUnary(refExpressionErrors, sawUnary) {
        if (!this.hasPlugin("jsx") && this.match(47)) {
          return this.tsParseTypeAssertion();
        }
        return _superClass.prototype.parseMaybeUnary.call(this, refExpressionErrors, sawUnary);
      };
      _proto.parseArrow = function parseArrow(node) {
        var _this26 = this;
        if (this.match(14)) {
          var result = this.tryParse(function (abort) {
            var returnType = _this26.tsParseTypeOrTypePredicateAnnotation(14);
            if (_this26.canInsertSemicolon() || !_this26.match(19)) abort();
            return returnType;
          });
          if (result.aborted) return;
          if (!result.thrown) {
            if (result.error) this.state = result.failState;
            node.returnType = result.node;
          }
        }
        return _superClass.prototype.parseArrow.call(this, node);
      };
      _proto.parseFunctionParamType = function parseFunctionParamType(param) {
        if (this.eat(17)) {
          param.optional = true;
        }
        var type = this.tsTryParseTypeAnnotation();
        if (type) param.typeAnnotation = type;
        this.resetEndLocation(param);
        return param;
      };
      _proto.isAssignable = function isAssignable(node, isBinding) {
        switch (node.type) {
          case "TSTypeCastExpression":
            return this.isAssignable(node.expression, isBinding);
          case "TSParameterProperty":
            return true;
          default:
            return _superClass.prototype.isAssignable.call(this, node, isBinding);
        }
      };
      _proto.toAssignable = function toAssignable(node, isLHS) {
        if (isLHS === void 0) {
          isLHS = false;
        }
        switch (node.type) {
          case "ParenthesizedExpression":
            this.toAssignableParenthesizedExpression(node, isLHS);
            break;
          case "TSAsExpression":
          case "TSSatisfiesExpression":
          case "TSNonNullExpression":
          case "TSTypeAssertion":
            if (isLHS) {
              this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, node);
            } else {
              this.raise(TSErrors.UnexpectedTypeCastInParameter, node);
            }
            this.toAssignable(node.expression, isLHS);
            break;
          case "AssignmentExpression":
            if (!isLHS && node.left.type === "TSTypeCastExpression") {
              node.left = this.typeCastToParameter(node.left);
            }
          default:
            _superClass.prototype.toAssignable.call(this, node, isLHS);
        }
      };
      _proto.toAssignableParenthesizedExpression = function toAssignableParenthesizedExpression(node, isLHS) {
        switch (node.expression.type) {
          case "TSAsExpression":
          case "TSSatisfiesExpression":
          case "TSNonNullExpression":
          case "TSTypeAssertion":
          case "ParenthesizedExpression":
            this.toAssignable(node.expression, isLHS);
            break;
          default:
            _superClass.prototype.toAssignable.call(this, node, isLHS);
        }
      };
      _proto.checkToRestConversion = function checkToRestConversion(node, allowPattern) {
        switch (node.type) {
          case "TSAsExpression":
          case "TSSatisfiesExpression":
          case "TSTypeAssertion":
          case "TSNonNullExpression":
            this.checkToRestConversion(node.expression, false);
            break;
          default:
            _superClass.prototype.checkToRestConversion.call(this, node, allowPattern);
        }
      };
      _proto.isValidLVal = function isValidLVal(type, isUnparenthesizedInAssign, binding) {
        switch (type) {
          case "TSTypeCastExpression":
            return true;
          case "TSParameterProperty":
            return "parameter";
          case "TSNonNullExpression":
          case "TSInstantiationExpression":
            return "expression";
          case "TSAsExpression":
          case "TSSatisfiesExpression":
          case "TSTypeAssertion":
            return (binding !== BindingFlag.TYPE_NONE || !isUnparenthesizedInAssign) && ["expression", true];
          default:
            return _superClass.prototype.isValidLVal.call(this, type, isUnparenthesizedInAssign, binding);
        }
      };
      _proto.parseBindingAtom = function parseBindingAtom() {
        if (this.state.type === 78) {
          return this.parseIdentifier(true);
        }
        return _superClass.prototype.parseBindingAtom.call(this);
      };
      _proto.parseMaybeDecoratorArguments = function parseMaybeDecoratorArguments(expr, startLoc) {
        if (this.match(47) || this.match(51)) {
          var typeArguments = this.tsParseTypeArgumentsInExpression();
          if (this.match(10)) {
            var call = _superClass.prototype.parseMaybeDecoratorArguments.call(this, expr, startLoc);
            {
              call.typeParameters = typeArguments;
            }
            return call;
          }
          this.unexpected(null, 10);
        }
        return _superClass.prototype.parseMaybeDecoratorArguments.call(this, expr, startLoc);
      };
      _proto.checkCommaAfterRest = function checkCommaAfterRest(close) {
        if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
          this.next();
          return false;
        }
        return _superClass.prototype.checkCommaAfterRest.call(this, close);
      };
      _proto.isClassMethod = function isClassMethod() {
        return this.match(47) || _superClass.prototype.isClassMethod.call(this);
      };
      _proto.isClassProperty = function isClassProperty() {
        return this.match(35) || this.match(14) || _superClass.prototype.isClassProperty.call(this);
      };
      _proto.parseMaybeDefault = function parseMaybeDefault(startLoc, left) {
        var node = _superClass.prototype.parseMaybeDefault.call(this, startLoc, left);
        if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
          this.raise(TSErrors.TypeAnnotationAfterAssign, node.typeAnnotation);
        }
        return node;
      };
      _proto.getTokenFromCode = function getTokenFromCode(code) {
        if (this.state.inType) {
          if (code === 62) {
            this.finishOp(48, 1);
            return;
          }
          if (code === 60) {
            this.finishOp(47, 1);
            return;
          }
        }
        _superClass.prototype.getTokenFromCode.call(this, code);
      };
      _proto.reScan_lt_gt = function reScan_lt_gt() {
        var type = this.state.type;
        if (type === 47) {
          this.state.pos -= 1;
          this.readToken_lt();
        } else if (type === 48) {
          this.state.pos -= 1;
          this.readToken_gt();
        }
      };
      _proto.reScan_lt = function reScan_lt() {
        var type = this.state.type;
        if (type === 51) {
          this.state.pos -= 2;
          this.finishOp(47, 1);
          return 47;
        }
        return type;
      };
      _proto.toAssignableList = function toAssignableList(exprList, trailingCommaLoc, isLHS) {
        for (var i = 0; i < exprList.length; i++) {
          var expr = exprList[i];
          if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") {
            exprList[i] = this.typeCastToParameter(expr);
          }
        }
        _superClass.prototype.toAssignableList.call(this, exprList, trailingCommaLoc, isLHS);
      };
      _proto.typeCastToParameter = function typeCastToParameter(node) {
        node.expression.typeAnnotation = node.typeAnnotation;
        this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
        return node.expression;
      };
      _proto.shouldParseArrow = function shouldParseArrow(params) {
        var _this27 = this;
        if (this.match(14)) {
          return params.every(function (expr) {
            return _this27.isAssignable(expr, true);
          });
        }
        return _superClass.prototype.shouldParseArrow.call(this, params);
      };
      _proto.shouldParseAsyncArrow = function shouldParseAsyncArrow() {
        return this.match(14) || _superClass.prototype.shouldParseAsyncArrow.call(this);
      };
      _proto.canHaveLeadingDecorator = function canHaveLeadingDecorator() {
        return _superClass.prototype.canHaveLeadingDecorator.call(this) || this.isAbstractClass();
      };
      _proto.jsxParseOpeningElementAfterName = function jsxParseOpeningElementAfterName(node) {
        var _this28 = this;
        if (this.match(47) || this.match(51)) {
          var typeArguments = this.tsTryParseAndCatch(function () {
            return _this28.tsParseTypeArgumentsInExpression();
          });
          if (typeArguments) {
            {
              node.typeParameters = typeArguments;
            }
          }
        }
        return _superClass.prototype.jsxParseOpeningElementAfterName.call(this, node);
      };
      _proto.getGetterSetterExpectedParamCount = function getGetterSetterExpectedParamCount(method) {
        var baseCount = _superClass.prototype.getGetterSetterExpectedParamCount.call(this, method);
        var params = this.getObjectOrClassMethodParams(method);
        var firstParam = params[0];
        var hasContextParam = firstParam && this.isThisParam(firstParam);
        return hasContextParam ? baseCount + 1 : baseCount;
      };
      _proto.parseCatchClauseParam = function parseCatchClauseParam() {
        var param = _superClass.prototype.parseCatchClauseParam.call(this);
        var type = this.tsTryParseTypeAnnotation();
        if (type) {
          param.typeAnnotation = type;
          this.resetEndLocation(param);
        }
        return param;
      };
      _proto.tsInAmbientContext = function tsInAmbientContext(cb) {
        var _this$state = this.state,
          oldIsAmbientContext = _this$state.isAmbientContext,
          oldStrict = _this$state.strict;
        this.state.isAmbientContext = true;
        this.state.strict = false;
        try {
          return cb();
        } finally {
          this.state.isAmbientContext = oldIsAmbientContext;
          this.state.strict = oldStrict;
        }
      };
      _proto.parseClass = function parseClass(node, isStatement, optionalId) {
        var oldInAbstractClass = this.state.inAbstractClass;
        this.state.inAbstractClass = !!node["abstract"];
        try {
          return _superClass.prototype.parseClass.call(this, node, isStatement, optionalId);
        } finally {
          this.state.inAbstractClass = oldInAbstractClass;
        }
      };
      _proto.tsParseAbstractDeclaration = function tsParseAbstractDeclaration(node, decorators) {
        if (this.match(80)) {
          node["abstract"] = true;
          return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));
        } else if (this.isContextual(129)) {
          if (!this.hasFollowingLineBreak()) {
            node["abstract"] = true;
            this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, node);
            return this.tsParseInterfaceDeclaration(node);
          }
        } else {
          this.unexpected(null, 80);
        }
      };
      _proto.parseMethod = function parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
        var method = _superClass.prototype.parseMethod.call(this, node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
        if (method["abstract"]) {
          var hasEstreePlugin = this.hasPlugin("estree");
          var methodFn = hasEstreePlugin ? method.value : method;
          if (methodFn.body) {
            var _key3 = method.key;
            this.raise(TSErrors.AbstractMethodHasImplementation, method, {
              methodName: _key3.type === "Identifier" && !method.computed ? _key3.name : "[" + this.input.slice(this.offsetToSourcePos(_key3.start), this.offsetToSourcePos(_key3.end)) + "]"
            });
          }
        }
        return method;
      };
      _proto.tsParseTypeParameterName = function tsParseTypeParameterName() {
        var typeName = this.parseIdentifier();
        return typeName.name;
      };
      _proto.shouldParseAsAmbientContext = function shouldParseAsAmbientContext() {
        return !!this.getPluginOption("typescript", "dts");
      };
      _proto.parse = function parse() {
        if (this.shouldParseAsAmbientContext()) {
          this.state.isAmbientContext = true;
        }
        return _superClass.prototype.parse.call(this);
      };
      _proto.getExpression = function getExpression() {
        if (this.shouldParseAsAmbientContext()) {
          this.state.isAmbientContext = true;
        }
        return _superClass.prototype.getExpression.call(this);
      };
      _proto.parseExportSpecifier = function parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
        if (!isString && isMaybeTypeOnly) {
          this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport);
          return this.finishNode(node, "ExportSpecifier");
        }
        node.exportKind = "value";
        return _superClass.prototype.parseExportSpecifier.call(this, node, isString, isInTypeExport, isMaybeTypeOnly);
      };
      _proto.parseImportSpecifier = function parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
        if (!importedIsString && isMaybeTypeOnly) {
          this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);
          return this.finishNode(specifier, "ImportSpecifier");
        }
        specifier.importKind = "value";
        return _superClass.prototype.parseImportSpecifier.call(this, specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? BindingFlag.TYPE_TS_TYPE_IMPORT : BindingFlag.TYPE_TS_VALUE_IMPORT);
      };
      _proto.parseTypeOnlyImportExportSpecifier = function parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) {
        var leftOfAsKey = isImport ? "imported" : "local";
        var rightOfAsKey = isImport ? "local" : "exported";
        var leftOfAs = node[leftOfAsKey];
        var rightOfAs;
        var hasTypeSpecifier = false;
        var canParseAsKeyword = true;
        var loc = leftOfAs.loc.start;
        if (this.isContextual(93)) {
          var firstAs = this.parseIdentifier();
          if (this.isContextual(93)) {
            var 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, loc);
        }
        node[leftOfAsKey] = leftOfAs;
        node[rightOfAsKey] = rightOfAs;
        var kindKey = isImport ? "importKind" : "exportKind";
        node[kindKey] = hasTypeSpecifier ? "type" : "value";
        if (canParseAsKeyword && this.eatContextual(93)) {
          node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName();
        }
        if (!node[rightOfAsKey]) {
          node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]);
        }
        if (isImport) {
          this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? BindingFlag.TYPE_TS_TYPE_IMPORT : BindingFlag.TYPE_TS_VALUE_IMPORT);
        }
      };
      return _createClass(TypeScriptParserMixin);
    }(superClass);
  });
  function isPossiblyLiteralEnum(expression) {
    if (expression.type !== "MemberExpression") return false;
    var computed = expression.computed,
      property = expression.property;
    if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) {
      return false;
    }
    return isUncomputedMemberExpressionChain(expression.object);
  }
  function isValidAmbientConstInitializer(expression, estree) {
    var _expression$extra;
    var type = expression.type;
    if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) {
      return false;
    }
    if (estree) {
      if (type === "Literal") {
        var value = expression.value;
        if (typeof value === "string" || typeof value === "boolean") {
          return true;
        }
      }
    } else {
      if (type === "StringLiteral" || type === "BooleanLiteral") {
        return true;
      }
    }
    if (isNumber$2(expression, estree) || isNegativeNumber(expression, estree)) {
      return true;
    }
    if (type === "TemplateLiteral" && expression.expressions.length === 0) {
      return true;
    }
    if (isPossiblyLiteralEnum(expression)) {
      return true;
    }
    return false;
  }
  function isNumber$2(expression, estree) {
    if (estree) {
      return expression.type === "Literal" && (typeof expression.value === "number" || "bigint" in expression);
    }
    return expression.type === "NumericLiteral" || expression.type === "BigIntLiteral";
  }
  function isNegativeNumber(expression, estree) {
    if (expression.type === "UnaryExpression") {
      var operator = expression.operator,
        argument = expression.argument;
      if (operator === "-" && isNumber$2(argument, estree)) {
        return true;
      }
    }
    return false;
  }
  function isUncomputedMemberExpressionChain(expression) {
    if (expression.type === "Identifier") return true;
    if (expression.type !== "MemberExpression" || expression.computed) {
      return false;
    }
    return isUncomputedMemberExpressionChain(expression.object);
  }

var _templateObject$G;
  var PlaceholderErrors = ParseErrorEnum(_templateObject$G || (_templateObject$G = _taggedTemplateLiteralLoose(["placeholders"])))({
    ClassNameIsRequired: "A class name is required.",
    UnexpectedSpace: "Unexpected space in placeholder."
  });
  var placeholders = (function (superClass) {
    return function (_superClass) {
      function PlaceholdersParserMixin() {
        return _superClass.apply(this, arguments) || this;
      }
      _inherits(PlaceholdersParserMixin, _superClass);
      var _proto = PlaceholdersParserMixin.prototype;
      _proto.parsePlaceholder = function parsePlaceholder(expectedNode) {
        if (this.match(133)) {
          var node = this.startNode();
          this.next();
          this.assertNoSpace();
          node.name = _superClass.prototype.parseIdentifier.call(this, true);
          this.assertNoSpace();
          this.expect(133);
          return this.finishPlaceholder(node, expectedNode);
        }
      };
      _proto.finishPlaceholder = function finishPlaceholder(node, expectedNode) {
        var placeholder = node;
        if (!placeholder.expectedNode || !placeholder.type) {
          placeholder = this.finishNode(placeholder, "Placeholder");
        }
        placeholder.expectedNode = expectedNode;
        return placeholder;
      };
      _proto.getTokenFromCode = function getTokenFromCode(code) {
        if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {
          this.finishOp(133, 2);
        } else {
          _superClass.prototype.getTokenFromCode.call(this, code);
        }
      };
      _proto.parseExprAtom = function parseExprAtom(refExpressionErrors) {
        return this.parsePlaceholder("Expression") || _superClass.prototype.parseExprAtom.call(this, refExpressionErrors);
      };
      _proto.parseIdentifier = function parseIdentifier(liberal) {
        return this.parsePlaceholder("Identifier") || _superClass.prototype.parseIdentifier.call(this, liberal);
      };
      _proto.checkReservedWord = function checkReservedWord(word, startLoc, checkKeywords, isBinding) {
        if (word !== undefined) {
          _superClass.prototype.checkReservedWord.call(this, word, startLoc, checkKeywords, isBinding);
        }
      };
      _proto.parseBindingAtom = function parseBindingAtom() {
        return this.parsePlaceholder("Pattern") || _superClass.prototype.parseBindingAtom.call(this);
      };
      _proto.isValidLVal = function isValidLVal(type, isParenthesized, binding) {
        return type === "Placeholder" || _superClass.prototype.isValidLVal.call(this, type, isParenthesized, binding);
      };
      _proto.toAssignable = function toAssignable(node, isLHS) {
        if (node && node.type === "Placeholder" && node.expectedNode === "Expression") {
          node.expectedNode = "Pattern";
        } else {
          _superClass.prototype.toAssignable.call(this, node, isLHS);
        }
      };
      _proto.chStartsBindingIdentifier = function chStartsBindingIdentifier(ch, pos) {
        if (_superClass.prototype.chStartsBindingIdentifier.call(this, ch, pos)) {
          return true;
        }
        var nextToken = this.lookahead();
        if (nextToken.type === 133) {
          return true;
        }
        return false;
      };
      _proto.verifyBreakContinue = function verifyBreakContinue(node, isBreak) {
        if (node.label && node.label.type === "Placeholder") return;
        _superClass.prototype.verifyBreakContinue.call(this, node, isBreak);
      };
      _proto.parseExpressionStatement = function parseExpressionStatement(node, expr) {
        var _expr$extra;
        if (expr.type !== "Placeholder" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {
          return _superClass.prototype.parseExpressionStatement.call(this, node, expr);
        }
        if (this.match(14)) {
          var stmt = node;
          stmt.label = this.finishPlaceholder(expr, "Identifier");
          this.next();
          stmt.body = _superClass.prototype.parseStatementOrSloppyAnnexBFunctionDeclaration.call(this);
          return this.finishNode(stmt, "LabeledStatement");
        }
        this.semicolon();
        var stmtPlaceholder = node;
        stmtPlaceholder.name = expr.name;
        return this.finishPlaceholder(stmtPlaceholder, "Statement");
      };
      _proto.parseBlock = function parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {
        return this.parsePlaceholder("BlockStatement") || _superClass.prototype.parseBlock.call(this, allowDirectives, createNewLexicalScope, afterBlockParse);
      };
      _proto.parseFunctionId = function parseFunctionId(requireId) {
        return this.parsePlaceholder("Identifier") || _superClass.prototype.parseFunctionId.call(this, requireId);
      };
      _proto.parseClass = function parseClass(node, isStatement, optionalId) {
        var type = isStatement ? "ClassDeclaration" : "ClassExpression";
        this.next();
        var oldStrict = this.state.strict;
        var placeholder = this.parsePlaceholder("Identifier");
        if (placeholder) {
          if (this.match(81) || this.match(133) || this.match(5)) {
            node.id = placeholder;
          } else if (optionalId || !isStatement) {
            node.id = null;
            node.body = this.finishPlaceholder(placeholder, "ClassBody");
            return this.finishNode(node, type);
          } else {
            throw this.raise(PlaceholderErrors.ClassNameIsRequired, this.state.startLoc);
          }
        } else {
          this.parseClassId(node, isStatement, optionalId);
        }
        _superClass.prototype.parseClassSuper.call(this, node);
        node.body = this.parsePlaceholder("ClassBody") || _superClass.prototype.parseClassBody.call(this, !!node.superClass, oldStrict);
        return this.finishNode(node, type);
      };
      _proto.parseExport = function parseExport(node, decorators) {
        var placeholder = this.parsePlaceholder("Identifier");
        if (!placeholder) return _superClass.prototype.parseExport.call(this, node, decorators);
        var node2 = node;
        if (!this.isContextual(98) && !this.match(12)) {
          node2.specifiers = [];
          node2.source = null;
          node2.declaration = this.finishPlaceholder(placeholder, "Declaration");
          return this.finishNode(node2, "ExportNamedDeclaration");
        }
        this.expectPlugin("exportDefaultFrom");
        var specifier = this.startNode();
        specifier.exported = placeholder;
        node2.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
        return _superClass.prototype.parseExport.call(this, node2, decorators);
      };
      _proto.isExportDefaultSpecifier = function isExportDefaultSpecifier() {
        if (this.match(65)) {
          var next = this.nextTokenStart();
          if (this.isUnparsedContextual(next, "from")) {
            if (this.input.startsWith(tokenLabelName(133), this.nextTokenStartSince(next + 4))) {
              return true;
            }
          }
        }
        return _superClass.prototype.isExportDefaultSpecifier.call(this);
      };
      _proto.maybeParseExportDefaultSpecifier = function maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
        var _specifiers;
        if ((_specifiers = node.specifiers) != null && _specifiers.length) {
          return true;
        }
        return _superClass.prototype.maybeParseExportDefaultSpecifier.call(this, node, maybeDefaultIdentifier);
      };
      _proto.checkExport = function checkExport(node) {
        var specifiers = node.specifiers;
        if (specifiers != null && specifiers.length) {
          node.specifiers = specifiers.filter(function (node) {
            return node.exported.type === "Placeholder";
          });
        }
        _superClass.prototype.checkExport.call(this, node);
        node.specifiers = specifiers;
      };
      _proto.parseImport = function parseImport(node) {
        var placeholder = this.parsePlaceholder("Identifier");
        if (!placeholder) return _superClass.prototype.parseImport.call(this, node);
        node.specifiers = [];
        if (!this.isContextual(98) && !this.match(12)) {
          node.source = this.finishPlaceholder(placeholder, "StringLiteral");
          this.semicolon();
          return this.finishNode(node, "ImportDeclaration");
        }
        var specifier = this.startNodeAtNode(placeholder);
        specifier.local = placeholder;
        node.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier"));
        if (this.eat(12)) {
          var hasStarImport = this.maybeParseStarImportSpecifier(node);
          if (!hasStarImport) this.parseNamedImportSpecifiers(node);
        }
        this.expectContextual(98);
        node.source = this.parseImportSource();
        this.semicolon();
        return this.finishNode(node, "ImportDeclaration");
      };
      _proto.parseImportSource = function parseImportSource() {
        return this.parsePlaceholder("StringLiteral") || _superClass.prototype.parseImportSource.call(this);
      };
      _proto.assertNoSpace = function assertNoSpace() {
        if (this.state.start > this.offsetToSourcePos(this.state.lastTokEndLoc.index)) {
          this.raise(PlaceholderErrors.UnexpectedSpace, this.state.lastTokEndLoc);
        }
      };
      return _createClass(PlaceholdersParserMixin);
    }(superClass);
  });

var index$4 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    parse: parse$4,
    parseExpression: parseExpression,
    tokTypes: tokTypes
  });

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

var picocolors_browser = {exports: {}};

var x = String;
  var create = function create() {
    return {
      isColorSupported: false,
      reset: x,
      bold: x,
      dim: x,
      italic: x,
      underline: x,
      inverse: x,
      hidden: x,
      strikethrough: x,
      black: x,
      red: x,
      green: x,
      yellow: x,
      blue: x,
      magenta: x,
      cyan: x,
      white: x,
      gray: x,
      bgBlack: x,
      bgRed: x,
      bgGreen: x,
      bgYellow: x,
      bgBlue: x,
      bgMagenta: x,
      bgCyan: x,
      bgWhite: x
    };
  };
  picocolors_browser.exports = create();
  var createColors = picocolors_browser.exports.createColors = create;
  var picocolors_browserExports = picocolors_browser.exports;

var jsTokensBABEL_8_BREAKINGFalse = {};

var hasRequiredJsTokensBABEL_8_BREAKINGFalse;
  function requireJsTokensBABEL_8_BREAKINGFalse() {
    if (hasRequiredJsTokensBABEL_8_BREAKINGFalse) return jsTokensBABEL_8_BREAKINGFalse;
    hasRequiredJsTokensBABEL_8_BREAKINGFalse = 1;
    Object.defineProperty(jsTokensBABEL_8_BREAKINGFalse, "__esModule", {
      value: true
    });
    jsTokensBABEL_8_BREAKINGFalse["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;
    jsTokensBABEL_8_BREAKINGFalse.matchToToken = function (match) {
      var token = {
        type: "invalid",
        value: match[0],
        closed: undefined
      };
      if (match[1]) token.type = "string", token.closed = !!(match[3] || match[4]);else if (match[5]) token.type = "comment";else if (match[6]) token.type = "comment", token.closed = !!match[7];else if (match[8]) token.type = "regex";else if (match[9]) token.type = "number";else if (match[10]) token.type = "name";else if (match[11]) token.type = "punctuator";else if (match[12]) token.type = "whitespace";
      return token;
    };
    return jsTokensBABEL_8_BREAKINGFalse;
  }

function bool$9(value) {
    if (value == null) return false;
    return value && value !== "false" && value !== "0";
  }
  var jsTokens = bool$9(browser$1$1.env["BABEL_8_BREAKING"]) ? requireJsTokensBABEL_8_BREAKINGFalse() : requireJsTokensBABEL_8_BREAKINGFalse();

function stringTemplate(formatter, code, opts) {
    code = formatter.code(code);
    var metadata;
    return function (arg) {
      var replacements = normalizeReplacements(arg);
      if (!metadata) metadata = parseAndBuildMetadata(formatter, code, opts);
      return formatter.unwrap(populatePlaceholders(metadata, replacements));
    };
  }

var smart = createTemplateBuilder(smart$1);
  var statement = createTemplateBuilder(statement$1);
  var statements = createTemplateBuilder(statements$1);
  var expression = createTemplateBuilder(expression$1);
  var program$1 = createTemplateBuilder(program$2);
  var template$1 = Object.assign(smart.bind(undefined), {
    smart: smart,
    statement: statement,
    statements: statements,
    expression: expression,
    program: program$1,
    ast: smart.ast
  });

var index$3 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    default: template$1,
    expression: expression,
    program: program$1,
    smart: smart,
    statement: statement,
    statements: statements
  });

var ReferencedIdentifier$1 = ["Identifier", "JSXIdentifier"];
  var ReferencedMemberExpression = ["MemberExpression"];
  var BindingIdentifier = ["Identifier"];
  var Statement = ["Statement"];
  var Expression = ["Expression"];
  var Scope$1 = ["Scopable", "Pattern"];
  var Referenced = null;
  var BlockScoped = null;
  var Var = ["VariableDeclaration"];
  var User = null;
  var Generated = null;
  var Pure = null;
  var Flow = ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"];
  var RestProperty = ["RestElement"];
  var SpreadProperty = ["RestElement"];
  var ExistentialTypeParam = ["ExistsTypeAnnotation"];
  var NumericLiteralTypeAnnotation = ["NumberLiteralTypeAnnotation"];
  var ForAwaitStatement = ["ForOfStatement"];

var virtualTypes = /*#__PURE__*/Object.freeze({
    __proto__: null,
    BindingIdentifier: BindingIdentifier,
    BlockScoped: BlockScoped,
    ExistentialTypeParam: ExistentialTypeParam,
    Expression: Expression,
    Flow: Flow,
    ForAwaitStatement: ForAwaitStatement,
    Generated: Generated,
    NumericLiteralTypeAnnotation: NumericLiteralTypeAnnotation,
    Pure: Pure,
    Referenced: Referenced,
    ReferencedIdentifier: ReferencedIdentifier$1,
    ReferencedMemberExpression: ReferencedMemberExpression,
    RestProperty: RestProperty,
    Scope: Scope$1,
    SpreadProperty: SpreadProperty,
    Statement: Statement,
    User: User,
    Var: Var
  });

var browser$2 = {exports: {}};

var ms;
  var hasRequiredMs;
  function requireMs() {
    if (hasRequiredMs) return ms;
    hasRequiredMs = 1;
    var s = 1000;
    var m = s * 60;
    var h = m * 60;
    var d = h * 24;
    var w = d * 7;
    var y = d * 365.25;
    ms = function ms(val, options) {
      options = options || {};
      var type = typeof val;
      if (type === 'string' && val.length > 0) {
        return parse(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 parse(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 undefined;
      }
    }
    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, name) {
      var isPlural = msAbs >= n * 1.5;
      return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
    }
    return ms;
  }

var NodePath_virtual_types_validator = /*#__PURE__*/Object.freeze({
    __proto__: null,
    isBindingIdentifier: isBindingIdentifier,
    isBlockScoped: isBlockScoped$1,
    isExpression: isExpression$4,
    isFlow: isFlow,
    isForAwaitStatement: isForAwaitStatement,
    isGenerated: isGenerated,
    isPure: isPure,
    isReferenced: isReferenced$1,
    isReferencedIdentifier: isReferencedIdentifier,
    isReferencedMemberExpression: isReferencedMemberExpression,
    isRestProperty: isRestProperty,
    isScope: isScope,
    isSpreadProperty: isSpreadProperty,
    isStatement: isStatement$6,
    isUser: isUser,
    isVar: isVar
  });

var visitors$2 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    environmentVisitor: environmentVisitor,
    explode: explode$1,
    isExplodedVisitor: isExplodedVisitor,
    merge: merge,
    verify: verify$1
  });

var globalsBABEL_8_BREAKINGFalse;
  var hasRequiredGlobalsBABEL_8_BREAKINGFalse;
  function requireGlobalsBABEL_8_BREAKINGFalse() {
    if (hasRequiredGlobalsBABEL_8_BREAKINGFalse) return globalsBABEL_8_BREAKINGFalse;
    hasRequiredGlobalsBABEL_8_BREAKINGFalse = 1;
    globalsBABEL_8_BREAKINGFalse = require$$0$b;
    return globalsBABEL_8_BREAKINGFalse;
  }

function bool$8(value) {
    if (value == null) return false;
    return value && value !== "false" && value !== "0";
  }
  var globals$1 = bool$8(browser$1$1.env["BABEL_8_BREAKING"]) ? requireGlobalsBABEL_8_BREAKINGFalse() : requireGlobalsBABEL_8_BREAKINGFalse();

var genMapping_umd$1 = {exports: {}};

var setArray_umd = {exports: {}};

var hasRequiredSetArray_umd;
  function requireSetArray_umd() {
    if (hasRequiredSetArray_umd) return setArray_umd.exports;
    hasRequiredSetArray_umd = 1;
    (function (module, exports) {
      (function (global, factory) {
        factory(exports) ;
      })(commonjsGlobal, function (exports) {
        var SetArray = _createClass(function SetArray() {
          this._indexes = {
            __proto__: null
          };
          this.array = [];
        });
        function cast(set) {
          return set;
        }
        function get(setarr, key) {
          return cast(setarr)._indexes[key];
        }
        function put(setarr, key) {
          var index = get(setarr, key);
          if (index !== undefined) return index;
          var _cast = cast(setarr),
            array = _cast.array,
            indexes = _cast._indexes;
          var length = array.push(key);
          return indexes[key] = length - 1;
        }
        function pop(setarr) {
          var _cast2 = cast(setarr),
            array = _cast2.array,
            indexes = _cast2._indexes;
          if (array.length === 0) return;
          var last = array.pop();
          indexes[last] = undefined;
        }
        function remove(setarr, key) {
          var index = get(setarr, key);
          if (index === undefined) return;
          var _cast3 = cast(setarr),
            array = _cast3.array,
            indexes = _cast3._indexes;
          for (var i = index + 1; i < array.length; i++) {
            var k = array[i];
            array[i - 1] = k;
            indexes[k]--;
          }
          indexes[key] = undefined;
          array.pop();
        }
        exports.SetArray = SetArray;
        exports.get = get;
        exports.pop = pop;
        exports.put = put;
        exports.remove = remove;
        Object.defineProperty(exports, '__esModule', {
          value: true
        });
      });
    })(setArray_umd, setArray_umd.exports);
    return setArray_umd.exports;
  }

var lookup = [];
  var revLookup = [];
  var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
  var inited = false;
  function init () {
    inited = true;
    var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    for (var i = 0, len = code.length; i < len; ++i) {
      lookup[i] = code[i];
      revLookup[code.charCodeAt(i)] = i;
    }

revLookup['-'.charCodeAt(0)] = 62;
    revLookup['_'.charCodeAt(0)] = 63;
  }

function toByteArray (b64) {
    if (!inited) {
      init();
    }
    var i, j, l, tmp, placeHolders, arr;
    var len = b64.length;

if (len % 4 > 0) {
      throw new Error('Invalid string. Length must be a multiple of 4')
    }

// the number of equal signs (place holders)
    // if there are two placeholders, than the two characters before it
    // represent one byte
    // if there is only one, then the three characters before it represent 2 bytes
    // this is just a cheap hack to not do indexOf twice
    placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0;

// base64 is 4/3 + up to two characters of the original data
    arr = new Arr(len * 3 / 4 - placeHolders);

// if there are placeholders, only get up to the last complete 4 chars
    l = placeHolders > 0 ? len - 4 : len;

var L = 0;

for (i = 0, j = 0; i < l; i += 4, j += 3) {
      tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)];
      arr[L++] = (tmp >> 16) & 0xFF;
      arr[L++] = (tmp >> 8) & 0xFF;
      arr[L++] = tmp & 0xFF;
    }

if (placeHolders === 2) {
      tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4);
      arr[L++] = tmp & 0xFF;
    } else if (placeHolders === 1) {
      tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2);
      arr[L++] = (tmp >> 8) & 0xFF;
      arr[L++] = tmp & 0xFF;
    }

return arr
  }

function tripletToBase64 (num) {
    return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
  }

function encodeChunk (uint8, start, end) {
    var tmp;
    var output = [];
    for (var i = start; i < end; i += 3) {
      tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]);
      output.push(tripletToBase64(tmp));
    }
    return output.join('')
  }

function fromByteArray (uint8) {
    if (!inited) {
      init();
    }
    var tmp;
    var len = uint8.length;
    var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
    var output = '';
    var parts = [];
    var maxChunkLength = 16383; // must be multiple of 3

// go through the array every three bytes, we'll deal with trailing stuff later
    for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
      parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)));
    }

// pad the end with zeros, but make sure to not forget the extra bytes
    if (extraBytes === 1) {
      tmp = uint8[len - 1];
      output += lookup[tmp >> 2];
      output += lookup[(tmp << 4) & 0x3F];
      output += '==';
    } else if (extraBytes === 2) {
      tmp = (uint8[len - 2] << 8) + (uint8[len - 1]);
      output += lookup[tmp >> 10];
      output += lookup[(tmp >> 4) & 0x3F];
      output += lookup[(tmp << 2) & 0x3F];
      output += '=';
    }

parts.push(output);

return parts.join('')
  }

function read (buffer, offset, isLE, mLen, nBytes) {
    var e, m;
    var eLen = nBytes * 8 - mLen - 1;
    var eMax = (1 << eLen) - 1;
    var eBias = eMax >> 1;
    var nBits = -7;
    var i = isLE ? (nBytes - 1) : 0;
    var d = isLE ? -1 : 1;
    var s = buffer[offset + i];

i += d;

e = s & ((1 << (-nBits)) - 1);
    s >>= (-nBits);
    nBits += eLen;
    for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}

m = e & ((1 << (-nBits)) - 1);
    e >>= (-nBits);
    nBits += mLen;
    for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}

if (e === 0) {
      e = 1 - eBias;
    } else if (e === eMax) {
      return m ? NaN : ((s ? -1 : 1) * Infinity)
    } else {
      m = m + Math.pow(2, mLen);
      e = e - eBias;
    }
    return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
  }

function write (buffer, value, offset, isLE, mLen, nBytes) {
    var e, m, c;
    var eLen = nBytes * 8 - mLen - 1;
    var eMax = (1 << eLen) - 1;
    var eBias = eMax >> 1;
    var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);
    var i = isLE ? 0 : (nBytes - 1);
    var d = isLE ? 1 : -1;
    var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;

value = Math.abs(value);

if (isNaN(value) || value === Infinity) {
      m = isNaN(value) ? 1 : 0;
      e = eMax;
    } else {
      e = Math.floor(Math.log(value) / Math.LN2);
      if (value * (c = Math.pow(2, -e)) < 1) {
        e--;
        c *= 2;
      }
      if (e + eBias >= 1) {
        value += rt / c;
      } else {
        value += rt * Math.pow(2, 1 - eBias);
      }
      if (value * c >= 2) {
        e++;
        c /= 2;
      }

if (e + eBias >= eMax) {
        m = 0;
        e = eMax;
      } else if (e + eBias >= 1) {
        m = (value * c - 1) * Math.pow(2, mLen);
        e = e + eBias;
      } else {
        m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
        e = 0;
      }
    }

for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

e = (e << mLen) | m;
    eLen += mLen;
    for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

buffer[offset + i - d] |= s * 128;
  }

var toString$1 = {}.toString;

var isArray$3 = Array.isArray || function (arr) {
    return toString$1.call(arr) == '[object Array]';
  };

/*!
   * The buffer module from node.js, for the browser.
   *
   * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
   * @license  MIT
   */
  /* eslint-disable no-proto */

var INSPECT_MAX_BYTES = 50;

/**
   * If `Buffer.TYPED_ARRAY_SUPPORT`:
   *   === true    Use Uint8Array implementation (fastest)
   *   === false   Use Object implementation (most compatible, even IE6)
   *
   * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
   * Opera 11.6+, iOS 4.2+.
   *
   * Due to various browser bugs, sometimes the Object implementation will be used even
   * when the browser supports typed arrays.
   *
   * Note:
   *
   *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
   *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
   *
   *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
   *
   *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
   *     incorrect length in some situations.

* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
   * get the Object implementation, which is slower but behaves correctly.
   */
  Buffer$1.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined
    ? global$1.TYPED_ARRAY_SUPPORT
    : true;

/*
   * Export kMaxLength after typed array support is determined.
   */
  kMaxLength();

function kMaxLength () {
    return Buffer$1.TYPED_ARRAY_SUPPORT
      ? 0x7fffffff
      : 0x3fffffff
  }

return that
  }

/**
   * The Buffer constructor returns instances of `Uint8Array` that have their
   * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
   * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
   * and the `Uint8Array` methods. Square bracket notation works as expected -- it
   * returns a single octet.
   *
   * The `Uint8Array` prototype remains unmodified.
   */

function Buffer$1 (arg, encodingOrOffset, length) {
    if (!Buffer$1.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer$1)) {
      return new Buffer$1(arg, encodingOrOffset, length)
    }

// Common case.
    if (typeof arg === 'number') {
      if (typeof encodingOrOffset === 'string') {
        throw new Error(
          'If encoding is specified then the first argument must be a string'
        )
      }
      return allocUnsafe(this, arg)
    }
    return from(this, arg, encodingOrOffset, length)
  }

Buffer$1.poolSize = 8192; // not used by this implementation

// TODO: Legacy, not needed anymore. Remove in next major version.
  Buffer$1._augment = function (arr) {
    arr.__proto__ = Buffer$1.prototype;
    return arr
  };

function from (that, value, encodingOrOffset, length) {
    if (typeof value === 'number') {
      throw new TypeError('"value" argument must not be a number')
    }

if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
      return fromArrayBuffer(that, value, encodingOrOffset, length)
    }

if (typeof value === 'string') {
      return fromString(that, value, encodingOrOffset)
    }

return fromObject(that, value)
  }

/**
   * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
   * if value is a number.
   * Buffer.from(str[, encoding])
   * Buffer.from(array)
   * Buffer.from(buffer)
   * Buffer.from(arrayBuffer[, byteOffset[, length]])
   **/
  Buffer$1.from = function (value, encodingOrOffset, length) {
    return from(null, value, encodingOrOffset, length)
  };

if (Buffer$1.TYPED_ARRAY_SUPPORT) {
    Buffer$1.prototype.__proto__ = Uint8Array.prototype;
    Buffer$1.__proto__ = Uint8Array;
    if (typeof Symbol !== 'undefined' && Symbol.species &&
        Buffer$1[Symbol.species] === Buffer$1) ;
  }

function assertSize (size) {
    if (typeof size !== 'number') {
      throw new TypeError('"size" argument must be a number')
    } else if (size < 0) {
      throw new RangeError('"size" argument must not be negative')
    }
  }

function alloc (that, size, fill, encoding) {
    assertSize(size);
    if (size <= 0) {
      return createBuffer(that, size)
    }
    if (fill !== undefined) {
      // Only pay attention to encoding if it's a string. This
      // prevents accidentally sending in a number that would
      // be interpretted as a start offset.
      return typeof encoding === 'string'
        ? createBuffer(that, size).fill(fill, encoding)
        : createBuffer(that, size).fill(fill)
    }
    return createBuffer(that, size)
  }

/**
   * Creates a new filled Buffer instance.
   * alloc(size[, fill[, encoding]])
   **/
  Buffer$1.alloc = function (size, fill, encoding) {
    return alloc(null, size, fill, encoding)
  };

/**
   * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
   * */
  Buffer$1.allocUnsafe = function (size) {
    return allocUnsafe(null, size)
  };
  /**
   * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
   */
  Buffer$1.allocUnsafeSlow = function (size) {
    return allocUnsafe(null, size)
  };

function fromString (that, string, encoding) {
    if (typeof encoding !== 'string' || encoding === '') {
      encoding = 'utf8';
    }

if (!Buffer$1.isEncoding(encoding)) {
      throw new TypeError('"encoding" must be a valid string encoding')
    }

var length = byteLength(string, encoding) | 0;
    that = createBuffer(that, length);

var actual = that.write(string, encoding);

if (actual !== length) {
      // Writing a hex string, for example, that contains invalid characters will
      // cause everything after the first invalid character to be ignored. (e.g.
      // 'abxxcd' will be treated as 'ab')
      that = that.slice(0, actual);
    }

return that
  }

function fromArrayLike (that, array) {
    var length = array.length < 0 ? 0 : checked(array.length) | 0;
    that = createBuffer(that, length);
    for (var i = 0; i < length; i += 1) {
      that[i] = array[i] & 255;
    }
    return that
  }

function fromArrayBuffer (that, array, byteOffset, length) {
    array.byteLength; // this throws if `array` is not a valid ArrayBuffer

if (byteOffset < 0 || array.byteLength < byteOffset) {
      throw new RangeError('\'offset\' is out of bounds')
    }

if (array.byteLength < byteOffset + (length || 0)) {
      throw new RangeError('\'length\' is out of bounds')
    }

if (byteOffset === undefined && length === undefined) {
      array = new Uint8Array(array);
    } else if (length === undefined) {
      array = new Uint8Array(array, byteOffset);
    } else {
      array = new Uint8Array(array, byteOffset, length);
    }

if (Buffer$1.TYPED_ARRAY_SUPPORT) {
      // Return an augmented `Uint8Array` instance, for best performance
      that = array;
      that.__proto__ = Buffer$1.prototype;
    } else {
      // Fallback: Return an object instance of the Buffer class
      that = fromArrayLike(that, array);
    }
    return that
  }

function fromObject (that, obj) {
    if (internalIsBuffer(obj)) {
      var len = checked(obj.length) | 0;
      that = createBuffer(that, len);

if (that.length === 0) {
        return that
      }

obj.copy(that, 0, 0, len);
      return that
    }

if (obj) {
      if ((typeof ArrayBuffer !== 'undefined' &&
          obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
        if (typeof obj.length !== 'number' || isnan(obj.length)) {
          return createBuffer(that, 0)
        }
        return fromArrayLike(that, obj)
      }

if (obj.type === 'Buffer' && isArray$3(obj.data)) {
        return fromArrayLike(that, obj.data)
      }
    }

throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
  }

function checked (length) {
    // Note: cannot use `length < kMaxLength()` here because that fails when
    // length is NaN (which is otherwise coerced to zero.)
    if (length >= kMaxLength()) {
      throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                           'size: 0x' + kMaxLength().toString(16) + ' bytes')
    }
    return length | 0
  }
  Buffer$1.isBuffer = isBuffer$2;
  function internalIsBuffer (b) {
    return !!(b != null && b._isBuffer)
  }

Buffer$1.compare = function compare (a, b) {
    if (!internalIsBuffer(a) || !internalIsBuffer(b)) {
      throw new TypeError('Arguments must be Buffers')
    }

if (a === b) return 0

var x = a.length;
    var y = b.length;

for (var i = 0, len = Math.min(x, y); i < len; ++i) {
      if (a[i] !== b[i]) {
        x = a[i];
        y = b[i];
        break
      }
    }

if (x < y) return -1
    if (y < x) return 1
    return 0
  };

Buffer$1.isEncoding = function isEncoding (encoding) {
    switch (String(encoding).toLowerCase()) {
      case 'hex':
      case 'utf8':
      case 'utf-8':
      case 'ascii':
      case 'latin1':
      case 'binary':
      case 'base64':
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return true
      default:
        return false
    }
  };

Buffer$1.concat = function concat (list, length) {
    if (!isArray$3(list)) {
      throw new TypeError('"list" argument must be an Array of Buffers')
    }

if (list.length === 0) {
      return Buffer$1.alloc(0)
    }

var i;
    if (length === undefined) {
      length = 0;
      for (i = 0; i < list.length; ++i) {
        length += list[i].length;
      }
    }

var buffer = Buffer$1.allocUnsafe(length);
    var pos = 0;
    for (i = 0; i < list.length; ++i) {
      var buf = list[i];
      if (!internalIsBuffer(buf)) {
        throw new TypeError('"list" argument must be an Array of Buffers')
      }
      buf.copy(buffer, pos);
      pos += buf.length;
    }
    return buffer
  };

function byteLength (string, encoding) {
    if (internalIsBuffer(string)) {
      return string.length
    }
    if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
        (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
      return string.byteLength
    }
    if (typeof string !== 'string') {
      string = '' + string;
    }

var len = string.length;
    if (len === 0) return 0

// Use a for loop to avoid recursion
    var loweredCase = false;
    for (;;) {
      switch (encoding) {
        case 'ascii':
        case 'latin1':
        case 'binary':
          return len
        case 'utf8':
        case 'utf-8':
        case undefined:
          return utf8ToBytes(string).length
        case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return len * 2
        case 'hex':
          return len >>> 1
        case 'base64':
          return base64ToBytes(string).length
        default:
          if (loweredCase) return utf8ToBytes(string).length // assume utf8
          encoding = ('' + encoding).toLowerCase();
          loweredCase = true;
      }
    }
  }
  Buffer$1.byteLength = byteLength;

function slowToString (encoding, start, end) {
    var loweredCase = false;

// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
    // property of a typed array.

// This behaves neither like String nor Uint8Array in that we set start/end
    // to their upper/lower bounds if the value passed is out of range.
    // undefined is handled specially as per ECMA-262 6th Edition,
    // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
    if (start === undefined || start < 0) {
      start = 0;
    }
    // Return early if start > this.length. Done here to prevent potential uint32
    // coercion fail below.
    if (start > this.length) {
      return ''
    }

if (end === undefined || end > this.length) {
      end = this.length;
    }

if (end <= 0) {
      return ''
    }

// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
    end >>>= 0;
    start >>>= 0;

if (end <= start) {
      return ''
    }

if (!encoding) encoding = 'utf8';

while (true) {
      switch (encoding) {
        case 'hex':
          return hexSlice(this, start, end)

case 'utf8':
        case 'utf-8':
          return utf8Slice(this, start, end)

case 'ascii':
          return asciiSlice(this, start, end)

case 'latin1':
        case 'binary':
          return latin1Slice(this, start, end)

case 'base64':
          return base64Slice(this, start, end)

case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return utf16leSlice(this, start, end)

default:
          if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
          encoding = (encoding + '').toLowerCase();
          loweredCase = true;
      }
    }
  }

// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
  // Buffer instances.
  Buffer$1.prototype._isBuffer = true;

function swap (b, n, m) {
    var i = b[n];
    b[n] = b[m];
    b[m] = i;
  }

Buffer$1.prototype.swap16 = function swap16 () {
    var len = this.length;
    if (len % 2 !== 0) {
      throw new RangeError('Buffer size must be a multiple of 16-bits')
    }
    for (var i = 0; i < len; i += 2) {
      swap(this, i, i + 1);
    }
    return this
  };

Buffer$1.prototype.swap32 = function swap32 () {
    var len = this.length;
    if (len % 4 !== 0) {
      throw new RangeError('Buffer size must be a multiple of 32-bits')
    }
    for (var i = 0; i < len; i += 4) {
      swap(this, i, i + 3);
      swap(this, i + 1, i + 2);
    }
    return this
  };

Buffer$1.prototype.swap64 = function swap64 () {
    var len = this.length;
    if (len % 8 !== 0) {
      throw new RangeError('Buffer size must be a multiple of 64-bits')
    }
    for (var i = 0; i < len; i += 8) {
      swap(this, i, i + 7);
      swap(this, i + 1, i + 6);
      swap(this, i + 2, i + 5);
      swap(this, i + 3, i + 4);
    }
    return this
  };

Buffer$1.prototype.toString = function toString () {
    var length = this.length | 0;
    if (length === 0) return ''
    if (arguments.length === 0) return utf8Slice(this, 0, length)
    return slowToString.apply(this, arguments)
  };

Buffer$1.prototype.equals = function equals (b) {
    if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer')
    if (this === b) return true
    return Buffer$1.compare(this, b) === 0
  };

Buffer$1.prototype.inspect = function inspect () {
    var str = '';
    var max = INSPECT_MAX_BYTES;
    if (this.length > 0) {
      str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');
      if (this.length > max) str += ' ... ';
    }
    return '<Buffer ' + str + '>'
  };

Buffer$1.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
    if (!internalIsBuffer(target)) {
      throw new TypeError('Argument must be a Buffer')
    }

if (start === undefined) {
      start = 0;
    }
    if (end === undefined) {
      end = target ? target.length : 0;
    }
    if (thisStart === undefined) {
      thisStart = 0;
    }
    if (thisEnd === undefined) {
      thisEnd = this.length;
    }

if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
      throw new RangeError('out of range index')
    }

if (thisStart >= thisEnd && start >= end) {
      return 0
    }
    if (thisStart >= thisEnd) {
      return -1
    }
    if (start >= end) {
      return 1
    }

start >>>= 0;
    end >>>= 0;
    thisStart >>>= 0;
    thisEnd >>>= 0;

if (this === target) return 0

var x = thisEnd - thisStart;
    var y = end - start;
    var len = Math.min(x, y);

var thisCopy = this.slice(thisStart, thisEnd);
    var targetCopy = target.slice(start, end);

for (var i = 0; i < len; ++i) {
      if (thisCopy[i] !== targetCopy[i]) {
        x = thisCopy[i];
        y = targetCopy[i];
        break
      }
    }

if (x < y) return -1
    if (y < x) return 1
    return 0
  };

// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
  // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
  //
  // Arguments:
  // - buffer - a Buffer to search
  // - val - a string, Buffer, or number
  // - byteOffset - an index into `buffer`; will be clamped to an int32
  // - encoding - an optional encoding, relevant is val is a string
  // - dir - true for indexOf, false for lastIndexOf
  function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
    // Empty buffer means no match
    if (buffer.length === 0) return -1

// Normalize byteOffset
    if (typeof byteOffset === 'string') {
      encoding = byteOffset;
      byteOffset = 0;
    } else if (byteOffset > 0x7fffffff) {
      byteOffset = 0x7fffffff;
    } else if (byteOffset < -0x80000000) {
      byteOffset = -0x80000000;
    }
    byteOffset = +byteOffset;  // Coerce to Number.
    if (isNaN(byteOffset)) {
      // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
      byteOffset = dir ? 0 : (buffer.length - 1);
    }

// Normalize byteOffset: negative offsets start from the end of the buffer
    if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
    if (byteOffset >= buffer.length) {
      if (dir) return -1
      else byteOffset = buffer.length - 1;
    } else if (byteOffset < 0) {
      if (dir) byteOffset = 0;
      else return -1
    }

// Normalize val
    if (typeof val === 'string') {
      val = Buffer$1.from(val, encoding);
    }

// Finally, search either indexOf (if dir is true) or lastIndexOf
    if (internalIsBuffer(val)) {
      // Special case: looking for empty string/buffer always fails
      if (val.length === 0) {
        return -1
      }
      return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
    } else if (typeof val === 'number') {
      val = val & 0xFF; // Search for a byte value [0-255]
      if (Buffer$1.TYPED_ARRAY_SUPPORT &&
          typeof Uint8Array.prototype.indexOf === 'function') {
        if (dir) {
          return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
        } else {
          return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
        }
      }
      return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
    }

throw new TypeError('val must be string, number or Buffer')
  }

function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
    var indexSize = 1;
    var arrLength = arr.length;
    var valLength = val.length;

if (encoding !== undefined) {
      encoding = String(encoding).toLowerCase();
      if (encoding === 'ucs2' || encoding === 'ucs-2' ||
          encoding === 'utf16le' || encoding === 'utf-16le') {
        if (arr.length < 2 || val.length < 2) {
          return -1
        }
        indexSize = 2;
        arrLength /= 2;
        valLength /= 2;
        byteOffset /= 2;
      }
    }

function read (buf, i) {
      if (indexSize === 1) {
        return buf[i]
      } else {
        return buf.readUInt16BE(i * indexSize)
      }
    }

var i;
    if (dir) {
      var foundIndex = -1;
      for (i = byteOffset; i < arrLength; i++) {
        if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
          if (foundIndex === -1) foundIndex = i;
          if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
        } else {
          if (foundIndex !== -1) i -= i - foundIndex;
          foundIndex = -1;
        }
      }
    } else {
      if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
      for (i = byteOffset; i >= 0; i--) {
        var found = true;
        for (var j = 0; j < valLength; j++) {
          if (read(arr, i + j) !== read(val, j)) {
            found = false;
            break
          }
        }
        if (found) return i
      }
    }

return -1
  }

Buffer$1.prototype.includes = function includes (val, byteOffset, encoding) {
    return this.indexOf(val, byteOffset, encoding) !== -1
  };

Buffer$1.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
    return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
  };

Buffer$1.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
    return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
  };

// must be an even number of digits
    var strLen = string.length;
    if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')

if (length > strLen / 2) {
      length = strLen / 2;
    }
    for (var i = 0; i < length; ++i) {
      var parsed = parseInt(string.substr(i * 2, 2), 16);
      if (isNaN(parsed)) return i
      buf[offset + i] = parsed;
    }
    return i
  }

function utf8Write (buf, string, offset, length) {
    return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
  }

function asciiWrite (buf, string, offset, length) {
    return blitBuffer(asciiToBytes(string), buf, offset, length)
  }

function latin1Write (buf, string, offset, length) {
    return asciiWrite(buf, string, offset, length)
  }

function base64Write (buf, string, offset, length) {
    return blitBuffer(base64ToBytes(string), buf, offset, length)
  }

function ucs2Write (buf, string, offset, length) {
    return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
  }

Buffer$1.prototype.write = function write (string, offset, length, encoding) {
    // Buffer#write(string)
    if (offset === undefined) {
      encoding = 'utf8';
      length = this.length;
      offset = 0;
    // Buffer#write(string, encoding)
    } else if (length === undefined && typeof offset === 'string') {
      encoding = offset;
      length = this.length;
      offset = 0;
    // Buffer#write(string, offset[, length][, encoding])
    } else if (isFinite(offset)) {
      offset = offset | 0;
      if (isFinite(length)) {
        length = length | 0;
        if (encoding === undefined) encoding = 'utf8';
      } else {
        encoding = length;
        length = undefined;
      }
    // legacy write(string, encoding, offset, length) - remove in v0.13
    } else {
      throw new Error(
        'Buffer.write(string, encoding, offset[, length]) is no longer supported'
      )
    }

var remaining = this.length - offset;
    if (length === undefined || length > remaining) length = remaining;

if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
      throw new RangeError('Attempt to write outside buffer bounds')
    }

if (!encoding) encoding = 'utf8';

var loweredCase = false;
    for (;;) {
      switch (encoding) {
        case 'hex':
          return hexWrite(this, string, offset, length)

case 'utf8':
        case 'utf-8':
          return utf8Write(this, string, offset, length)

case 'ascii':
          return asciiWrite(this, string, offset, length)

case 'latin1':
        case 'binary':
          return latin1Write(this, string, offset, length)

case 'base64':
          // Warning: maxLength not taken into account in base64Write
          return base64Write(this, string, offset, length)

case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return ucs2Write(this, string, offset, length)

default:
          if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
          encoding = ('' + encoding).toLowerCase();
          loweredCase = true;
      }
    }
  };

Buffer$1.prototype.toJSON = function toJSON () {
    return {
      type: 'Buffer',
      data: Array.prototype.slice.call(this._arr || this, 0)
    }
  };

function base64Slice (buf, start, end) {
    if (start === 0 && end === buf.length) {
      return fromByteArray(buf)
    } else {
      return fromByteArray(buf.slice(start, end))
    }
  }

function utf8Slice (buf, start, end) {
    end = Math.min(buf.length, end);
    var res = [];

var i = start;
    while (i < end) {
      var firstByte = buf[i];
      var codePoint = null;
      var bytesPerSequence = (firstByte > 0xEF) ? 4
        : (firstByte > 0xDF) ? 3
        : (firstByte > 0xBF) ? 2
        : 1;

if (i + bytesPerSequence <= end) {
        var secondByte, thirdByte, fourthByte, tempCodePoint;

switch (bytesPerSequence) {
          case 1:
            if (firstByte < 0x80) {
              codePoint = firstByte;
            }
            break
          case 2:
            secondByte = buf[i + 1];
            if ((secondByte & 0xC0) === 0x80) {
              tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
              if (tempCodePoint > 0x7F) {
                codePoint = tempCodePoint;
              }
            }
            break
          case 3:
            secondByte = buf[i + 1];
            thirdByte = buf[i + 2];
            if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
              tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
              if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
                codePoint = tempCodePoint;
              }
            }
            break
          case 4:
            secondByte = buf[i + 1];
            thirdByte = buf[i + 2];
            fourthByte = buf[i + 3];
            if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
              tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
              if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
                codePoint = tempCodePoint;
              }
            }
        }
      }

if (codePoint === null) {
        // we did not generate a valid codePoint so insert a
        // replacement char (U+FFFD) and advance only 1 byte
        codePoint = 0xFFFD;
        bytesPerSequence = 1;
      } else if (codePoint > 0xFFFF) {
        // encode to utf16 (surrogate pair dance)
        codePoint -= 0x10000;
        res.push(codePoint >>> 10 & 0x3FF | 0xD800);
        codePoint = 0xDC00 | codePoint & 0x3FF;
      }

res.push(codePoint);
      i += bytesPerSequence;
    }

return decodeCodePointsArray(res)
  }

// Based on http://stackoverflow.com/a/22747272/680742, the browser with
  // the lowest limit is Chrome, with 0x10000 args.
  // We go 1 magnitude less, for safety
  var MAX_ARGUMENTS_LENGTH = 0x1000;

function decodeCodePointsArray (codePoints) {
    var len = codePoints.length;
    if (len <= MAX_ARGUMENTS_LENGTH) {
      return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
    }

// Decode in chunks to avoid "call stack size exceeded".
    var res = '';
    var i = 0;
    while (i < len) {
      res += String.fromCharCode.apply(
        String,
        codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
      );
    }
    return res
  }

function asciiSlice (buf, start, end) {
    var ret = '';
    end = Math.min(buf.length, end);

for (var i = start; i < end; ++i) {
      ret += String.fromCharCode(buf[i] & 0x7F);
    }
    return ret
  }

function latin1Slice (buf, start, end) {
    var ret = '';
    end = Math.min(buf.length, end);

for (var i = start; i < end; ++i) {
      ret += String.fromCharCode(buf[i]);
    }
    return ret
  }

function hexSlice (buf, start, end) {
    var len = buf.length;

if (!start || start < 0) start = 0;
    if (!end || end < 0 || end > len) end = len;

var out = '';
    for (var i = start; i < end; ++i) {
      out += toHex(buf[i]);
    }
    return out
  }

function utf16leSlice (buf, start, end) {
    var bytes = buf.slice(start, end);
    var res = '';
    for (var i = 0; i < bytes.length; i += 2) {
      res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
    }
    return res
  }

Buffer$1.prototype.slice = function slice (start, end) {
    var len = this.length;
    start = ~~start;
    end = end === undefined ? len : ~~end;

if (start < 0) {
      start += len;
      if (start < 0) start = 0;
    } else if (start > len) {
      start = len;
    }

if (end < 0) {
      end += len;
      if (end < 0) end = 0;
    } else if (end > len) {
      end = len;
    }

if (end < start) end = start;

var newBuf;
    if (Buffer$1.TYPED_ARRAY_SUPPORT) {
      newBuf = this.subarray(start, end);
      newBuf.__proto__ = Buffer$1.prototype;
    } else {
      var sliceLen = end - start;
      newBuf = new Buffer$1(sliceLen, undefined);
      for (var i = 0; i < sliceLen; ++i) {
        newBuf[i] = this[i + start];
      }
    }

return newBuf
  };

/*
   * Need to make sure that buffer isn't trying to write out of bounds.
   */
  function checkOffset (offset, ext, length) {
    if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
    if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
  }

Buffer$1.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
    offset = offset | 0;
    byteLength = byteLength | 0;
    if (!noAssert) checkOffset(offset, byteLength, this.length);

var val = this[offset];
    var mul = 1;
    var i = 0;
    while (++i < byteLength && (mul *= 0x100)) {
      val += this[offset + i] * mul;
    }

return val
  };

Buffer$1.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
    offset = offset | 0;
    byteLength = byteLength | 0;
    if (!noAssert) {
      checkOffset(offset, byteLength, this.length);
    }

var val = this[offset + --byteLength];
    var mul = 1;
    while (byteLength > 0 && (mul *= 0x100)) {
      val += this[offset + --byteLength] * mul;
    }

return val
  };

Buffer$1.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 1, this.length);
    return this[offset]
  };

Buffer$1.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 2, this.length);
    return this[offset] | (this[offset + 1] << 8)
  };

Buffer$1.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 2, this.length);
    return (this[offset] << 8) | this[offset + 1]
  };

Buffer$1.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length);

return ((this[offset]) |
        (this[offset + 1] << 8) |
        (this[offset + 2] << 16)) +
        (this[offset + 3] * 0x1000000)
  };

Buffer$1.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length);

return (this[offset] * 0x1000000) +
      ((this[offset + 1] << 16) |
      (this[offset + 2] << 8) |
      this[offset + 3])
  };

Buffer$1.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
    offset = offset | 0;
    byteLength = byteLength | 0;
    if (!noAssert) checkOffset(offset, byteLength, this.length);

var val = this[offset];
    var mul = 1;
    var i = 0;
    while (++i < byteLength && (mul *= 0x100)) {
      val += this[offset + i] * mul;
    }
    mul *= 0x80;

if (val >= mul) val -= Math.pow(2, 8 * byteLength);

return val
  };

Buffer$1.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
    offset = offset | 0;
    byteLength = byteLength | 0;
    if (!noAssert) checkOffset(offset, byteLength, this.length);

var i = byteLength;
    var mul = 1;
    var val = this[offset + --i];
    while (i > 0 && (mul *= 0x100)) {
      val += this[offset + --i] * mul;
    }
    mul *= 0x80;

if (val >= mul) val -= Math.pow(2, 8 * byteLength);

return val
  };

Buffer$1.prototype.readInt8 = function readInt8 (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 1, this.length);
    if (!(this[offset] & 0x80)) return (this[offset])
    return ((0xff - this[offset] + 1) * -1)
  };

Buffer$1.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 2, this.length);
    var val = this[offset] | (this[offset + 1] << 8);
    return (val & 0x8000) ? val | 0xFFFF0000 : val
  };

Buffer$1.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 2, this.length);
    var val = this[offset + 1] | (this[offset] << 8);
    return (val & 0x8000) ? val | 0xFFFF0000 : val
  };

Buffer$1.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length);

return (this[offset]) |
      (this[offset + 1] << 8) |
      (this[offset + 2] << 16) |
      (this[offset + 3] << 24)
  };

Buffer$1.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length);

return (this[offset] << 24) |
      (this[offset + 1] << 16) |
      (this[offset + 2] << 8) |
      (this[offset + 3])
  };

Buffer$1.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length);
    return read(this, offset, true, 23, 4)
  };

Buffer$1.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 4, this.length);
    return read(this, offset, false, 23, 4)
  };

Buffer$1.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 8, this.length);
    return read(this, offset, true, 52, 8)
  };

Buffer$1.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
    if (!noAssert) checkOffset(offset, 8, this.length);
    return read(this, offset, false, 52, 8)
  };

function checkInt (buf, value, offset, ext, max, min) {
    if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
    if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
    if (offset + ext > buf.length) throw new RangeError('Index out of range')
  }

Buffer$1.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
    value = +value;
    offset = offset | 0;
    byteLength = byteLength | 0;
    if (!noAssert) {
      var maxBytes = Math.pow(2, 8 * byteLength) - 1;
      checkInt(this, value, offset, byteLength, maxBytes, 0);
    }

var mul = 1;
    var i = 0;
    this[offset] = value & 0xFF;
    while (++i < byteLength && (mul *= 0x100)) {
      this[offset + i] = (value / mul) & 0xFF;
    }

return offset + byteLength
  };

Buffer$1.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
    value = +value;
    offset = offset | 0;
    byteLength = byteLength | 0;
    if (!noAssert) {
      var maxBytes = Math.pow(2, 8 * byteLength) - 1;
      checkInt(this, value, offset, byteLength, maxBytes, 0);
    }

var i = byteLength - 1;
    var mul = 1;
    this[offset + i] = value & 0xFF;
    while (--i >= 0 && (mul *= 0x100)) {
      this[offset + i] = (value / mul) & 0xFF;
    }

return offset + byteLength
  };

Buffer$1.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
    if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
    this[offset] = (value & 0xff);
    return offset + 1
  };

function objectWriteUInt16 (buf, value, offset, littleEndian) {
    if (value < 0) value = 0xffff + value + 1;
    for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
      buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
        (littleEndian ? i : 1 - i) * 8;
    }
  }

Buffer$1.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
    if (Buffer$1.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value & 0xff);
      this[offset + 1] = (value >>> 8);
    } else {
      objectWriteUInt16(this, value, offset, true);
    }
    return offset + 2
  };

Buffer$1.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
    if (Buffer$1.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value >>> 8);
      this[offset + 1] = (value & 0xff);
    } else {
      objectWriteUInt16(this, value, offset, false);
    }
    return offset + 2
  };

function objectWriteUInt32 (buf, value, offset, littleEndian) {
    if (value < 0) value = 0xffffffff + value + 1;
    for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
      buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff;
    }
  }

Buffer$1.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
    if (Buffer$1.TYPED_ARRAY_SUPPORT) {
      this[offset + 3] = (value >>> 24);
      this[offset + 2] = (value >>> 16);
      this[offset + 1] = (value >>> 8);
      this[offset] = (value & 0xff);
    } else {
      objectWriteUInt32(this, value, offset, true);
    }
    return offset + 4
  };

Buffer$1.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
    if (Buffer$1.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value >>> 24);
      this[offset + 1] = (value >>> 16);
      this[offset + 2] = (value >>> 8);
      this[offset + 3] = (value & 0xff);
    } else {
      objectWriteUInt32(this, value, offset, false);
    }
    return offset + 4
  };

Buffer$1.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) {
      var limit = Math.pow(2, 8 * byteLength - 1);

checkInt(this, value, offset, byteLength, limit - 1, -limit);
    }

var i = 0;
    var mul = 1;
    var sub = 0;
    this[offset] = value & 0xFF;
    while (++i < byteLength && (mul *= 0x100)) {
      if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
        sub = 1;
      }
      this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
    }

return offset + byteLength
  };

Buffer$1.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) {
      var limit = Math.pow(2, 8 * byteLength - 1);

checkInt(this, value, offset, byteLength, limit - 1, -limit);
    }

var i = byteLength - 1;
    var mul = 1;
    var sub = 0;
    this[offset + i] = value & 0xFF;
    while (--i >= 0 && (mul *= 0x100)) {
      if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
        sub = 1;
      }
      this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
    }

return offset + byteLength
  };

Buffer$1.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
    if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
    if (value < 0) value = 0xff + value + 1;
    this[offset] = (value & 0xff);
    return offset + 1
  };

Buffer$1.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
    if (Buffer$1.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value & 0xff);
      this[offset + 1] = (value >>> 8);
    } else {
      objectWriteUInt16(this, value, offset, true);
    }
    return offset + 2
  };

Buffer$1.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
    if (Buffer$1.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value >>> 8);
      this[offset + 1] = (value & 0xff);
    } else {
      objectWriteUInt16(this, value, offset, false);
    }
    return offset + 2
  };

Buffer$1.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
    if (Buffer$1.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value & 0xff);
      this[offset + 1] = (value >>> 8);
      this[offset + 2] = (value >>> 16);
      this[offset + 3] = (value >>> 24);
    } else {
      objectWriteUInt32(this, value, offset, true);
    }
    return offset + 4
  };

Buffer$1.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
    value = +value;
    offset = offset | 0;
    if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
    if (value < 0) value = 0xffffffff + value + 1;
    if (Buffer$1.TYPED_ARRAY_SUPPORT) {
      this[offset] = (value >>> 24);
      this[offset + 1] = (value >>> 16);
      this[offset + 2] = (value >>> 8);
      this[offset + 3] = (value & 0xff);
    } else {
      objectWriteUInt32(this, value, offset, false);
    }
    return offset + 4
  };

function checkIEEE754 (buf, value, offset, ext, max, min) {
    if (offset + ext > buf.length) throw new RangeError('Index out of range')
    if (offset < 0) throw new RangeError('Index out of range')
  }

function writeFloat (buf, value, offset, littleEndian, noAssert) {
    if (!noAssert) {
      checkIEEE754(buf, value, offset, 4);
    }
    write(buf, value, offset, littleEndian, 23, 4);
    return offset + 4
  }

Buffer$1.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
    return writeFloat(this, value, offset, true, noAssert)
  };

Buffer$1.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
    return writeFloat(this, value, offset, false, noAssert)
  };

function writeDouble (buf, value, offset, littleEndian, noAssert) {
    if (!noAssert) {
      checkIEEE754(buf, value, offset, 8);
    }
    write(buf, value, offset, littleEndian, 52, 8);
    return offset + 8
  }

Buffer$1.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
    return writeDouble(this, value, offset, true, noAssert)
  };

Buffer$1.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
    return writeDouble(this, value, offset, false, noAssert)
  };

// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
  Buffer$1.prototype.copy = function copy (target, targetStart, start, end) {
    if (!start) start = 0;
    if (!end && end !== 0) end = this.length;
    if (targetStart >= target.length) targetStart = target.length;
    if (!targetStart) targetStart = 0;
    if (end > 0 && end < start) end = start;

// Copy 0 bytes; we're done
    if (end === start) return 0
    if (target.length === 0 || this.length === 0) return 0

// Fatal error conditions
    if (targetStart < 0) {
      throw new RangeError('targetStart out of bounds')
    }
    if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
    if (end < 0) throw new RangeError('sourceEnd out of bounds')

// Are we oob?
    if (end > this.length) end = this.length;
    if (target.length - targetStart < end - start) {
      end = target.length - targetStart + start;
    }

var len = end - start;
    var i;

if (this === target && start < targetStart && targetStart < end) {
      // descending copy from end
      for (i = len - 1; i >= 0; --i) {
        target[i + targetStart] = this[i + start];
      }
    } else if (len < 1000 || !Buffer$1.TYPED_ARRAY_SUPPORT) {
      // ascending copy from start
      for (i = 0; i < len; ++i) {
        target[i + targetStart] = this[i + start];
      }
    } else {
      Uint8Array.prototype.set.call(
        target,
        this.subarray(start, start + len),
        targetStart
      );
    }

return len
  };

// Usage:
  //    buffer.fill(number[, offset[, end]])
  //    buffer.fill(buffer[, offset[, end]])
  //    buffer.fill(string[, offset[, end]][, encoding])
  Buffer$1.prototype.fill = function fill (val, start, end, encoding) {
    // Handle string cases:
    if (typeof val === 'string') {
      if (typeof start === 'string') {
        encoding = start;
        start = 0;
        end = this.length;
      } else if (typeof end === 'string') {
        encoding = end;
        end = this.length;
      }
      if (val.length === 1) {
        var code = val.charCodeAt(0);
        if (code < 256) {
          val = code;
        }
      }
      if (encoding !== undefined && typeof encoding !== 'string') {
        throw new TypeError('encoding must be a string')
      }
      if (typeof encoding === 'string' && !Buffer$1.isEncoding(encoding)) {
        throw new TypeError('Unknown encoding: ' + encoding)
      }
    } else if (typeof val === 'number') {
      val = val & 255;
    }

// Invalid ranges are not set to a default, so can range check early.
    if (start < 0 || this.length < start || this.length < end) {
      throw new RangeError('Out of range index')
    }

if (end <= start) {
      return this
    }

start = start >>> 0;
    end = end === undefined ? this.length : end >>> 0;

if (!val) val = 0;

var i;
    if (typeof val === 'number') {
      for (i = start; i < end; ++i) {
        this[i] = val;
      }
    } else {
      var bytes = internalIsBuffer(val)
        ? val
        : utf8ToBytes(new Buffer$1(val, encoding).toString());
      var len = bytes.length;
      for (i = 0; i < end - start; ++i) {
        this[i + start] = bytes[i % len];
      }
    }

return this
  };

// HELPER FUNCTIONS
  // ================

var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;

function base64clean (str) {
    // Node strips out invalid characters like \n and \t from the string, base64-js does not
    str = stringtrim(str).replace(INVALID_BASE64_RE, '');
    // Node converts strings with length < 2 to ''
    if (str.length < 2) return ''
    // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
    while (str.length % 4 !== 0) {
      str = str + '=';
    }
    return str
  }

function stringtrim (str) {
    if (str.trim) return str.trim()
    return str.replace(/^\s+|\s+$/g, '')
  }

function toHex (n) {
    if (n < 16) return '0' + n.toString(16)
    return n.toString(16)
  }

function utf8ToBytes (string, units) {
    units = units || Infinity;
    var codePoint;
    var length = string.length;
    var leadSurrogate = null;
    var bytes = [];

for (var i = 0; i < length; ++i) {
      codePoint = string.charCodeAt(i);

// is surrogate component
      if (codePoint > 0xD7FF && codePoint < 0xE000) {
        // last char was a lead
        if (!leadSurrogate) {
          // no lead yet
          if (codePoint > 0xDBFF) {
            // unexpected trail
            if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
            continue
          } else if (i + 1 === length) {
            // unpaired lead
            if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
            continue
          }

// valid lead
          leadSurrogate = codePoint;

continue
        }

// 2 leads in a row
        if (codePoint < 0xDC00) {
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
          leadSurrogate = codePoint;
          continue
        }

// valid surrogate pair
        codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
      } else if (leadSurrogate) {
        // valid bmp char, but last char was a lead
        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
      }

leadSurrogate = null;

// encode utf8
      if (codePoint < 0x80) {
        if ((units -= 1) < 0) break
        bytes.push(codePoint);
      } else if (codePoint < 0x800) {
        if ((units -= 2) < 0) break
        bytes.push(
          codePoint >> 0x6 | 0xC0,
          codePoint & 0x3F | 0x80
        );
      } else if (codePoint < 0x10000) {
        if ((units -= 3) < 0) break
        bytes.push(
          codePoint >> 0xC | 0xE0,
          codePoint >> 0x6 & 0x3F | 0x80,
          codePoint & 0x3F | 0x80
        );
      } else if (codePoint < 0x110000) {
        if ((units -= 4) < 0) break
        bytes.push(
          codePoint >> 0x12 | 0xF0,
          codePoint >> 0xC & 0x3F | 0x80,
          codePoint >> 0x6 & 0x3F | 0x80,
          codePoint & 0x3F | 0x80
        );
      } else {
        throw new Error('Invalid code point')
      }
    }

return bytes
  }

function asciiToBytes (str) {
    var byteArray = [];
    for (var i = 0; i < str.length; ++i) {
      // Node's code seems to be doing this and not & 0x7F..
      byteArray.push(str.charCodeAt(i) & 0xFF);
    }
    return byteArray
  }

function utf16leToBytes (str, units) {
    var c, hi, lo;
    var byteArray = [];
    for (var i = 0; i < str.length; ++i) {
      if ((units -= 2) < 0) break

c = str.charCodeAt(i);
      hi = c >> 8;
      lo = c % 256;
      byteArray.push(lo);
      byteArray.push(hi);
    }

return byteArray
  }

function base64ToBytes (str) {
    return toByteArray(base64clean(str))
  }

function blitBuffer (src, dst, offset, length) {
    for (var i = 0; i < length; ++i) {
      if ((i + offset >= dst.length) || (i >= src.length)) break
      dst[i + offset] = src[i];
    }
    return i
  }

function isnan (val) {
    return val !== val // eslint-disable-line no-self-compare
  }

// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence
  // The _isBuffer check is for Safari 5-7 support, because it's missing
  // Object.prototype.constructor. Remove this eventually
  function isBuffer$2(obj) {
    return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj))
  }

function isFastBuffer (obj) {
    return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
  }

// For Node v0.10 support. Remove this eventually.
  function isSlowBuffer (obj) {
    return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0))
  }

var sourcemapCodec_umd = {exports: {}};

var hasRequiredSourcemapCodec_umd;
  function requireSourcemapCodec_umd() {
    if (hasRequiredSourcemapCodec_umd) return sourcemapCodec_umd.exports;
    hasRequiredSourcemapCodec_umd = 1;
    (function (module, exports) {
      (function (global, factory) {
        factory(exports) ;
      })(commonjsGlobal, function (exports) {

var traceMapping_umd = {exports: {}};

var resolveUri_umd = {exports: {}};

var hasRequiredResolveUri_umd;
  function requireResolveUri_umd() {
    if (hasRequiredResolveUri_umd) return resolveUri_umd.exports;
    hasRequiredResolveUri_umd = 1;
    (function (module, exports) {
      (function (global, factory) {
        module.exports = factory() ;
      })(commonjsGlobal, function () {
        var schemeRegex = /^[\w+.-]+:\/\//;
        var urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
        var fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
        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) {
          var match = urlRegex.exec(input);
          return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
        }
        function parseFileUrl(input) {
          var match = fileRegex.exec(input);
          var 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: scheme,
            user: user,
            host: host,
            port: port,
            path: path,
            query: query,
            hash: hash,
            type: 7
          };
        }
        function parseUrl(input) {
          if (isSchemeRelativeUrl(input)) {
            var _url = parseAbsoluteUrl('http:' + input);
            _url.scheme = '';
            _url.type = 6;
            return _url;
          }
          if (isAbsolutePath(input)) {
            var _url2 = parseAbsoluteUrl('http://foo.com' + input);
            _url2.scheme = '';
            _url2.host = '';
            _url2.type = 5;
            return _url2;
          }
          if (isFileUrl(input)) return parseFileUrl(input);
          if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
          var url = parseAbsoluteUrl('http://foo.com/' + input);
          url.scheme = '';
          url.host = '';
          url.type = input ? input.startsWith('?') ? 3 : input.startsWith('#') ? 2 : 4 : 1;
          return url;
        }
        function stripPathFilename(path) {
          if (path.endsWith('/..')) return path;
          var index = path.lastIndexOf('/');
          return path.slice(0, index + 1);
        }
        function mergePaths(url, base) {
          normalizePath(base, base.type);
          if (url.path === '/') {
            url.path = base.path;
          } else {
            url.path = stripPathFilename(base.path) + url.path;
          }
        }
        function normalizePath(url, type) {
          var rel = type <= 4;
          var pieces = url.path.split('/');
          var pointer = 1;
          var positive = 0;
          var addTrailingSlash = false;
          for (var i = 1; i < pieces.length; i++) {
            var 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++;
          }
          var path = '';
          for (var _i = 1; _i < pointer; _i++) {
            path += '/' + pieces[_i];
          }
          if (!path || addTrailingSlash && !path.endsWith('/..')) {
            path += '/';
          }
          url.path = path;
        }
        function resolve(input, base) {
          if (!input && !base) return '';
          var url = parseUrl(input);
          var inputType = url.type;
          if (base && inputType !== 7) {
            var baseUrl = parseUrl(base);
            var baseType = baseUrl.type;
            switch (inputType) {
              case 1:
                url.hash = baseUrl.hash;
              case 2:
                url.query = baseUrl.query;
              case 3:
              case 4:
                mergePaths(url, baseUrl);
              case 5:
                url.user = baseUrl.user;
                url.host = baseUrl.host;
                url.port = baseUrl.port;
              case 6:
                url.scheme = baseUrl.scheme;
            }
            if (baseType > inputType) inputType = baseType;
          }
          normalizePath(url, inputType);
          var queryHash = url.query + url.hash;
          switch (inputType) {
            case 2:
            case 3:
              return queryHash;
            case 4:
              {
                var path = url.path.slice(1);
                if (!path) return queryHash || '.';
                if (isRelative(base || input) && !isRelative(path)) {
                  return './' + path + queryHash;
                }
                return path + queryHash;
              }
            case 5:
              return url.path + queryHash;
            default:
              return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
          }
        }
        return resolve;
      });
    })(resolveUri_umd);
    return resolveUri_umd.exports;
  }

(function (module, exports) {
    (function (global, factory) {
      factory(exports, requireSourcemapCodec_umd(), requireResolveUri_umd()) ;
    })(commonjsGlobal, function (exports, sourcemapCodec, resolveUri) {

(function (module, exports) {
    (function (global, factory) {
      factory(exports, requireSetArray_umd(), requireSourcemapCodec_umd(), traceMapping_umdExports) ;
    })(commonjsGlobal, function (exports, setArray, sourcemapCodec, traceMapping) {

var parens = /*#__PURE__*/Object.freeze({
    __proto__: null,
    ArrowFunctionExpression: ConditionalExpression$2,
    AssignmentExpression: AssignmentExpression$2,
    AwaitExpression: YieldExpression$1,
    Binary: Binary,
    BinaryExpression: BinaryExpression$1,
    ClassExpression: ClassExpression,
    ConditionalExpression: ConditionalExpression$2,
    DoExpression: DoExpression$1,
    FunctionExpression: FunctionExpression$1,
    FunctionTypeAnnotation: FunctionTypeAnnotation$1,
    Identifier: Identifier$1,
    IntersectionTypeAnnotation: UnionTypeAnnotation$1,
    LogicalExpression: LogicalExpression$1,
    NullableTypeAnnotation: NullableTypeAnnotation$1,
    ObjectExpression: ObjectExpression$2,
    OptionalCallExpression: OptionalMemberExpression$1,
    OptionalIndexedAccessType: OptionalIndexedAccessType$1,
    OptionalMemberExpression: OptionalMemberExpression$1,
    SequenceExpression: SequenceExpression$2,
    TSAsExpression: TSAsExpression$1,
    TSInferType: TSInferType$1,
    TSInstantiationExpression: TSInstantiationExpression$1,
    TSIntersectionType: TSUnionType$1,
    TSSatisfiesExpression: TSAsExpression$1,
    TSTypeAssertion: UnaryLike,
    TSUnionType: TSUnionType$1,
    UnaryLike: UnaryLike,
    UnionTypeAnnotation: UnionTypeAnnotation$1,
    UpdateExpression: UpdateExpression$2,
    YieldExpression: YieldExpression$1
  });

var generatorFunctions = /*#__PURE__*/Object.freeze({
    __proto__: null,
    AnyTypeAnnotation: AnyTypeAnnotation,
    ArgumentPlaceholder: ArgumentPlaceholder,
    ArrayExpression: ArrayExpression$1,
    ArrayPattern: ArrayExpression$1,
    ArrayTypeAnnotation: ArrayTypeAnnotation,
    ArrowFunctionExpression: ArrowFunctionExpression,
    AssignmentExpression: AssignmentExpression$1,
    AssignmentPattern: AssignmentPattern,
    AwaitExpression: AwaitExpression,
    BigIntLiteral: BigIntLiteral,
    BinaryExpression: AssignmentExpression$1,
    BindExpression: BindExpression,
    BlockStatement: BlockStatement,
    BooleanLiteral: BooleanLiteral$1,
    BooleanLiteralTypeAnnotation: BooleanLiteralTypeAnnotation,
    BooleanTypeAnnotation: BooleanTypeAnnotation,
    BreakStatement: BreakStatement,
    CallExpression: CallExpression$1,
    CatchClause: CatchClause,
    ClassAccessorProperty: ClassAccessorProperty,
    ClassBody: ClassBody,
    ClassDeclaration: ClassDeclaration,
    ClassExpression: ClassDeclaration,
    ClassImplements: InterfaceExtends,
    ClassMethod: ClassMethod,
    ClassPrivateMethod: ClassPrivateMethod,
    ClassPrivateProperty: ClassPrivateProperty,
    ClassProperty: ClassProperty,
    ConditionalExpression: ConditionalExpression$1,
    ContinueStatement: ContinueStatement,
    DebuggerStatement: DebuggerStatement,
    DeclareClass: DeclareClass,
    DeclareExportAllDeclaration: DeclareExportAllDeclaration,
    DeclareExportDeclaration: DeclareExportDeclaration,
    DeclareFunction: DeclareFunction,
    DeclareInterface: DeclareInterface,
    DeclareModule: DeclareModule,
    DeclareModuleExports: DeclareModuleExports,
    DeclareOpaqueType: DeclareOpaqueType,
    DeclareTypeAlias: DeclareTypeAlias,
    DeclareVariable: DeclareVariable,
    DeclaredPredicate: DeclaredPredicate,
    Decorator: Decorator,
    Directive: Directive,
    DirectiveLiteral: DirectiveLiteral,
    DoExpression: DoExpression,
    DoWhileStatement: DoWhileStatement,
    EmptyStatement: EmptyStatement,
    EmptyTypeAnnotation: EmptyTypeAnnotation,
    EnumBooleanBody: EnumBooleanBody,
    EnumBooleanMember: EnumBooleanMember,
    EnumDeclaration: EnumDeclaration,
    EnumDefaultedMember: EnumDefaultedMember,
    EnumNumberBody: EnumNumberBody,
    EnumNumberMember: EnumNumberMember,
    EnumStringBody: EnumStringBody,
    EnumStringMember: EnumStringMember,
    EnumSymbolBody: EnumSymbolBody,
    ExistsTypeAnnotation: ExistsTypeAnnotation,
    ExportAllDeclaration: ExportAllDeclaration,
    ExportDefaultDeclaration: ExportDefaultDeclaration,
    ExportDefaultSpecifier: ExportDefaultSpecifier,
    ExportNamedDeclaration: ExportNamedDeclaration,
    ExportNamespaceSpecifier: ExportNamespaceSpecifier,
    ExportSpecifier: ExportSpecifier,
    ExpressionStatement: ExpressionStatement,
    File: File$1,
    ForInStatement: ForInStatement,
    ForOfStatement: ForOfStatement,
    ForStatement: ForStatement,
    FunctionDeclaration: FunctionExpression,
    FunctionExpression: FunctionExpression,
    FunctionTypeAnnotation: FunctionTypeAnnotation,
    FunctionTypeParam: FunctionTypeParam,
    GenericTypeAnnotation: InterfaceExtends,
    Identifier: Identifier,
    IfStatement: IfStatement,
    Import: Import,
    ImportAttribute: ImportAttribute,
    ImportDeclaration: ImportDeclaration,
    ImportDefaultSpecifier: ImportDefaultSpecifier,
    ImportExpression: ImportExpression,
    ImportNamespaceSpecifier: ImportNamespaceSpecifier,
    ImportSpecifier: ImportSpecifier,
    IndexedAccessType: IndexedAccessType,
    InferredPredicate: InferredPredicate,
    InterfaceDeclaration: InterfaceDeclaration,
    InterfaceExtends: InterfaceExtends,
    InterfaceTypeAnnotation: InterfaceTypeAnnotation,
    InterpreterDirective: InterpreterDirective,
    IntersectionTypeAnnotation: IntersectionTypeAnnotation,
    JSXAttribute: JSXAttribute,
    JSXClosingElement: JSXClosingElement,
    JSXClosingFragment: JSXClosingFragment,
    JSXElement: JSXElement,
    JSXEmptyExpression: JSXEmptyExpression,
    JSXExpressionContainer: JSXExpressionContainer,
    JSXFragment: JSXFragment,
    JSXIdentifier: JSXIdentifier,
    JSXMemberExpression: JSXMemberExpression,
    JSXNamespacedName: JSXNamespacedName,
    JSXOpeningElement: JSXOpeningElement,
    JSXOpeningFragment: JSXOpeningFragment,
    JSXSpreadAttribute: JSXSpreadAttribute,
    JSXSpreadChild: JSXSpreadChild,
    JSXText: JSXText,
    LabeledStatement: LabeledStatement,
    LogicalExpression: AssignmentExpression$1,
    MemberExpression: MemberExpression,
    MetaProperty: MetaProperty,
    MixedTypeAnnotation: MixedTypeAnnotation,
    ModuleExpression: ModuleExpression,
    NewExpression: NewExpression$1,
    NullLiteral: NullLiteral$1,
    NullLiteralTypeAnnotation: NullLiteralTypeAnnotation,
    NullableTypeAnnotation: NullableTypeAnnotation,
    NumberLiteralTypeAnnotation: NumericLiteral$1,
    NumberTypeAnnotation: NumberTypeAnnotation,
    NumericLiteral: NumericLiteral$1,
    ObjectExpression: ObjectExpression$1,
    ObjectMethod: ObjectMethod,
    ObjectPattern: ObjectExpression$1,
    ObjectProperty: ObjectProperty,
    ObjectTypeAnnotation: ObjectTypeAnnotation,
    ObjectTypeCallProperty: ObjectTypeCallProperty,
    ObjectTypeIndexer: ObjectTypeIndexer,
    ObjectTypeInternalSlot: ObjectTypeInternalSlot,
    ObjectTypeProperty: ObjectTypeProperty,
    ObjectTypeSpreadProperty: ObjectTypeSpreadProperty,
    OpaqueType: OpaqueType,
    OptionalCallExpression: OptionalCallExpression,
    OptionalIndexedAccessType: OptionalIndexedAccessType,
    OptionalMemberExpression: OptionalMemberExpression,
    ParenthesizedExpression: ParenthesizedExpression$1,
    PipelineBareFunction: PipelineBareFunction,
    PipelinePrimaryTopicReference: PipelinePrimaryTopicReference,
    PipelineTopicExpression: PipelineTopicExpression,
    Placeholder: Placeholder,
    PrivateName: PrivateName,
    Program: Program,
    QualifiedTypeIdentifier: QualifiedTypeIdentifier,
    RecordExpression: RecordExpression,
    RegExpLiteral: RegExpLiteral$1,
    RestElement: RestElement$1,
    ReturnStatement: ReturnStatement,
    SequenceExpression: SequenceExpression$1,
    SpreadElement: RestElement$1,
    StaticBlock: StaticBlock,
    StringLiteral: StringLiteral$1,
    StringLiteralTypeAnnotation: StringLiteral$1,
    StringTypeAnnotation: StringTypeAnnotation,
    Super: Super,
    SwitchCase: SwitchCase,
    SwitchStatement: SwitchStatement,
    SymbolTypeAnnotation: SymbolTypeAnnotation,
    TSAnyKeyword: TSAnyKeyword,
    TSArrayType: TSArrayType,
    TSAsExpression: TSTypeExpression,
    TSBigIntKeyword: TSBigIntKeyword,
    TSBooleanKeyword: TSBooleanKeyword,
    TSCallSignatureDeclaration: TSCallSignatureDeclaration,
    TSClassImplements: TSClassImplements,
    TSConditionalType: TSConditionalType,
    TSConstructSignatureDeclaration: TSConstructSignatureDeclaration,
    TSConstructorType: TSConstructorType,
    TSDeclareFunction: TSDeclareFunction,
    TSDeclareMethod: TSDeclareMethod,
    TSEnumBody: TSEnumBody,
    TSEnumDeclaration: TSEnumDeclaration,
    TSEnumMember: TSEnumMember,
    TSExportAssignment: TSExportAssignment,
    TSExternalModuleReference: TSExternalModuleReference,
    TSFunctionType: TSFunctionType,
    TSImportEqualsDeclaration: TSImportEqualsDeclaration,
    TSImportType: TSImportType,
    TSIndexSignature: TSIndexSignature,
    TSIndexedAccessType: TSIndexedAccessType,
    TSInferType: TSInferType,
    TSInstantiationExpression: TSInstantiationExpression,
    TSInterfaceBody: TSInterfaceBody,
    TSInterfaceDeclaration: TSInterfaceDeclaration,
    TSInterfaceHeritage: TSClassImplements,
    TSIntersectionType: TSIntersectionType,
    TSIntrinsicKeyword: TSIntrinsicKeyword,
    TSLiteralType: TSLiteralType,
    TSMappedType: TSMappedType,
    TSMethodSignature: TSMethodSignature,
    TSModuleBlock: TSModuleBlock,
    TSModuleDeclaration: TSModuleDeclaration,
    TSNamedTupleMember: TSNamedTupleMember,
    TSNamespaceExportDeclaration: TSNamespaceExportDeclaration,
    TSNeverKeyword: TSNeverKeyword,
    TSNonNullExpression: TSNonNullExpression$1,
    TSNullKeyword: TSNullKeyword,
    TSNumberKeyword: TSNumberKeyword,
    TSObjectKeyword: TSObjectKeyword,
    TSOptionalType: TSOptionalType,
    TSParameterProperty: TSParameterProperty,
    TSParenthesizedType: TSParenthesizedType,
    TSPropertySignature: TSPropertySignature,
    TSQualifiedName: TSQualifiedName,
    TSRestType: TSRestType,
    TSSatisfiesExpression: TSTypeExpression,
    TSStringKeyword: TSStringKeyword,
    TSSymbolKeyword: TSSymbolKeyword,
    TSThisType: TSThisType,
    TSTupleType: TSTupleType,
    TSTypeAliasDeclaration: TSTypeAliasDeclaration,
    TSTypeAnnotation: TSTypeAnnotation,
    TSTypeAssertion: TSTypeAssertion,
    TSTypeLiteral: TSTypeLiteral,
    TSTypeOperator: TSTypeOperator,
    TSTypeParameter: TSTypeParameter,
    TSTypeParameterDeclaration: TSTypeParameterInstantiation,
    TSTypeParameterInstantiation: TSTypeParameterInstantiation,
    TSTypePredicate: TSTypePredicate,
    TSTypeQuery: TSTypeQuery,
    TSTypeReference: TSTypeReference,
    TSUndefinedKeyword: TSUndefinedKeyword,
    TSUnionType: TSUnionType,
    TSUnknownKeyword: TSUnknownKeyword,
    TSVoidKeyword: TSVoidKeyword,
    TaggedTemplateExpression: TaggedTemplateExpression$1,
    TemplateElement: TemplateElement,
    TemplateLiteral: TemplateLiteral$1,
    ThisExpression: ThisExpression,
    ThisTypeAnnotation: ThisTypeAnnotation,
    ThrowStatement: ThrowStatement,
    TopicReference: TopicReference,
    TryStatement: TryStatement,
    TupleExpression: TupleExpression,
    TupleTypeAnnotation: TupleTypeAnnotation,
    TypeAlias: TypeAlias,
    TypeAnnotation: TypeAnnotation,
    TypeCastExpression: TypeCastExpression$1,
    TypeParameter: TypeParameter,
    TypeParameterDeclaration: TypeParameterInstantiation,
    TypeParameterInstantiation: TypeParameterInstantiation,
    TypeofTypeAnnotation: TypeofTypeAnnotation,
    UnaryExpression: UnaryExpression$1,
    UnionTypeAnnotation: UnionTypeAnnotation,
    UpdateExpression: UpdateExpression$1,
    V8IntrinsicIdentifier: V8IntrinsicIdentifier,
    VariableDeclaration: VariableDeclaration,
    VariableDeclarator: VariableDeclarator$1,
    Variance: Variance,
    VoidTypeAnnotation: VoidTypeAnnotation,
    WhileStatement: WhileStatement,
    WithStatement: WithStatement,
    YieldExpression: YieldExpression,
    _classMethodHead: _classMethodHead,
    _functionHead: _functionHead,
    _getRawIdentifier: _getRawIdentifier,
    _interfaceish: _interfaceish,
    _methodHead: _methodHead,
    _param: _param,
    _parameters: _parameters,
    _params: _params,
    _predicate: _predicate,
    _printAttributes: _printAttributes,
    _shouldPrintArrowParamsParens: _shouldPrintArrowParamsParens,
    _shouldPrintDecoratorsBeforeExport: _shouldPrintDecoratorsBeforeExport,
    _variance: _variance,
    tsPrintClassMemberModifiers: tsPrintClassMemberModifiers,
    tsPrintFunctionOrConstructorType: tsPrintFunctionOrConstructorType,
    tsPrintPropertyOrMethodName: tsPrintPropertyOrMethodName,
    tsPrintSignatureDeclarationBase: tsPrintSignatureDeclarationBase
  });

var index$2 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    default: generate$1
  });

var inferers = /*#__PURE__*/Object.freeze({
    __proto__: null,
    ArrayExpression: ArrayExpression,
    ArrowFunctionExpression: Func,
    AssignmentExpression: AssignmentExpression,
    BinaryExpression: BinaryExpression,
    BooleanLiteral: BooleanLiteral,
    CallExpression: CallExpression,
    ClassDeclaration: Func,
    ClassExpression: Func,
    ConditionalExpression: ConditionalExpression,
    FunctionDeclaration: Func,
    FunctionExpression: Func,
    Identifier: infererReference,
    LogicalExpression: LogicalExpression,
    NewExpression: NewExpression,
    NullLiteral: NullLiteral,
    NumericLiteral: NumericLiteral,
    ObjectExpression: ObjectExpression,
    ParenthesizedExpression: ParenthesizedExpression,
    RegExpLiteral: RegExpLiteral,
    RestElement: RestElement,
    SequenceExpression: SequenceExpression,
    StringLiteral: StringLiteral,
    TSAsExpression: TSAsExpression,
    TSNonNullExpression: TSNonNullExpression,
    TaggedTemplateExpression: TaggedTemplateExpression,
    TemplateLiteral: TemplateLiteral,
    TypeCastExpression: TypeCastExpression,
    UnaryExpression: UnaryExpression,
    UpdateExpression: UpdateExpression,
    VariableDeclarator: VariableDeclarator
  });

var NodePath_modification = /*#__PURE__*/Object.freeze({
    __proto__: null,
    _containerInsert: _containerInsert,
    _containerInsertAfter: _containerInsertAfter,
    _containerInsertBefore: _containerInsertBefore,
    _verifyNodeList: _verifyNodeList,
    insertAfter: insertAfter,
    insertBefore: insertBefore,
    pushContainer: pushContainer,
    unshiftContainer: unshiftContainer,
    updateSiblingKeys: updateSiblingKeys
  });

var _templateObject$F;
  var arrowFunctionExpression$1 = arrowFunctionExpression$4,
    assignmentExpression$4 = assignmentExpression$8,
    binaryExpression$3 = binaryExpression$4,
    blockStatement$2 = blockStatement$6,
    callExpression$8 = callExpression$c,
    conditionalExpression$3 = conditionalExpression$5,
    expressionStatement$2 = expressionStatement$7,
    identifier$7 = identifier$d,
    isIdentifier$4 = isIdentifier$e,
    jsxIdentifier = jsxIdentifier$1,
    logicalExpression$1 = logicalExpression$2,
    LOGICAL_OPERATORS$1 = LOGICAL_OPERATORS$2,
    memberExpression$7 = memberExpression$9,
    metaProperty = metaProperty$1,
    numericLiteral$3 = numericLiteral$5,
    objectExpression$2 = objectExpression$3,
    restElement$1 = restElement$2,
    returnStatement$1 = returnStatement$3,
    sequenceExpression$3 = sequenceExpression$6,
    spreadElement$1 = spreadElement$2,
    stringLiteral$4 = stringLiteral$6,
    _super = _super$1,
    thisExpression$2 = thisExpression$4,
    toExpression = toExpression$1,
    unaryExpression$3 = unaryExpression$4,
    toBindingIdentifierName = toBindingIdentifierName$1,
    isFunction$1 = isFunction$6,
    isAssignmentPattern$2 = isAssignmentPattern$4,
    isRestElement$1 = isRestElement$2,
    getFunctionName = getFunctionName$1,
    cloneNode$7 = cloneNode$e,
    variableDeclaration$3 = variableDeclaration$6,
    variableDeclarator$3 = variableDeclarator$6,
    exportNamedDeclaration$1 = exportNamedDeclaration$2,
    exportSpecifier$1 = exportSpecifier$2,
    inherits$2 = inherits$3;
  function toComputedKey() {
    var key;
    if (this.isMemberExpression()) {
      key = this.node.property;
    } else if (this.isProperty() || this.isMethod()) {
      key = this.node.key;
    } else {
      throw new ReferenceError("todo");
    }
    if (!this.node.computed) {
      if (isIdentifier$4(key)) key = stringLiteral$4(key.name);
    }
    return key;
  }
  function ensureBlock() {
    var body = this.get("body");
    var 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;
    }
    var statements = [];
    var stringPath = "body";
    var key;
    var listKey;
    if (body.isStatement()) {
      listKey = "body";
      key = 0;
      statements.push(body.node);
    } else {
      stringPath += ".body.0";
      if (this.isFunction()) {
        key = "argument";
        statements.push(returnStatement$1(body.node));
      } else {
        key = "expression";
        statements.push(expressionStatement$2(body.node));
      }
    }
    this.node.body = blockStatement$2(statements);
    var parentPath = this.get(stringPath);
    setup.call(body, parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key);
    return this.node;
  }
  {
    exports.arrowFunctionToShadowed = function () {
      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(_temp) {
    var _arguments$;
    var _ref = _temp === void 0 ? {} : _temp,
      _ref$allowInsertArrow = _ref.allowInsertArrow,
      allowInsertArrow = _ref$allowInsertArrow === void 0 ? true : _ref$allowInsertArrow,
      _ref$allowInsertArrow2 = _ref.allowInsertArrowWithRest,
      allowInsertArrowWithRest = _ref$allowInsertArrow2 === void 0 ? allowInsertArrow : _ref$allowInsertArrow2,
      _ref$noNewArrows = _ref.noNewArrows,
      noNewArrows = _ref$noNewArrows === void 0 ? !((_arguments$ = arguments[0]) != null && _arguments$.specCompliant) : _ref$noNewArrows;
    if (!this.isArrowFunctionExpression()) {
      throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
    }
    var self = this;
    if (!noNewArrows) {
      var _self$ensureFunctionN;
      self = (_self$ensureFunctionN = self.ensureFunctionName(false)) != null ? _self$ensureFunctionN : self;
    }
    var _hoistFunctionEnviron = hoistFunctionEnvironment(self, noNewArrows, allowInsertArrow, allowInsertArrowWithRest),
      thisBinding = _hoistFunctionEnviron.thisBinding,
      fn = _hoistFunctionEnviron.fnPath;
    fn.ensureBlock();
    setType(fn, "FunctionExpression");
    if (!noNewArrows) {
      var checkBinding = thisBinding ? null : fn.scope.generateUidIdentifier("arrowCheckId");
      if (checkBinding) {
        fn.parentPath.scope.push({
          id: checkBinding,
          init: objectExpression$2([])
        });
      }
      fn.get("body").unshiftContainer("body", expressionStatement$2(callExpression$8(this.hub.addHelper("newArrowCheck"), [thisExpression$2(), checkBinding ? identifier$7(checkBinding.name) : identifier$7(thisBinding)])));
      fn.replaceWith(callExpression$8(memberExpression$7(fn.node, identifier$7("bind")), [checkBinding ? identifier$7(checkBinding.name) : thisExpression$2()]));
      return fn.get("callee.object");
    }
    return fn;
  }
  var getSuperCallsVisitor = environmentVisitor({
    CallExpression: function CallExpression(child, _ref2) {
      var allSuperCalls = _ref2.allSuperCalls;
      if (!child.get("callee").isSuper()) return;
      allSuperCalls.push(child);
    }
  });
  function hoistFunctionEnvironment(fnPath, noNewArrows, allowInsertArrow, allowInsertArrowWithRest) {
    if (noNewArrows === void 0) {
      noNewArrows = true;
    }
    if (allowInsertArrow === void 0) {
      allowInsertArrow = true;
    }
    if (allowInsertArrowWithRest === void 0) {
      allowInsertArrowWithRest = true;
    }
    var arrowParent;
    var thisEnvFn = fnPath.findParent(function (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
      });
    });
    var inConstructor = thisEnvFn.isClassMethod({
      kind: "constructor"
    });
    if (thisEnvFn.isClassProperty() || thisEnvFn.isClassPrivateProperty()) {
      if (arrowParent) {
        thisEnvFn = arrowParent;
      } else if (allowInsertArrow) {
        fnPath.replaceWith(callExpression$8(arrowFunctionExpression$1([], toExpression(fnPath.node)), []));
        thisEnvFn = fnPath.get("callee");
        fnPath = thisEnvFn.get("body");
      } else {
        throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
      }
    }
    var _getScopeInformation = getScopeInformation(fnPath),
      thisPaths = _getScopeInformation.thisPaths,
      argumentsPaths = _getScopeInformation.argumentsPaths,
      newTargetPaths = _getScopeInformation.newTargetPaths,
      superProps = _getScopeInformation.superProps,
      superCalls = _getScopeInformation.superCalls;
    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.\n" + "Please 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.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
      }
      var allSuperCalls = [];
      thisEnvFn.traverse(getSuperCallsVisitor, {
        allSuperCalls: allSuperCalls
      });
      var superBinding = getSuperBinding(thisEnvFn);
      allSuperCalls.forEach(function (superCall) {
        var callee = identifier$7(superBinding);
        callee.loc = superCall.node.callee.loc;
        superCall.get("callee").replaceWith(callee);
      });
    }
    if (argumentsPaths.length > 0) {
      var argumentsBinding = getBinding(thisEnvFn, "arguments", function () {
        var args = function args() {
          return identifier$7("arguments");
        };
        if (thisEnvFn.scope.path.isProgram()) {
          return conditionalExpression$3(binaryExpression$3("===", unaryExpression$3("typeof", args()), stringLiteral$4("undefined")), thisEnvFn.scope.buildUndefinedNode(), args());
        } else {
          return args();
        }
      });
      argumentsPaths.forEach(function (argumentsChild) {
        var argsRef = identifier$7(argumentsBinding);
        argsRef.loc = argumentsChild.node.loc;
        argumentsChild.replaceWith(argsRef);
      });
    }
    if (newTargetPaths.length > 0) {
      var newTargetBinding = getBinding(thisEnvFn, "newtarget", function () {
        return metaProperty(identifier$7("new"), identifier$7("target"));
      });
      newTargetPaths.forEach(function (targetChild) {
        var targetRef = identifier$7(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.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
      }
      var flatSuperProps = superProps.reduce(function (acc, superProp) {
        return acc.concat(standardizeSuperProperty(superProp));
      }, []);
      flatSuperProps.forEach(function (superProp) {
        var key = superProp.node.computed ? "" : superProp.get("property").node.name;
        var superParentPath = superProp.parentPath;
        var isAssignment = superParentPath.isAssignmentExpression({
          left: superProp.node
        });
        var isCall = superParentPath.isCallExpression({
          callee: superProp.node
        });
        var isTaggedTemplate = superParentPath.isTaggedTemplateExpression({
          tag: superProp.node
        });
        var superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
        var args = [];
        if (superProp.node.computed) {
          args.push(superProp.get("property").node);
        }
        if (isAssignment) {
          var value = superParentPath.node.right;
          args.push(value);
        }
        var call = callExpression$8(identifier$7(superBinding), args);
        if (isCall) {
          superParentPath.unshiftContainer("arguments", thisExpression$2());
          superProp.replaceWith(memberExpression$7(call, identifier$7("call")));
          thisPaths.push(superParentPath.get("arguments.0"));
        } else if (isAssignment) {
          superParentPath.replaceWith(call);
        } else if (isTaggedTemplate) {
          superProp.replaceWith(callExpression$8(memberExpression$7(call, identifier$7("bind"), false), [thisExpression$2()]));
          thisPaths.push(superProp.get("arguments.0"));
        } else {
          superProp.replaceWith(call);
        }
      });
    }
    var thisBinding;
    if (thisPaths.length > 0 || !noNewArrows) {
      thisBinding = getThisBinding(thisEnvFn, inConstructor);
      if (noNewArrows || inConstructor && hasSuperClass(thisEnvFn)) {
        thisPaths.forEach(function (thisChild) {
          var thisRef = thisChild.isJSX() ? jsxIdentifier(thisBinding) : identifier$7(thisBinding);
          thisRef.loc = thisChild.node.loc;
          thisChild.replaceWith(thisRef);
        });
        if (!noNewArrows) thisBinding = null;
      }
    }
    return {
      thisBinding: thisBinding,
      fnPath: fnPath
    };
  }
  function isLogicalOp(op) {
    return LOGICAL_OPERATORS$1.includes(op);
  }
  function standardizeSuperProperty(superProp) {
    if (superProp.parentPath.isAssignmentExpression() && superProp.parentPath.node.operator !== "=") {
      var assignmentPath = superProp.parentPath;
      var op = assignmentPath.node.operator.slice(0, -1);
      var value = assignmentPath.node.right;
      var isLogicalAssignment = isLogicalOp(op);
      if (superProp.node.computed) {
        var tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
        var object = superProp.node.object;
        var property = superProp.node.property;
        assignmentPath.get("left").replaceWith(memberExpression$7(object, assignmentExpression$4("=", tmp, property), true));
        assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression$7(object, identifier$7(tmp.name), true), value));
      } else {
        var _object = superProp.node.object;
        var _property = superProp.node.property;
        assignmentPath.get("left").replaceWith(memberExpression$7(_object, _property));
        assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression$7(_object, identifier$7(_property.name)), value));
      }
      if (isLogicalAssignment) {
        assignmentPath.replaceWith(logicalExpression$1(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()) {
      var updateExpr = superProp.parentPath;
      var _tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
      var computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null;
      var parts = [assignmentExpression$4("=", _tmp, memberExpression$7(superProp.node.object, computedKey ? assignmentExpression$4("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), assignmentExpression$4("=", memberExpression$7(superProp.node.object, computedKey ? identifier$7(computedKey.name) : superProp.node.property, superProp.node.computed), binaryExpression$3(superProp.parentPath.node.operator[0], identifier$7(_tmp.name), numericLiteral$3(1)))];
      if (!superProp.parentPath.node.prefix) {
        parts.push(identifier$7(_tmp.name));
      }
      updateExpr.replaceWith(sequenceExpression$3(parts));
      var left = updateExpr.get("expressions.0.right");
      var right = updateExpr.get("expressions.1.left");
      return [left, right];
    }
    return [superProp];
    function rightExpression(op, left, right) {
      if (op === "=") {
        return assignmentExpression$4("=", left, right);
      } else {
        return binaryExpression$3(op, left, right);
      }
    }
  }
  function hasSuperClass(thisEnvFn) {
    return thisEnvFn.isClassMethod() && !!thisEnvFn.parentPath.parentPath.node.superClass;
  }
  var assignSuperThisVisitor = environmentVisitor({
    CallExpression: function CallExpression(child, _ref3) {
      var supers = _ref3.supers,
        thisBinding = _ref3.thisBinding;
      if (!child.get("callee").isSuper()) return;
      if (supers.has(child.node)) return;
      supers.add(child.node);
      child.replaceWithMultiple([child.node, assignmentExpression$4("=", identifier$7(thisBinding), identifier$7("this"))]);
    }
  });
  function getThisBinding(thisEnvFn, inConstructor) {
    return getBinding(thisEnvFn, "this", function (thisBinding) {
      if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression$2();
      thisEnvFn.traverse(assignSuperThisVisitor, {
        supers: new WeakSet(),
        thisBinding: thisBinding
      });
    });
  }
  function getSuperBinding(thisEnvFn) {
    return getBinding(thisEnvFn, "supercall", function () {
      var argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
      return arrowFunctionExpression$1([restElement$1(argsBinding)], callExpression$8(_super(), [spreadElement$1(identifier$7(argsBinding.name))]));
    });
  }
  function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
    var op = isAssignment ? "set" : "get";
    return getBinding(thisEnvFn, "superprop_" + op + ":" + (propName || ""), function () {
      var argsList = [];
      var fnBody;
      if (propName) {
        fnBody = memberExpression$7(_super(), identifier$7(propName));
      } else {
        var method = thisEnvFn.scope.generateUidIdentifier("prop");
        argsList.unshift(method);
        fnBody = memberExpression$7(_super(), identifier$7(method.name), true);
      }
      if (isAssignment) {
        var valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
        argsList.push(valueIdent);
        fnBody = assignmentExpression$4("=", fnBody, identifier$7(valueIdent.name));
      }
      return arrowFunctionExpression$1(argsList, fnBody);
    });
  }
  function getBinding(thisEnvFn, key, init) {
    var cacheKey = "binding:" + key;
    var data = thisEnvFn.getData(cacheKey);
    if (!data) {
      var id = thisEnvFn.scope.generateUidIdentifier(key);
      data = id.name;
      thisEnvFn.setData(cacheKey, data);
      thisEnvFn.scope.push({
        id: id,
        init: init(data)
      });
    }
    return data;
  }
  var getScopeInformationVisitor = environmentVisitor({
    ThisExpression: function ThisExpression(child, _ref4) {
      var thisPaths = _ref4.thisPaths;
      thisPaths.push(child);
    },
    JSXIdentifier: function JSXIdentifier(child, _ref5) {
      var thisPaths = _ref5.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: function CallExpression(child, _ref6) {
      var superCalls = _ref6.superCalls;
      if (child.get("callee").isSuper()) superCalls.push(child);
    },
    MemberExpression: function MemberExpression(child, _ref7) {
      var superProps = _ref7.superProps;
      if (child.get("object").isSuper()) superProps.push(child);
    },
    Identifier: function Identifier(child, _ref8) {
      var argumentsPaths = _ref8.argumentsPaths;
      if (!child.isReferencedIdentifier({
        name: "arguments"
      })) return;
      var 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: function MetaProperty(child, _ref9) {
      var newTargetPaths = _ref9.newTargetPaths;
      if (!child.get("meta").isIdentifier({
        name: "new"
      })) return;
      if (!child.get("property").isIdentifier({
        name: "target"
      })) return;
      newTargetPaths.push(child);
    }
  });
  function getScopeInformation(fnPath) {
    var thisPaths = [];
    var argumentsPaths = [];
    var newTargetPaths = [];
    var superProps = [];
    var superCalls = [];
    fnPath.traverse(getScopeInformationVisitor, {
      thisPaths: thisPaths,
      argumentsPaths: argumentsPaths,
      newTargetPaths: newTargetPaths,
      superProps: superProps,
      superCalls: superCalls
    });
    return {
      thisPaths: thisPaths,
      argumentsPaths: argumentsPaths,
      newTargetPaths: newTargetPaths,
      superProps: superProps,
      superCalls: superCalls
    };
  }
  function splitExportDeclaration() {
    if (!this.isExportDeclaration() || this.isExportAllDeclaration()) {
      throw new Error("Only default and named export declarations can be split.");
    }
    if (this.isExportNamedDeclaration() && this.get("specifiers").length > 0) {
      throw new Error("It doesn't make sense to split exported specifiers.");
    }
    var declaration = this.get("declaration");
    if (this.isExportDefaultDeclaration()) {
      var standaloneDeclaration = declaration.isFunctionDeclaration() || declaration.isClassDeclaration();
      var exportExpr = declaration.isFunctionExpression() || declaration.isClassExpression();
      var scope = declaration.isScope() ? declaration.scope.parent : declaration.scope;
      var id = declaration.node.id;
      var needBindingRegistration = false;
      if (!id) {
        needBindingRegistration = true;
        id = scope.generateUidIdentifier("default");
        if (standaloneDeclaration || exportExpr) {
          declaration.node.id = cloneNode$7(id);
        }
      } else if (exportExpr && scope.hasBinding(id.name)) {
        needBindingRegistration = true;
        id = scope.generateUidIdentifier(id.name);
      }
      var updatedDeclaration = standaloneDeclaration ? declaration.node : variableDeclaration$3("var", [variableDeclarator$3(cloneNode$7(id), declaration.node)]);
      var updatedExportDeclaration = exportNamedDeclaration$1(null, [exportSpecifier$1(cloneNode$7(id), identifier$7("default"))]);
      this.insertAfter(updatedExportDeclaration);
      this.replaceWith(updatedDeclaration);
      if (needBindingRegistration) {
        scope.registerDeclaration(this);
      }
      return this;
    } else if (this.get("specifiers").length > 0) {
      throw new Error("It doesn't make sense to split exported specifiers.");
    }
    var bindingIdentifiers = declaration.getOuterBindingIdentifiers();
    var specifiers = Object.keys(bindingIdentifiers).map(function (name) {
      return exportSpecifier$1(identifier$7(name), identifier$7(name));
    });
    var aliasDeclar = exportNamedDeclaration$1(null, specifiers);
    this.insertAfter(aliasDeclar);
    this.replaceWith(declaration.node);
    return this;
  }
  var refersOuterBindingVisitor = {
    "ReferencedIdentifier|BindingIdentifier": function ReferencedIdentifierBindingIdentifier(path, state) {
      if (path.node.name !== state.name) return;
      state.needsRename = true;
      path.stop();
    },
    Scope: function Scope(path, state) {
      if (path.scope.hasOwnBinding(state.name)) {
        path.skip();
      }
    }
  };
  function ensureFunctionName(supportUnicodeId) {
    if (this.node.id) return this;
    var res = getFunctionName(this.node, this.parent);
    if (res == null) return this;
    var name = res.name;
    if (!supportUnicodeId && /[\uD800-\uDFFF]/.test(name)) {
      return null;
    }
    if (name.startsWith("get ") || name.startsWith("set ")) {
      return null;
    }
    name = toBindingIdentifierName(name.replace(/[/ ]/g, "_"));
    var id = identifier$7(name);
    inherits$2(id, res.originalNode);
    var state = {
      needsRename: false,
      name: name
    };
    var scope = this.scope;
    var binding = scope.getOwnBinding(name);
    if (binding) {
      if (binding.kind === "param") {
        state.needsRename = true;
      }
    } else if (scope.parent.hasBinding(name) || scope.hasGlobal(name)) {
      this.traverse(refersOuterBindingVisitor, state);
    }
    if (!state.needsRename) {
      this.node.id = id;
      scope.getProgramParent().references[id.name] = true;
      return this;
    }
    if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
      scope.rename(id.name);
      this.node.id = id;
      scope.getProgramParent().references[id.name] = true;
      return this;
    }
    if (!isFunction$1(this.node)) return null;
    var key = scope.generateUidIdentifier(id.name);
    var params = [];
    for (var i = 0, len = getFunctionArity(this.node); i < len; i++) {
      params.push(scope.generateUidIdentifier("x"));
    }
    var call = template$1.expression.ast(_templateObject$F || (_templateObject$F = _taggedTemplateLiteralLoose(["\n    (function (", ") {\n      function ", "(", ") {\n        return ", ".apply(this, arguments);\n      }\n\n      ", ".toString = function () {\n        return ", ".toString();\n      }\n\n      return ", ";\n    })(", ")\n  "])), key, id, params, cloneNode$7(key), cloneNode$7(id), cloneNode$7(key), cloneNode$7(id), toExpression(this.node));
    return this.replaceWith(call)[0].get("arguments.0");
  }
  function getFunctionArity(node) {
    var count = node.params.findIndex(function (param) {
      return isAssignmentPattern$2(param) || isRestElement$1(param);
    });
    return count === -1 ? node.params.length : count;
  }

var NodePath_conversion = /*#__PURE__*/Object.freeze({
    __proto__: null,
    arrowFunctionToExpression: arrowFunctionToExpression,
    ensureBlock: ensureBlock,
    ensureFunctionName: ensureFunctionName,
    splitExportDeclaration: splitExportDeclaration,
    toComputedKey: toComputedKey,
    unwrapFunctionEnvironment: unwrapFunctionEnvironment
  });

var NodePath_introspection = /*#__PURE__*/Object.freeze({
    __proto__: null,
    _guessExecutionStatusRelativeTo: _guessExecutionStatusRelativeTo,
    _resolve: _resolve,
    canHaveVariableDeclarationOrExpression: canHaveVariableDeclarationOrExpression,
    canSwapBetweenExpressionAndStatement: canSwapBetweenExpressionAndStatement,
    getSource: getSource$1,
    isCompletionRecord: isCompletionRecord,
    isConstantExpression: isConstantExpression,
    isInStrictMode: isInStrictMode,
    isNodeType: isNodeType,
    isStatementOrBlock: isStatementOrBlock,
    isStatic: isStatic,
    matchesPattern: matchesPattern,
    referencesImport: referencesImport,
    resolve: resolve$3,
    willIMaybeExecuteBefore: willIMaybeExecuteBefore
  });

var index$1 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    Hub: Hub,
    NodePath: NodePath_Final,
    Scope: Scope,
    default: traverse,
    visitors: visitors$2
  });

var semver$a = {exports: {}};

var hasRequiredSemver$2;
  function requireSemver$2() {
    if (hasRequiredSemver$2) return semver$a.exports;
    hasRequiredSemver$2 = 1;
    (function (module, exports) {
      exports = module.exports = SemVer;
      var debug;
      if (typeof browser$1$1 === 'object' && browser$1$1.env && browser$1$1.env.NODE_DEBUG && /\bsemver\b/i.test(browser$1$1.env.NODE_DEBUG)) {
        debug = function debug() {
          var args = Array.prototype.slice.call(arguments, 0);
          args.unshift('SEMVER');
          console.log.apply(console, args);
        };
      } else {
        debug = function debug() {};
      }
      exports.SEMVER_SPEC_VERSION = '2.0.0';
      var MAX_LENGTH = 256;
      var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
      var MAX_SAFE_COMPONENT_LENGTH = 16;
      var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
      var re = exports.re = [];
      var safeRe = exports.safeRe = [];
      var src = exports.src = [];
      var t = exports.tokens = {};
      var R = 0;
      function tok(n) {
        t[n] = R++;
      }
      var LETTERDASHNUMBER = '[a-zA-Z0-9-]';
      var safeRegexReplacements = [['\\s', 1], ['\\d', MAX_LENGTH], [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]];
      function makeSafeRe(value) {
        for (var i = 0; i < safeRegexReplacements.length; i++) {
          var token = safeRegexReplacements[i][0];
          var max = safeRegexReplacements[i][1];
          value = value.split(token + '*').join(token + '{0,' + max + '}').split(token + '+').join(token + '{1,' + max + '}');
        }
        return value;
      }
      tok('NUMERICIDENTIFIER');
      src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*';
      tok('NUMERICIDENTIFIERLOOSE');
      src[t.NUMERICIDENTIFIERLOOSE] = '\\d+';
      tok('NONNUMERICIDENTIFIER');
      src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-]' + LETTERDASHNUMBER + '*';
      tok('MAINVERSION');
      src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')';
      tok('MAINVERSIONLOOSE');
      src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')';
      tok('PRERELEASEIDENTIFIER');
      src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + '|' + src[t.NONNUMERICIDENTIFIER] + ')';
      tok('PRERELEASEIDENTIFIERLOOSE');
      src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + '|' + src[t.NONNUMERICIDENTIFIER] + ')';
      tok('PRERELEASE');
      src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))';
      tok('PRERELEASELOOSE');
      src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))';
      tok('BUILDIDENTIFIER');
      src[t.BUILDIDENTIFIER] = LETTERDASHNUMBER + '+';
      tok('BUILD');
      src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] + '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))';
      tok('FULL');
      tok('FULLPLAIN');
      src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + src[t.PRERELEASE] + '?' + src[t.BUILD] + '?';
      src[t.FULL] = '^' + src[t.FULLPLAIN] + '$';
      tok('LOOSEPLAIN');
      src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + src[t.PRERELEASELOOSE] + '?' + src[t.BUILD] + '?';
      tok('LOOSE');
      src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$';
      tok('GTLT');
      src[t.GTLT] = '((?:<|>)?=?)';
      tok('XRANGEIDENTIFIERLOOSE');
      src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*';
      tok('XRANGEIDENTIFIER');
      src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*';
      tok('XRANGEPLAIN');
      src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:' + src[t.PRERELEASE] + ')?' + src[t.BUILD] + '?' + ')?)?';
      tok('XRANGEPLAINLOOSE');
      src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:' + src[t.PRERELEASELOOSE] + ')?' + src[t.BUILD] + '?' + ')?)?';
      tok('XRANGE');
      src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$';
      tok('XRANGELOOSE');
      src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$';
      tok('COERCE');
      src[t.COERCE] = '(^|[^\\d])' + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:$|[^\\d])';
      tok('COERCERTL');
      re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g');
      safeRe[t.COERCERTL] = new RegExp(makeSafeRe(src[t.COERCE]), 'g');
      tok('LONETILDE');
      src[t.LONETILDE] = '(?:~>?)';
      tok('TILDETRIM');
      src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+';
      re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g');
      safeRe[t.TILDETRIM] = new RegExp(makeSafeRe(src[t.TILDETRIM]), 'g');
      var tildeTrimReplace = '$1~';
      tok('TILDE');
      src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$';
      tok('TILDELOOSE');
      src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$';
      tok('LONECARET');
      src[t.LONECARET] = '(?:\\^)';
      tok('CARETTRIM');
      src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+';
      re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g');
      safeRe[t.CARETTRIM] = new RegExp(makeSafeRe(src[t.CARETTRIM]), 'g');
      var caretTrimReplace = '$1^';
      tok('CARET');
      src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$';
      tok('CARETLOOSE');
      src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$';
      tok('COMPARATORLOOSE');
      src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$';
      tok('COMPARATOR');
      src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$';
      tok('COMPARATORTRIM');
      src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')';
      re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g');
      safeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(src[t.COMPARATORTRIM]), 'g');
      var comparatorTrimReplace = '$1$2$3';
      tok('HYPHENRANGE');
      src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAIN] + ')' + '\\s*$';
      tok('HYPHENRANGELOOSE');
      src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s*$';
      tok('STAR');
      src[t.STAR] = '(<|>)?=?\\s*\\*';
      for (var i = 0; i < R; i++) {
        debug(i, src[i]);
        if (!re[i]) {
          re[i] = new RegExp(src[i]);
          safeRe[i] = new RegExp(makeSafeRe(src[i]));
        }
      }
      exports.parse = parse;
      function parse(version, options) {
        if (!options || typeof options !== 'object') {
          options = {
            loose: !!options,
            includePrerelease: false
          };
        }
        if (version instanceof SemVer) {
          return version;
        }
        if (typeof version !== 'string') {
          return null;
        }
        if (version.length > MAX_LENGTH) {
          return null;
        }
        var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL];
        if (!r.test(version)) {
          return null;
        }
        try {
          return new SemVer(version, options);
        } catch (er) {
          return null;
        }
      }
      exports.valid = valid;
      function valid(version, options) {
        var v = parse(version, options);
        return v ? v.version : null;
      }
      exports.clean = clean;
      function clean(version, options) {
        var s = parse(version.trim().replace(/^[=v]+/, ''), options);
        return s ? s.version : null;
      }
      exports.SemVer = SemVer;
      function SemVer(version, options) {
        if (!options || typeof options !== 'object') {
          options = {
            loose: !!options,
            includePrerelease: false
          };
        }
        if (version instanceof SemVer) {
          if (version.loose === options.loose) {
            return version;
          } else {
            version = version.version;
          }
        } else if (typeof version !== 'string') {
          throw new TypeError('Invalid Version: ' + version);
        }
        if (version.length > MAX_LENGTH) {
          throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters');
        }
        if (!(this instanceof SemVer)) {
          return new SemVer(version, options);
        }
        debug('SemVer', version, options);
        this.options = options;
        this.loose = !!options.loose;
        var m = version.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]);
        if (!m) {
          throw new TypeError('Invalid Version: ' + version);
        }
        this.raw = version;
        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 i = 0;
        do {
          var a = this.prerelease[i];
          var b = other.prerelease[i];
          debug('prerelease compare', i, a, b);
          if (a === undefined && b === undefined) {
            return 0;
          } else if (b === undefined) {
            return 1;
          } else if (a === undefined) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      };
      SemVer.prototype.compareBuild = function (other) {
        if (!(other instanceof SemVer)) {
          other = new SemVer(other, this.options);
        }
        var i = 0;
        do {
          var a = this.build[i];
          var b = other.build[i];
          debug('prerelease compare', i, a, b);
          if (a === undefined && b === undefined) {
            return 0;
          } else if (b === undefined) {
            return 1;
          } else if (a === undefined) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      };
      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 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 (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(version, release, loose, identifier) {
        if (typeof loose === 'string') {
          identifier = loose;
          loose = undefined;
        }
        try {
          return new SemVer(version, loose).inc(release, identifier).version;
        } catch (er) {
          return null;
        }
      }
      exports.diff = diff;
      function diff(version1, version2) {
        if (eq(version1, version2)) {
          return null;
        } else {
          var v1 = parse(version1);
          var v2 = parse(version2);
          var prefix = '';
          if (v1.prerelease.length || v2.prerelease.length) {
            prefix = 'pre';
            var defaultResult = 'prerelease';
          }
          for (var key in v1) {
            if (key === 'major' || key === 'minor' || key === 'patch') {
              if (v1[key] !== v2[key]) {
                return prefix + key;
              }
            }
          }
          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 = patch;
      function patch(a, loose) {
        return new SemVer(a, loose).patch;
      }
      exports.compare = compare;
      function compare(a, b, loose) {
        return new SemVer(a, loose).compare(new SemVer(b, loose));
      }
      exports.compareLoose = compareLoose;
      function compareLoose(a, b) {
        return compare(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 compare(b, a, loose);
      }
      exports.sort = sort;
      function sort(list, loose) {
        return list.sort(function (a, b) {
          return exports.compareBuild(a, b, loose);
        });
      }
      exports.rsort = rsort;
      function rsort(list, loose) {
        return list.sort(function (a, b) {
          return exports.compareBuild(b, a, loose);
        });
      }
      exports.gt = gt;
      function gt(a, b, loose) {
        return compare(a, b, loose) > 0;
      }
      exports.lt = lt;
      function lt(a, b, loose) {
        return compare(a, b, loose) < 0;
      }
      exports.eq = eq;
      function eq(a, b, loose) {
        return compare(a, b, loose) === 0;
      }
      exports.neq = neq;
      function neq(a, b, loose) {
        return compare(a, b, loose) !== 0;
      }
      exports.gte = gte;
      function gte(a, b, loose) {
        return compare(a, b, loose) >= 0;
      }
      exports.lte = lte;
      function lte(a, b, loose) {
        return compare(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);
        }
        comp = comp.trim().split(/\s+/).join(' ');
        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 ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];
        var m = comp.match(r);
        if (!m) {
          throw new TypeError('Invalid comparator: ' + comp);
        }
        this.operator = m[1] !== undefined ? 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 (version) {
        debug('Comparator.test', version, this.options.loose);
        if (this.semver === ANY || version === ANY) {
          return true;
        }
        if (typeof version === 'string') {
          try {
            version = new SemVer(version, this.options);
          } catch (er) {
            return false;
          }
        }
        return cmp(version, 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.trim().split(/\s+/).join(' ');
        this.set = this.raw.split('||').map(function (range) {
          return this.parseRange(range.trim());
        }, this).filter(function (c) {
          return c.length;
        });
        if (!this.set.length) {
          throw new TypeError('Invalid SemVer Range: ' + this.raw);
        }
        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;
        var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE];
        range = range.replace(hr, hyphenReplace);
        debug('hyphen replace', range);
        range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace);
        debug('comparator trim', range, safeRe[t.COMPARATORTRIM]);
        range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace);
        range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace);
        range = range.split(/\s+/).join(' ');
        var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.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 (c) {
            return c.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 (comp) {
          return replaceTilde(comp, options);
        }).join(' ');
      }
      function replaceTilde(comp, options) {
        var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.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 (comp) {
          return replaceCaret(comp, options);
        }).join(' ');
      }
      function replaceCaret(comp, options) {
        debug('caret', comp, options);
        var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.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 (comp) {
          return replaceXRange(comp, options);
        }).join(' ');
      }
      function replaceXRange(comp, options) {
        comp = comp.trim();
        var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.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(safeRe[t.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 (version) {
        if (!version) {
          return false;
        }
        if (typeof version === 'string') {
          try {
            version = new SemVer(version, this.options);
          } catch (er) {
            return false;
          }
        }
        for (var i = 0; i < this.set.length; i++) {
          if (testSet(this.set[i], version, this.options)) {
            return true;
          }
        }
        return false;
      };
      function testSet(set, version, options) {
        for (var i = 0; i < set.length; i++) {
          if (!set[i].test(version)) {
            return false;
          }
        }
        if (version.prerelease.length && !options.includePrerelease) {
          for (i = 0; i < set.length; i++) {
            debug(set[i].semver);
            if (set[i].semver === ANY) {
              continue;
            }
            if (set[i].semver.prerelease.length > 0) {
              var allowed = set[i].semver;
              if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
                return true;
              }
            }
          }
          return false;
        }
        return true;
      }
      exports.satisfies = satisfies;
      function satisfies(version, range, options) {
        try {
          range = new Range(range, options);
        } catch (er) {
          return false;
        }
        return range.test(version);
      }
      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 i = 0; i < range.set.length; ++i) {
          var comparators = range.set[i];
          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(version, range, options) {
        return outside(version, range, '<', options);
      }
      exports.gtr = gtr;
      function gtr(version, range, options) {
        return outside(version, range, '>', options);
      }
      exports.outside = outside;
      function outside(version, range, hilo, options) {
        version = new SemVer(version, 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(version, range, options)) {
          return false;
        }
        for (var i = 0; i < range.set.length; ++i) {
          var comparators = range.set[i];
          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(version, low.semver)) {
            return false;
          } else if (low.operator === ecomp && ltfn(version, low.semver)) {
            return false;
          }
        }
        return true;
      }
      exports.prerelease = prerelease;
      function prerelease(version, options) {
        var parsed = parse(version, 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(version, options) {
        if (version instanceof SemVer) {
          return version;
        }
        if (typeof version === 'number') {
          version = String(version);
        }
        if (typeof version !== 'string') {
          return null;
        }
        options = options || {};
        var match = null;
        if (!options.rtl) {
          match = version.match(safeRe[t.COERCE]);
        } else {
          var next;
          while ((next = safeRe[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
            if (!match || next.index + next[0].length !== match.index + match[0].length) {
              match = next;
            }
            safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
          }
          safeRe[t.COERCERTL].lastIndex = -1;
        }
        if (match === null) {
          return null;
        }
        return parse(match[2] + '.' + (match[3] || '0') + '.' + (match[4] || '0'), options);
      }
    })(semver$a, semver$a.exports);
    return semver$a.exports;
  }

function bool$7(value) {
    if (value == null) return false;
    return value && value !== "false" && value !== "0";
  }
  var semver$9 = bool$7(browser$1$1.env["BABEL_8_BREAKING"]) ? requireSemver$2() : requireSemver$2();

var inherits$1;
  if (typeof Object.create === 'function'){
    inherits$1 = function inherits(ctor, superCtor) {
      // implementation from standard node.js 'util' module
      ctor.super_ = superCtor;
      ctor.prototype = Object.create(superCtor.prototype, {
        constructor: {
          value: ctor,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
    };
  } else {
    inherits$1 = function inherits(ctor, superCtor) {
      ctor.super_ = superCtor;
      var TempCtor = function () {};
      TempCtor.prototype = superCtor.prototype;
      ctor.prototype = new TempCtor();
      ctor.prototype.constructor = ctor;
    };
  }

var formatRegExp = /%[sdj%]/g;
  function format(f) {
    if (!isString(f)) {
      var objects = [];
      for (var i = 0; i < arguments.length; i++) {
        objects.push(inspect$1(arguments[i]));
      }
      return objects.join(' ');
    }

// Mark that a method should not be used.
  // Returns a modified function which warns once by default.
  // If --no-deprecation is set, then it is a no-op.
  function deprecate(fn, msg) {
    // Allow for deprecating things in the process of starting up.
    if (isUndefined(global$1.process)) {
      return function() {
        return deprecate(fn, msg).apply(this, arguments);
      };
    }

if (browser$1$1.noDeprecation === true) {
      return fn;
    }

return deprecated;
  }

/**
   * Echos the value of a value. Trys to print the value out
   * in the best way possible given the different types.
   *
   * @param {Object} obj The object to print out.
   * @param {Object} opts Optional options object that alters the output.
   */
  /* legacy: obj, showHidden, depth, colors*/
  function inspect$1(obj, opts) {
    // default options
    var ctx = {
      seen: [],
      stylize: stylizeNoColor
    };
    // legacy...
    if (arguments.length >= 3) ctx.depth = arguments[2];
    if (arguments.length >= 4) ctx.colors = arguments[3];
    if (isBoolean(opts)) {
      // legacy...
      ctx.showHidden = opts;
    } else if (opts) {
      // got an "options" object
      _extend(ctx, opts);
    }
    // set default options
    if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
    if (isUndefined(ctx.depth)) ctx.depth = 2;
    if (isUndefined(ctx.colors)) ctx.colors = false;
    if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
    if (ctx.colors) ctx.stylize = stylizeWithColor;
    return formatValue(ctx, obj, ctx.depth);
  }

// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
  inspect$1.colors = {
    'bold' : [1, 22],
    'italic' : [3, 23],
    'underline' : [4, 24],
    'inverse' : [7, 27],
    'white' : [37, 39],
    'grey' : [90, 39],
    'black' : [30, 39],
    'blue' : [34, 39],
    'cyan' : [36, 39],
    'green' : [32, 39],
    'magenta' : [35, 39],
    'red' : [31, 39],
    'yellow' : [33, 39]
  };

// Don't use 'blue' not visible on cmd.exe
  inspect$1.styles = {
    'special': 'cyan',
    'number': 'yellow',
    'boolean': 'yellow',
    'undefined': 'grey',
    'null': 'bold',
    'string': 'green',
    'date': 'magenta',
    // "name": intentionally not styling
    'regexp': 'red'
  };

function stylizeWithColor(str, styleType) {
    var style = inspect$1.styles[styleType];

if (style) {
      return '\u001b[' + inspect$1.colors[style][0] + 'm' + str +
             '\u001b[' + inspect$1.colors[style][1] + 'm';
    } else {
      return str;
    }
  }

function stylizeNoColor(str, styleType) {
    return str;
  }

function arrayToHash(array) {
    var hash = {};

array.forEach(function(val, idx) {
      hash[val] = true;
    });

return hash;
  }

function formatValue(ctx, value, recurseTimes) {
    // Provide a hook for user-specified inspect functions.
    // Check that value is an object with an inspect function on it
    if (ctx.customInspect &&
        value &&
        isFunction(value.inspect) &&
        // Filter out the util module, it's inspect function is special
        value.inspect !== inspect$1 &&
        // Also filter out any prototype objects using the circular check.
        !(value.constructor && value.constructor.prototype === value)) {
      var ret = value.inspect(recurseTimes, ctx);
      if (!isString(ret)) {
        ret = formatValue(ctx, ret, recurseTimes);
      }
      return ret;
    }

// Primitive types cannot have properties
    var primitive = formatPrimitive(ctx, value);
    if (primitive) {
      return primitive;
    }

// Look up the keys of the object.
    var keys = Object.keys(value);
    var visibleKeys = arrayToHash(keys);

if (ctx.showHidden) {
      keys = Object.getOwnPropertyNames(value);
    }

// IE doesn't make error fields non-enumerable
    // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
    if (isError(value)
        && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
      return formatError(value);
    }

// Some type of object without properties can be shortcutted.
    if (keys.length === 0) {
      if (isFunction(value)) {
        var name = value.name ? ': ' + value.name : '';
        return ctx.stylize('[Function' + name + ']', 'special');
      }
      if (isRegExp(value)) {
        return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
      }
      if (isDate(value)) {
        return ctx.stylize(Date.prototype.toString.call(value), 'date');
      }
      if (isError(value)) {
        return formatError(value);
      }
    }

var base = '', array = false, braces = ['{', '}'];

// Make Array say that they are Array
    if (isArray$1(value)) {
      array = true;
      braces = ['[', ']'];
    }

// Make functions say that they are functions
    if (isFunction(value)) {
      var n = value.name ? ': ' + value.name : '';
      base = ' [Function' + n + ']';
    }

// Make RegExps say that they are RegExps
    if (isRegExp(value)) {
      base = ' ' + RegExp.prototype.toString.call(value);
    }

// Make dates with properties first say the date
    if (isDate(value)) {
      base = ' ' + Date.prototype.toUTCString.call(value);
    }

// Make error with message first say the error
    if (isError(value)) {
      base = ' ' + formatError(value);
    }

if (keys.length === 0 && (!array || value.length == 0)) {
      return braces[0] + base + braces[1];
    }

if (recurseTimes < 0) {
      if (isRegExp(value)) {
        return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
      } else {
        return ctx.stylize('[Object]', 'special');
      }
    }

ctx.seen.push(value);

var output;
    if (array) {
      output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
    } else {
      output = keys.map(function(key) {
        return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
      });
    }

ctx.seen.pop();

return reduceToSingleString(output, base, braces);
  }

function formatPrimitive(ctx, value) {
    if (isUndefined(value))
      return ctx.stylize('undefined', 'undefined');
    if (isString(value)) {
      var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
                                               .replace(/'/g, "\\'")
                                               .replace(/\\"/g, '"') + '\'';
      return ctx.stylize(simple, 'string');
    }
    if (isNumber(value))
      return ctx.stylize('' + value, 'number');
    if (isBoolean(value))
      return ctx.stylize('' + value, 'boolean');
    // For some reason typeof null is "object", so special case here.
    if (isNull(value))
      return ctx.stylize('null', 'null');
  }

function formatError(value) {
    return '[' + Error.prototype.toString.call(value) + ']';
  }

return name + ': ' + str;
  }

function reduceToSingleString(output, base, braces) {
    var length = output.reduce(function(prev, cur) {
      if (cur.indexOf('\n') >= 0) ;
      return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
    }, 0);

if (length > 60) {
      return braces[0] +
             (base === '' ? '' : base + '\n ') +
             ' ' +
             output.join(',\n  ') +
             ' ' +
             braces[1];
    }

return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
  }

// NOTE: These type checking functions intentionally don't use `instanceof`
  // because it is fragile and can be easily faked with `Object.create()`.
  function isArray$1(ar) {
    return Array.isArray(ar);
  }

function isBoolean(arg) {
    return typeof arg === 'boolean';
  }

function isNull(arg) {
    return arg === null;
  }

function isNullOrUndefined(arg) {
    return arg == null;
  }

function isNumber(arg) {
    return typeof arg === 'number';
  }

function isString(arg) {
    return typeof arg === 'string';
  }

function isSymbol(arg) {
    return typeof arg === 'symbol';
  }

function isUndefined(arg) {
    return arg === void 0;
  }

function isRegExp(re) {
    return isObject(re) && objectToString(re) === '[object RegExp]';
  }

function isObject(arg) {
    return typeof arg === 'object' && arg !== null;
  }

function isDate(d) {
    return isObject(d) && objectToString(d) === '[object Date]';
  }

function isError(e) {
    return isObject(e) &&
        (objectToString(e) === '[object Error]' || e instanceof Error);
  }

function isFunction(arg) {
    return typeof arg === 'function';
  }

function isPrimitive(arg) {
    return arg === null ||
           typeof arg === 'boolean' ||
           typeof arg === 'number' ||
           typeof arg === 'string' ||
           typeof arg === 'symbol' ||  // ES6 symbol
           typeof arg === 'undefined';
  }

function isBuffer(maybeBuf) {
    return Buffer$1.isBuffer(maybeBuf);
  }

function objectToString(o) {
    return Object.prototype.toString.call(o);
  }

function pad(n) {
    return n < 10 ? '0' + n.toString(10) : n.toString(10);
  }

var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
                'Oct', 'Nov', 'Dec'];

// 26 Feb 16:19:34
  function timestamp() {
    var d = new Date();
    var time = [pad(d.getHours()),
                pad(d.getMinutes()),
                pad(d.getSeconds())].join(':');
    return [d.getDate(), months[d.getMonth()], time].join(' ');
  }

// log is just a thin wrapper to console.log that prepends a timestamp
  function log() {
    console.log('%s - %s', timestamp(), format.apply(null, arguments));
  }

function _extend(origin, add) {
    // Don't do anything if add isn't an object
    if (!add || !isObject(add)) return origin;

var keys = Object.keys(add);
    var i = keys.length;
    while (i--) {
      origin[keys[i]] = add[keys[i]];
    }
    return origin;
  }
  function hasOwnProperty$1(obj, prop) {
    return Object.prototype.hasOwnProperty.call(obj, prop);
  }

var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;

function promisify(original) {
    if (typeof original !== 'function')
      throw new TypeError('The "original" argument must be of type Function');

if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
      var fn = original[kCustomPromisifiedSymbol];
      if (typeof fn !== 'function') {
        throw new TypeError('The "util.promisify.custom" argument must be of type Function');
      }
      Object.defineProperty(fn, kCustomPromisifiedSymbol, {
        value: fn, enumerable: false, writable: false, configurable: true
      });
      return fn;
    }

function fn() {
      var promiseResolve, promiseReject;
      var promise = new Promise(function (resolve, reject) {
        promiseResolve = resolve;
        promiseReject = reject;
      });

try {
        original.apply(this, args);
      } catch (err) {
        promiseReject(err);
      }

return promise;
    }

Object.setPrototypeOf(fn, Object.getPrototypeOf(original));

if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
      value: fn, enumerable: false, writable: false, configurable: true
    });
    return Object.defineProperties(
      fn,
      getOwnPropertyDescriptors(original)
    );
  }

promisify.custom = kCustomPromisifiedSymbol;

function callbackifyOnRejected(reason, cb) {
    // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).
    // Because `null` is a special error value in callbacks which means "no error
    // occurred", we error-wrap so the callback consumer can distinguish between
    // "the promise rejected with null" or "the promise fulfilled with undefined".
    if (!reason) {
      var newReason = new Error('Promise was rejected with a falsy value');
      newReason.reason = reason;
      reason = newReason;
    }
    return cb(reason);
  }

function callbackify(original) {
    if (typeof original !== 'function') {
      throw new TypeError('The "original" argument must be of type Function');
    }

// We DO NOT return the promise as it gives the user a false sense that
    // the promise is actually somehow related to the callback's execution
    // and that the callback throwing will reject the promise.
    function callbackified() {
      var args = [];
      for (var i = 0; i < arguments.length; i++) {
        args.push(arguments[i]);
      }

Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
    Object.defineProperties(callbackified, getOwnPropertyDescriptors(original));
    return callbackified;
  }

var _polyfillNode_util = {
    inherits: inherits$1,
    _extend: _extend,
    log: log,
    isBuffer: isBuffer,
    isPrimitive: isPrimitive,
    isFunction: isFunction,
    isError: isError,
    isDate: isDate,
    isObject: isObject,
    isRegExp: isRegExp,
    isUndefined: isUndefined,
    isSymbol: isSymbol,
    isString: isString,
    isNumber: isNumber,
    isNullOrUndefined: isNullOrUndefined,
    isNull: isNull,
    isBoolean: isBoolean,
    isArray: isArray$1,
    inspect: inspect$1,
    deprecate: deprecate,
    format: format,
    debuglog: debuglog,
    promisify: promisify,
    callbackify: callbackify,
  };

var _polyfillNode_util$1 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    _extend: _extend,
    callbackify: callbackify,
    debuglog: debuglog,
    default: _polyfillNode_util,
    deprecate: deprecate,
    format: format,
    inherits: inherits$1,
    inspect: inspect$1,
    isArray: isArray$1,
    isBoolean: isBoolean,
    isBuffer: isBuffer,
    isDate: isDate,
    isError: isError,
    isFunction: isFunction,
    isNull: isNull,
    isNullOrUndefined: isNullOrUndefined,
    isNumber: isNumber,
    isObject: isObject,
    isPrimitive: isPrimitive,
    isRegExp: isRegExp,
    isString: isString,
    isSymbol: isSymbol,
    isUndefined: isUndefined,
    log: log,
    promisify: promisify
  });

function compare$3(a, b) {
    if (a === b) {
      return 0;
    }

var x = a.length;
    var y = b.length;

for (var i = 0, len = Math.min(x, y); i < len; ++i) {
      if (a[i] !== b[i]) {
        x = a[i];
        y = b[i];
        break;
      }
    }

if (x < y) {
      return -1;
    }
    if (y < x) {
      return 1;
    }
    return 0;
  }
  var hasOwn = Object.prototype.hasOwnProperty;

function assert(value, message) {
    if (!value) fail(value, true, message, '==', ok);
  }

// 2. The AssertionError is defined in assert.
  // new assert.AssertionError({ message: message,
  //                             actual: actual,
  //                             expected: expected })

// try to strip useless frames
        var fn_name = getName$1(stackStartFunction);
        var idx = out.indexOf('\n' + fn_name);
        if (idx >= 0) {
          // once we have located the function frame
          // we need to strip out everything before it (and its line)
          var next_line = out.indexOf('\n', idx + 1);
          out = out.substring(next_line + 1);
        }

this.stack = out;
      }
    }
  }

// assert.AssertionError instanceof Error
  inherits$1(AssertionError, Error);

// At present only the three keys mentioned above are used and
  // understood by the spec. Implementations or sub modules can pass
  // other keys to the AssertionError's constructor - they will be
  // ignored.

// 3. All of the following functions must throw an AssertionError
  // when a corresponding condition is not met, with a message that
  // may be undefined if not provided.  All assertion methods provide
  // both the actual and expected values to the assertion error for
  // display purposes.

function fail(actual, expected, message, operator, stackStartFunction) {
    throw new AssertionError({
      message: message,
      actual: actual,
      expected: expected,
      operator: operator,
      stackStartFunction: stackStartFunction
    });
  }

// EXTENSION! allows for well behaved errors defined elsewhere.
  assert.fail = fail;

// 4. Pure assertion tests whether a value is truthy, as determined
  // by !!guard.
  // assert.ok(guard, message_opt);
  // This statement is equivalent to assert.equal(true, !!guard,
  // message_opt);. To test strictly for the value true, use
  // assert.strictEqual(true, guard, message_opt);.

function ok(value, message) {
    if (!value) fail(value, true, message, '==', ok);
  }
  assert.ok = ok;

// 5. The equality assertion tests shallow, coercive equality with
  // ==.
  // assert.equal(actual, expected, message_opt);
  assert.equal = equal;
  function equal(actual, expected, message) {
    if (actual != expected) fail(actual, expected, message, '==', equal);
  }

// 6. The non-equality assertion tests for whether two objects are not equal
  // with != assert.notEqual(actual, expected, message_opt);
  assert.notEqual = notEqual;
  function notEqual(actual, expected, message) {
    if (actual == expected) {
      fail(actual, expected, message, '!=', notEqual);
    }
  }

// 7. The equivalence assertion tests a deep equality relation.
  // assert.deepEqual(actual, expected, message_opt);
  assert.deepEqual = deepEqual;
  function deepEqual(actual, expected, message) {
    if (!_deepEqual(actual, expected, false)) {
      fail(actual, expected, message, 'deepEqual', deepEqual);
    }
  }
  assert.deepStrictEqual = deepStrictEqual;
  function deepStrictEqual(actual, expected, message) {
    if (!_deepEqual(actual, expected, true)) {
      fail(actual, expected, message, 'deepStrictEqual', deepStrictEqual);
    }
  }

function _deepEqual(actual, expected, strict, memos) {
    // 7.1. All identical values are equivalent, as determined by ===.
    if (actual === expected) {
      return true;
    } else if (isBuffer$2(actual) && isBuffer$2(expected)) {
      return compare$3(actual, expected) === 0;

// 7.2. If the expected value is a Date object, the actual value is
    // equivalent if it is also a Date object that refers to the same time.
    } else if (isDate(actual) && isDate(expected)) {
      return actual.getTime() === expected.getTime();

// 7.3 If the expected value is a RegExp object, the actual value is
    // equivalent if it is also a RegExp object with the same source and
    // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
    } else if (isRegExp(actual) && isRegExp(expected)) {
      return actual.source === expected.source &&
             actual.global === expected.global &&
             actual.multiline === expected.multiline &&
             actual.lastIndex === expected.lastIndex &&
             actual.ignoreCase === expected.ignoreCase;

// 7.4. Other pairs that do not both pass typeof value == 'object',
    // equivalence is determined by ==.
    } else if ((actual === null || typeof actual !== 'object') &&
               (expected === null || typeof expected !== 'object')) {
      return strict ? actual === expected : actual == expected;

// If both values are instances of typed arrays, wrap their underlying
    // ArrayBuffers in a Buffer each to increase performance
    // This optimization requires the arrays to have the same type as checked by
    // Object.prototype.toString (aka pToString). Never perform binary
    // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their
    // bit patterns are not identical.
    } else if (isView(actual) && isView(expected) &&
               pToString(actual) === pToString(expected) &&
               !(actual instanceof Float32Array ||
                 actual instanceof Float64Array)) {
      return compare$3(new Uint8Array(actual.buffer),
                     new Uint8Array(expected.buffer)) === 0;

// 7.5 For all other Object pairs, including Array objects, equivalence is
    // determined by having the same number of owned properties (as verified
    // with Object.prototype.hasOwnProperty.call), the same set of keys
    // (although not necessarily the same order), equivalent values for every
    // corresponding key, and an identical 'prototype' property. Note: this
    // accounts for both named and indexed properties on Arrays.
    } else if (isBuffer$2(actual) !== isBuffer$2(expected)) {
      return false;
    } else {
      memos = memos || {actual: [], expected: []};

var actualIndex = memos.actual.indexOf(actual);
      if (actualIndex !== -1) {
        if (actualIndex === memos.expected.indexOf(expected)) {
          return true;
        }
      }

memos.actual.push(actual);
      memos.expected.push(expected);

return objEquiv(actual, expected, strict, memos);
    }
  }

function isArguments(object) {
    return Object.prototype.toString.call(object) == '[object Arguments]';
  }

// 8. The non-equivalence assertion tests for any deep inequality.
  // assert.notDeepEqual(actual, expected, message_opt);
  assert.notDeepEqual = notDeepEqual;
  function notDeepEqual(actual, expected, message) {
    if (_deepEqual(actual, expected, false)) {
      fail(actual, expected, message, 'notDeepEqual', notDeepEqual);
    }
  }

assert.notDeepStrictEqual = notDeepStrictEqual;
  function notDeepStrictEqual(actual, expected, message) {
    if (_deepEqual(actual, expected, true)) {
      fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
    }
  }

// 9. The strict equality assertion tests strict equality, as determined by ===.
  // assert.strictEqual(actual, expected, message_opt);
  assert.strictEqual = strictEqual;
  function strictEqual(actual, expected, message) {
    if (actual !== expected) {
      fail(actual, expected, message, '===', strictEqual);
    }
  }

// 10. The strict non-equality assertion tests for strict inequality, as
  // determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
  assert.notStrictEqual = notStrictEqual;
  function notStrictEqual(actual, expected, message) {
    if (actual === expected) {
      fail(actual, expected, message, '!==', notStrictEqual);
    }
  }

function expectedException(actual, expected) {
    if (!actual || !expected) {
      return false;
    }

if (Object.prototype.toString.call(expected) == '[object RegExp]') {
      return expected.test(actual);
    }

try {
      if (actual instanceof expected) {
        return true;
      }
    } catch (e) {
      // Ignore.  The instanceof check doesn't work for arrow functions.
    }

if (Error.isPrototypeOf(expected)) {
      return false;
    }

return expected.call({}, actual) === true;
  }

function _tryBlock(block) {
    var error;
    try {
      block();
    } catch (e) {
      error = e;
    }
    return error;
  }

function _throws(shouldThrow, block, expected, message) {
    var actual;

if (typeof block !== 'function') {
      throw new TypeError('"block" argument must be a function');
    }

if (typeof expected === 'string') {
      message = expected;
      expected = null;
    }

actual = _tryBlock(block);

message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
              (message ? ' ' + message : '.');

if (shouldThrow && !actual) {
      fail(actual, expected, 'Missing expected exception' + message);
    }

var userProvidedMessage = typeof message === 'string';
    var isUnwantedException = !shouldThrow && isError(actual);
    var isUnexpectedException = !shouldThrow && actual && !expected;

if ((isUnwantedException &&
        userProvidedMessage &&
        expectedException(actual, expected)) ||
        isUnexpectedException) {
      fail(actual, expected, 'Got unwanted exception' + message);
    }

if ((shouldThrow && actual && expected &&
        !expectedException(actual, expected)) || (!shouldThrow && actual)) {
      throw actual;
    }
  }

// 11. Expected to throw an error:
  // assert.throws(block, Error_opt, message_opt);
  assert.throws = throws;
  function throws(block, /*optional*/error, /*optional*/message) {
    _throws(true, block, error, message);
  }

// EXTENSION! This is annoying to write outside this module.
  assert.doesNotThrow = doesNotThrow;
  function doesNotThrow(block, /*optional*/error, /*optional*/message) {
    _throws(false, block, error, message);
  }

assert.ifError = ifError;
  function ifError(err) {
    if (err) throw err;
  }

var _polyfillNode_assert = /*#__PURE__*/Object.freeze({
    __proto__: null,
    AssertionError: AssertionError,
    assert: ok,
    deepEqual: deepEqual,
    deepStrictEqual: deepStrictEqual,
    default: assert,
    doesNotThrow: doesNotThrow,
    equal: equal,
    fail: fail,
    ifError: ifError,
    notDeepEqual: notDeepEqual,
    notDeepStrictEqual: notDeepStrictEqual,
    notEqual: notEqual,
    notStrictEqual: notStrictEqual,
    ok: ok,
    strictEqual: strictEqual,
    throws: throws
  });

function isModule(path) {
    return path.node.sourceType === "module";
  }

var rewriteThisVisitor;
  function rewriteThis(programPath) {
    if (!rewriteThisVisitor) {
      rewriteThisVisitor = environmentVisitor({
        ThisExpression: function ThisExpression(path) {
          path.replaceWith(unaryExpression$4("void", numericLiteral$5(0), true));
        }
      });
      rewriteThisVisitor.noScope = true;
    }
    traverse(programPath.node, rewriteThisVisitor);
  }

var _templateObject$E;
  function isInType$1(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, wrapReference) {
    var imported = new Map();
    var exported = new Map();
    var requeueInParent = function requeueInParent(path) {
      programPath.requeue(path);
    };
    for (var _iterator = _createForOfIteratorHelperLoose(metadata.source), _step; !(_step = _iterator()).done;) {
      var _step$value = _slicedToArray(_step.value, 2),
        source = _step$value[0],
        data = _step$value[1];
      for (var _iterator3 = _createForOfIteratorHelperLoose(data.imports), _step3; !(_step3 = _iterator3()).done;) {
        var _step3$value = _slicedToArray(_step3.value, 2),
          localName = _step3$value[0],
          importName = _step3$value[1];
        imported.set(localName, [source, importName, null]);
      }
      for (var _iterator4 = _createForOfIteratorHelperLoose(data.importsNamespace), _step4; !(_step4 = _iterator4()).done;) {
        var _localName = _step4.value;
        imported.set(_localName, [source, null, _localName]);
      }
    }
    for (var _iterator2 = _createForOfIteratorHelperLoose(metadata.local), _step2; !(_step2 = _iterator2()).done;) {
      var _exportMeta;
      var _step2$value = _slicedToArray(_step2.value, 2),
        local = _step2$value[0],
        _data = _step2$value[1];
      var exportMeta = exported.get(local);
      if (!exportMeta) {
        exportMeta = [];
        exported.set(local, exportMeta);
      }
      (_exportMeta = exportMeta).push.apply(_exportMeta, _toConsumableArray(_data.names));
    }
    var rewriteBindingInitVisitorState = {
      metadata: metadata,
      requeueInParent: requeueInParent,
      scope: programPath.scope,
      exported: exported
    };
    programPath.traverse(rewriteBindingInitVisitor, rewriteBindingInitVisitorState);
    var rewriteReferencesVisitorState = {
      seen: new WeakSet(),
      metadata: metadata,
      requeueInParent: requeueInParent,
      scope: programPath.scope,
      imported: imported,
      exported: exported,
      buildImportReference: function buildImportReference(_ref, identNode) {
        var _ref2 = _slicedToArray(_ref, 3),
          source = _ref2[0],
          importName = _ref2[1],
          localName = _ref2[2];
        var meta = metadata.source.get(source);
        meta.referenced = true;
        if (localName) {
          if (meta.wrap) {
            var _wrapReference;
            identNode = (_wrapReference = wrapReference(identNode, meta.wrap)) != null ? _wrapReference : identNode;
          }
          return identNode;
        }
        var namespace = identifier$d(meta.name);
        if (meta.wrap) {
          var _wrapReference2;
          namespace = (_wrapReference2 = wrapReference(namespace, meta.wrap)) != null ? _wrapReference2 : namespace;
        }
        if (importName === "default" && meta.interop === "node-default") {
          return namespace;
        }
        var computed = metadata.stringSpecifiers.has(importName);
        return memberExpression$9(namespace, computed ? stringLiteral$6(importName) : identifier$d(importName), computed);
      }
    };
    programPath.traverse(rewriteReferencesVisitor, rewriteReferencesVisitorState);
  }
  var rewriteBindingInitVisitor = {
    Scope: function Scope(path) {
      path.skip();
    },
    ClassDeclaration: function ClassDeclaration(path) {
      var requeueInParent = this.requeueInParent,
        exported = this.exported,
        metadata = this.metadata;
      var id = path.node.id;
      if (!id) throw new Error("Expected class to have a name");
      var localName = id.name;
      var exportNames = exported.get(localName) || [];
      if (exportNames.length > 0) {
        var statement = expressionStatement$7(buildBindingExportAssignmentExpression(metadata, exportNames, identifier$d(localName), path.scope));
        statement._blockHoist = path.node._blockHoist;
        requeueInParent(path.insertAfter(statement)[0]);
      }
    },
    VariableDeclaration: function VariableDeclaration(path) {
      var requeueInParent = this.requeueInParent,
        exported = this.exported,
        metadata = this.metadata;
      var isVar = path.node.kind === "var";
      for (var _iterator5 = _createForOfIteratorHelperLoose(path.get("declarations")), _step5; !(_step5 = _iterator5()).done;) {
        var decl = _step5.value;
        var id = decl.node.id;
        var init = decl.node.init;
        if (isIdentifier$e(id) && exported.has(id.name) && !isArrowFunctionExpression(init) && (!isFunctionExpression(init) || init.id) && (!isClassExpression(init) || init.id)) {
          if (!init) {
            if (isVar) {
              continue;
            } else {
              init = path.scope.buildUndefinedNode();
            }
          }
          decl.node.init = buildBindingExportAssignmentExpression(metadata, exported.get(id.name), init, path.scope);
          requeueInParent(decl.get("init"));
        } else {
          for (var _i = 0, _Object$keys = Object.keys(decl.getOuterBindingIdentifiers()); _i < _Object$keys.length; _i++) {
            var localName = _Object$keys[_i];
            if (exported.has(localName)) {
              var statement = expressionStatement$7(buildBindingExportAssignmentExpression(metadata, exported.get(localName), identifier$d(localName), path.scope));
              statement._blockHoist = path.node._blockHoist;
              requeueInParent(path.insertAfter(statement)[0]);
            }
          }
        }
      }
    }
  };
  var buildBindingExportAssignmentExpression = function buildBindingExportAssignmentExpression(metadata, exportNames, localExpr, scope) {
    var exportsObjectName = metadata.exportName;
    for (var currentScope = scope; currentScope != null; currentScope = currentScope.parent) {
      if (currentScope.hasOwnBinding(exportsObjectName)) {
        currentScope.rename(exportsObjectName);
      }
    }
    return (exportNames || []).reduce(function (expr, exportName) {
      var stringSpecifiers = metadata.stringSpecifiers;
      var computed = stringSpecifiers.has(exportName);
      return assignmentExpression$8("=", memberExpression$9(identifier$d(exportsObjectName), computed ? stringLiteral$6(exportName) : identifier$d(exportName), computed), expr);
    }, localExpr);
  };
  var buildImportThrow = function buildImportThrow(localName) {
    return template$1.expression.ast(_templateObject$E || (_templateObject$E = _taggedTemplateLiteralLoose(["\n    (function() {\n      throw new Error('\"' + '", "' + '\" is read-only.');\n    })()\n  "])), localName);
  };
  var rewriteReferencesVisitor = {
    ReferencedIdentifier: function ReferencedIdentifier(path) {
      var seen = this.seen,
        buildImportReference = this.buildImportReference,
        scope = this.scope,
        imported = this.imported,
        requeueInParent = this.requeueInParent;
      if (seen.has(path.node)) return;
      seen.add(path.node);
      var localName = path.node.name;
      var importData = imported.get(localName);
      if (importData) {
        if (isInType$1(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.");
        }
        var localBinding = path.scope.getBinding(localName);
        var rootBinding = scope.getBinding(localName);
        if (rootBinding !== localBinding) return;
        var ref = buildImportReference(importData, path.node);
        ref.loc = path.node.loc;
        if ((path.parentPath.isCallExpression({
          callee: path.node
        }) || path.parentPath.isOptionalCallExpression({
          callee: path.node
        }) || path.parentPath.isTaggedTemplateExpression({
          tag: path.node
        })) && isMemberExpression$7(ref)) {
          path.replaceWith(sequenceExpression$6([numericLiteral$5(0), ref]));
        } else if (path.isJSXIdentifier() && isMemberExpression$7(ref)) {
          var object = ref.object,
            property = ref.property;
          path.replaceWith(jsxMemberExpression(jsxIdentifier$1(object.name), jsxIdentifier$1(property.name)));
        } else {
          path.replaceWith(ref);
        }
        requeueInParent(path);
        path.skip();
      }
    },
    UpdateExpression: function UpdateExpression(path) {
      var scope = this.scope,
        seen = this.seen,
        imported = this.imported,
        exported = this.exported,
        requeueInParent = this.requeueInParent,
        buildImportReference = this.buildImportReference;
      if (seen.has(path.node)) return;
      seen.add(path.node);
      var arg = path.get("argument");
      if (arg.isMemberExpression()) return;
      var update = path.node;
      if (arg.isIdentifier()) {
        var localName = arg.node.name;
        if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
          return;
        }
        var exportedNames = exported.get(localName);
        var importData = imported.get(localName);
        if ((exportedNames == null ? void 0 : exportedNames.length) > 0 || importData) {
          if (importData) {
            path.replaceWith(assignmentExpression$8(update.operator[0] + "=", buildImportReference(importData, arg.node), buildImportThrow(localName)));
          } else if (update.prefix) {
            path.replaceWith(buildBindingExportAssignmentExpression(this.metadata, exportedNames, cloneNode$e(update), path.scope));
          } else {
            var ref = scope.generateDeclaredUidIdentifier(localName);
            path.replaceWith(sequenceExpression$6([assignmentExpression$8("=", cloneNode$e(ref), cloneNode$e(update)), buildBindingExportAssignmentExpression(this.metadata, exportedNames, identifier$d(localName), path.scope), cloneNode$e(ref)]));
          }
        }
      }
      requeueInParent(path);
      path.skip();
    },
    AssignmentExpression: {
      exit: function exit(path) {
        var _this = this;
        var scope = this.scope,
          seen = this.seen,
          imported = this.imported,
          exported = this.exported,
          requeueInParent = this.requeueInParent,
          buildImportReference = this.buildImportReference;
        if (seen.has(path.node)) return;
        seen.add(path.node);
        var left = path.get("left");
        if (left.isMemberExpression()) return;
        if (left.isIdentifier()) {
          var localName = left.node.name;
          if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
            return;
          }
          var exportedNames = exported.get(localName);
          var importData = imported.get(localName);
          if ((exportedNames == null ? void 0 : exportedNames.length) > 0 || importData) {
            var assignment = path.node;
            if (importData) {
              assignment.left = buildImportReference(importData, left.node);
              assignment.right = sequenceExpression$6([assignment.right, buildImportThrow(localName)]);
            }
            var operator = assignment.operator;
            var newExpr;
            if (operator === "=") {
              newExpr = assignment;
            } else if (operator === "&&=" || operator === "||=" || operator === "??=") {
              newExpr = assignmentExpression$8("=", assignment.left, logicalExpression$2(operator.slice(0, -1), cloneNode$e(assignment.left), assignment.right));
            } else {
              newExpr = assignmentExpression$8("=", assignment.left, binaryExpression$4(operator.slice(0, -1), cloneNode$e(assignment.left), assignment.right));
            }
            path.replaceWith(buildBindingExportAssignmentExpression(this.metadata, exportedNames, newExpr, path.scope));
            requeueInParent(path);
            path.skip();
          }
        } else {
          var ids = left.getOuterBindingIdentifiers();
          var programScopeIds = Object.keys(ids).filter(function (localName) {
            return scope.getBinding(localName) === path.scope.getBinding(localName);
          });
          var id = programScopeIds.find(function (localName) {
            return imported.has(localName);
          });
          if (id) {
            path.node.right = sequenceExpression$6([path.node.right, buildImportThrow(id)]);
          }
          var items = [];
          programScopeIds.forEach(function (localName) {
            var exportedNames = exported.get(localName) || [];
            if (exportedNames.length > 0) {
              items.push(buildBindingExportAssignmentExpression(_this.metadata, exportedNames, identifier$d(localName), path.scope));
            }
          });
          if (items.length > 0) {
            var node = sequenceExpression$6(items);
            if (path.parentPath.isExpressionStatement()) {
              node = expressionStatement$7(node);
              node._blockHoist = path.parentPath.node._blockHoist;
            }
            var statement = path.insertAfter(node)[0];
            requeueInParent(statement);
          }
        }
      }
    },
    ForXStatement: function ForXStatement(path) {
      var scope = path.scope,
        node = path.node;
      var left = node.left;
      var exported = this.exported,
        imported = this.imported,
        programScope = this.scope;
      if (!isVariableDeclaration$3(left)) {
        var didTransformExport = false,
          importConstViolationName;
        var loopBodyScope = path.get("body").scope;
        for (var _i2 = 0, _Object$keys2 = Object.keys(getOuterBindingIdentifiers$1(left)); _i2 < _Object$keys2.length; _i2++) {
          var name = _Object$keys2[_i2];
          if (programScope.getBinding(name) === scope.getBinding(name)) {
            if (exported.has(name)) {
              didTransformExport = true;
              if (loopBodyScope.hasOwnBinding(name)) {
                loopBodyScope.rename(name);
              }
            }
            if (imported.has(name) && !importConstViolationName) {
              importConstViolationName = name;
            }
          }
        }
        if (!didTransformExport && !importConstViolationName) {
          return;
        }
        path.ensureBlock();
        var bodyPath = path.get("body");
        var newLoopId = scope.generateUidIdentifierBasedOnNode(left);
        path.get("left").replaceWith(variableDeclaration$6("let", [variableDeclarator$6(cloneNode$e(newLoopId))]));
        scope.registerDeclaration(path.get("left"));
        if (didTransformExport) {
          bodyPath.unshiftContainer("body", expressionStatement$7(assignmentExpression$8("=", left, newLoopId)));
        }
        if (importConstViolationName) {
          bodyPath.unshiftContainer("body", expressionStatement$7(buildImportThrow(importConstViolationName)));
        }
      }
    }
  };

// Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.

// resolves . and .. elements in a path array with directory names there
  // must be no slashes, empty elements, or device names (c:\) in the array
  // (so also no leading and trailing slashes - it does not distinguish
  // relative and absolute paths)
  function normalizeArray(parts, allowAboveRoot) {
    // if the path tries to go above the root, `up` ends up > 0
    var up = 0;
    for (var i = parts.length - 1; i >= 0; i--) {
      var last = parts[i];
      if (last === '.') {
        parts.splice(i, 1);
      } else if (last === '..') {
        parts.splice(i, 1);
        up++;
      } else if (up) {
        parts.splice(i, 1);
        up--;
      }
    }

// if the path is allowed to go above the root, restore leading ..s
    if (allowAboveRoot) {
      for (; up--; up) {
        parts.unshift('..');
      }
    }

return parts;
  }

// Split a filename into [root, dir, basename, ext], unix version
  // 'root' is just a slash, or nothing.
  var splitPathRe =
      /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
  var splitPath = function(filename) {
    return splitPathRe.exec(filename).slice(1);
  };

// path.resolve([from ...], to)
  // posix version
  function resolve$2() {
    var resolvedPath = '',
        resolvedAbsolute = false;

for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
      var path = (i >= 0) ? arguments[i] : '/';

// Skip empty and invalid entries
      if (typeof path !== 'string') {
        throw new TypeError('Arguments to path.resolve must be strings');
      } else if (!path) {
        continue;
      }

resolvedPath = path + '/' + resolvedPath;
      resolvedAbsolute = path.charAt(0) === '/';
    }

// At this point the path should be resolved to a full absolute path, but
    // handle relative paths to be safe (might happen when process.cwd() fails)

// Normalize the path
    resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
      return !!p;
    }), !resolvedAbsolute).join('/');

return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
  }
  // path.normalize(path)
  // posix version
  function normalize$2(path) {
    var isPathAbsolute = isAbsolute(path),
        trailingSlash = substr(path, -1) === '/';

// Normalize the path
    path = normalizeArray(filter(path.split('/'), function(p) {
      return !!p;
    }), !isPathAbsolute).join('/');

if (!path && !isPathAbsolute) {
      path = '.';
    }
    if (path && trailingSlash) {
      path += '/';
    }

return (isPathAbsolute ? '/' : '') + path;
  }
  // posix version
  function isAbsolute(path) {
    return path.charAt(0) === '/';
  }

// posix version
  function join() {
    var paths = Array.prototype.slice.call(arguments, 0);
    return normalize$2(filter(paths, function(p, index) {
      if (typeof p !== 'string') {
        throw new TypeError('Arguments to path.join must be strings');
      }
      return p;
    }).join('/'));
  }

// path.relative(from, to)
  // posix version
  function relative(from, to) {
    from = resolve$2(from).substr(1);
    to = resolve$2(to).substr(1);

function trim(arr) {
      var start = 0;
      for (; start < arr.length; start++) {
        if (arr[start] !== '') break;
      }

var end = arr.length - 1;
      for (; end >= 0; end--) {
        if (arr[end] !== '') break;
      }

if (start > end) return [];
      return arr.slice(start, end - start + 1);
    }

var fromParts = trim(from.split('/'));
    var toParts = trim(to.split('/'));

var length = Math.min(fromParts.length, toParts.length);
    var samePartsLength = length;
    for (var i = 0; i < length; i++) {
      if (fromParts[i] !== toParts[i]) {
        samePartsLength = i;
        break;
      }
    }

var outputParts = [];
    for (var i = samePartsLength; i < fromParts.length; i++) {
      outputParts.push('..');
    }

outputParts = outputParts.concat(toParts.slice(samePartsLength));

return outputParts.join('/');
  }

var sep$1 = '/';
  var delimiter = ':';

function dirname(path) {
    var result = splitPath(path),
        root = result[0],
        dir = result[1];

if (!root && !dir) {
      // No dirname whatsoever
      return '.';
    }

if (dir) {
      // It has a dirname, strip trailing slash
      dir = dir.substr(0, dir.length - 1);
    }

return root + dir;
  }

function basename(path, ext) {
    var f = splitPath(path)[2];
    // TODO: make this comparison case-insensitive on windows?
    if (ext && f.substr(-1 * ext.length) === ext) {
      f = f.substr(0, f.length - ext.length);
    }
    return f;
  }

// String.prototype.substr - negative index don't work in IE8
  var substr = 'ab'.substr(-1) === 'b' ?
      function (str, start, len) { return str.substr(start, len) } :
      function (str, start, len) {
          if (start < 0) start = str.length + start;
          return str.substr(start, len);
      }
  ;

var _polyfillNode_path = /*#__PURE__*/Object.freeze({
    __proto__: null,
    basename: basename,
    default: path$1,
    delimiter: delimiter,
    dirname: dirname,
    extname: extname,
    isAbsolute: isAbsolute,
    join: join,
    normalize: normalize$2,
    relative: relative,
    resolve: resolve$2,
    sep: sep$1
  });

var _templateObject$D, _templateObject2$j, _templateObject3$f, _templateObject4$a;
  function buildDynamicImport(node, deferToThen, wrapWithPromise, builder) {
    var specifier = isCallExpression$8(node) ? node.arguments[0] : node.source;
    if (isStringLiteral$5(specifier) || isTemplateLiteral$1(specifier) && specifier.quasis.length === 0) {
      if (deferToThen) {
        return template$1.expression.ast(_templateObject$D || (_templateObject$D = _taggedTemplateLiteralLoose(["\n        Promise.resolve().then(() => ", ")\n      "])), builder(specifier));
      } else return builder(specifier);
    }
    var specifierToString = isTemplateLiteral$1(specifier) ? identifier$d("specifier") : templateLiteral([templateElement({
      raw: ""
    }), templateElement({
      raw: ""
    })], [identifier$d("specifier")]);
    if (deferToThen) {
      return template$1.expression.ast(_templateObject2$j || (_templateObject2$j = _taggedTemplateLiteralLoose(["\n      (specifier =>\n        new Promise(r => r(", "))\n          .then(s => ", ")\n      )(", ")\n    "])), specifierToString, builder(identifier$d("s")), specifier);
    } else if (wrapWithPromise) {
      return template$1.expression.ast(_templateObject3$f || (_templateObject3$f = _taggedTemplateLiteralLoose(["\n      (specifier =>\n        new Promise(r => r(", "))\n      )(", ")\n    "])), builder(specifierToString), specifier);
    } else {
      return template$1.expression.ast(_templateObject4$a || (_templateObject4$a = _taggedTemplateLiteralLoose(["\n      (specifier => ", ")(", ")\n    "])), builder(specifierToString), specifier);
    }
  }

{
    var originalGetModuleName = getModuleName$1;
    getModuleName$1 = function getModuleName(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$1(rootOpts, pluginOpts) {
    var filename = rootOpts.filename,
      _rootOpts$filenameRel = rootOpts.filenameRelative,
      filenameRelative = _rootOpts$filenameRel === void 0 ? filename : _rootOpts$filenameRel,
      _rootOpts$sourceRoot = rootOpts.sourceRoot,
      sourceRoot = _rootOpts$sourceRoot === void 0 ? pluginOpts.moduleRoot : _rootOpts$sourceRoot;
    var moduleId = pluginOpts.moduleId,
      _pluginOpts$moduleIds2 = pluginOpts.moduleIds,
      moduleIds = _pluginOpts$moduleIds2 === void 0 ? !!moduleId : _pluginOpts$moduleIds2,
      getModuleId = pluginOpts.getModuleId,
      _pluginOpts$moduleRoo2 = pluginOpts.moduleRoot,
      moduleRoot = _pluginOpts$moduleRoo2 === void 0 ? sourceRoot : _pluginOpts$moduleRoo2;
    if (!moduleIds) return null;
    if (moduleId != null && !getModuleId) {
      return moduleId;
    }
    var moduleName = moduleRoot != null ? moduleRoot + "/" : "";
    if (filenameRelative) {
      var 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;
    }
  }

var _templateObject$C, _templateObject2$i, _templateObject3$e, _templateObject4$9, _templateObject5$5, _templateObject6$3, _templateObject7$2, _templateObject8$2, _templateObject9$2, _templateObject10$2, _templateObject11$2, _templateObject12$2, _templateObject13$2, _templateObject14$2;
  function rewriteModuleStatementsAndPrepareHeader(path, _ref) {
    var exportName = _ref.exportName,
      strict = _ref.strict,
      allowTopLevelThis = _ref.allowTopLevelThis,
      strictMode = _ref.strictMode,
      noInterop = _ref.noInterop,
      _ref$importInterop = _ref.importInterop,
      importInterop = _ref$importInterop === void 0 ? noInterop ? "none" : "babel" : _ref$importInterop,
      lazy = _ref.lazy,
      _ref$getWrapperPayloa = _ref.getWrapperPayload,
      getWrapperPayload = _ref$getWrapperPayloa === void 0 ? toGetWrapperPayload(lazy != null ? lazy : false) : _ref$getWrapperPayloa,
      _ref$wrapReference = _ref.wrapReference,
      wrapReference$1 = _ref$wrapReference === void 0 ? wrapReference : _ref$wrapReference,
      esNamespaceOnly = _ref.esNamespaceOnly,
      filename = _ref.filename,
      _ref$constantReexport = _ref.constantReexports,
      constantReexports = _ref$constantReexport === void 0 ? arguments[1].loose : _ref$constantReexport,
      _ref$enumerableModule = _ref.enumerableModuleMeta,
      enumerableModuleMeta = _ref$enumerableModule === void 0 ? arguments[1].loose : _ref$enumerableModule,
      noIncompleteNsImportDetection = _ref.noIncompleteNsImportDetection;
    validateImportInteropOption(importInterop);
    assert(isModule(path), "Cannot process module statements in a script");
    path.node.sourceType = "script";
    var meta = normalizeModuleAndLoadMetadata(path, exportName, {
      importInterop: importInterop,
      initializeReexports: constantReexports,
      getWrapperPayload: getWrapperPayload,
      esNamespaceOnly: esNamespaceOnly,
      filename: filename
    });
    if (!allowTopLevelThis) {
      rewriteThis(path);
    }
    rewriteLiveReferences(path, meta, wrapReference$1);
    if (strictMode !== false) {
      var hasStrict = path.node.directives.some(function (directive) {
        return directive.value.value === "use strict";
      });
      if (!hasStrict) {
        path.unshiftContainer("directives", directive(directiveLiteral("use strict")));
      }
    }
    var headers = [];
    if (hasExports(meta) && !strict) {
      headers.push(buildESModuleHeader(meta, enumerableModuleMeta));
    }
    var nameList = buildExportNameListDeclaration(path, meta);
    if (nameList) {
      meta.exportNameListName = nameList.name;
      headers.push(nameList.statement);
    }
    headers.push.apply(headers, _toConsumableArray(buildExportInitializationStatements(path, meta, wrapReference$1, constantReexports, noIncompleteNsImportDetection)));
    return {
      meta: meta,
      headers: headers
    };
  }
  function ensureStatementsHoisted(statements) {
    statements.forEach(function (header) {
      header._blockHoist = 3;
    });
  }
  function wrapInterop(programPath, expr, type) {
    if (type === "none") {
      return null;
    }
    if (type === "node-namespace") {
      return callExpression$c(programPath.hub.addHelper("interopRequireWildcard"), [expr, booleanLiteral$2(true)]);
    } else if (type === "node-default") {
      return null;
    }
    var helper;
    if (type === "default") {
      helper = "interopRequireDefault";
    } else if (type === "namespace") {
      helper = "interopRequireWildcard";
    } else {
      throw new Error("Unknown interop: " + type);
    }
    return callExpression$c(programPath.hub.addHelper(helper), [expr]);
  }
  function buildNamespaceInitStatements(metadata, sourceMetadata, constantReexports, wrapReference$1) {
    var _wrapReference;
    if (constantReexports === void 0) {
      constantReexports = false;
    }
    if (wrapReference$1 === void 0) {
      wrapReference$1 = wrapReference;
    }
    var statements = [];
    var srcNamespaceId = identifier$d(sourceMetadata.name);
    for (var _iterator = _createForOfIteratorHelperLoose(sourceMetadata.importsNamespace), _step; !(_step = _iterator()).done;) {
      var localName = _step.value;
      if (localName === sourceMetadata.name) continue;
      statements.push(template$1.statement(_templateObject$C || (_templateObject$C = _taggedTemplateLiteralLoose(["var NAME = SOURCE;"])))({
        NAME: localName,
        SOURCE: cloneNode$e(srcNamespaceId)
      }));
    }
    var srcNamespace = (_wrapReference = wrapReference$1(srcNamespaceId, sourceMetadata.wrap)) != null ? _wrapReference : srcNamespaceId;
    if (constantReexports) {
      statements.push.apply(statements, _toConsumableArray(buildReexportsFromMeta(metadata, sourceMetadata, true, wrapReference$1)));
    }
    for (var _iterator2 = _createForOfIteratorHelperLoose(sourceMetadata.reexportNamespace), _step2; !(_step2 = _iterator2()).done;) {
      var exportName = _step2.value;
      statements.push((!isIdentifier$e(srcNamespace) ? template$1.statement(_templateObject2$i || (_templateObject2$i = _taggedTemplateLiteralLoose(["\n            Object.defineProperty(EXPORTS, \"NAME\", {\n              enumerable: true,\n              get: function() {\n                return NAMESPACE;\n              }\n            });\n          "]))) : template$1.statement(_templateObject3$e || (_templateObject3$e = _taggedTemplateLiteralLoose(["EXPORTS.NAME = NAMESPACE;"]))))({
        EXPORTS: metadata.exportName,
        NAME: exportName,
        NAMESPACE: cloneNode$e(srcNamespace)
      }));
    }
    if (sourceMetadata.reexportAll) {
      var statement = buildNamespaceReexport(metadata, cloneNode$e(srcNamespace), constantReexports);
      statement.loc = sourceMetadata.reexportAll.loc;
      statements.push(statement);
    }
    return statements;
  }
  var ReexportTemplate = {
    constant: function constant(_ref2) {
      var exports = _ref2.exports,
        exportName = _ref2.exportName,
        namespaceImport = _ref2.namespaceImport;
      return template$1.statement.ast(_templateObject4$9 || (_templateObject4$9 = _taggedTemplateLiteralLoose(["\n      ", ".", " = ", ";\n    "])), exports, exportName, namespaceImport);
    },
    constantComputed: function constantComputed(_ref3) {
      var exports = _ref3.exports,
        exportName = _ref3.exportName,
        namespaceImport = _ref3.namespaceImport;
      return template$1.statement.ast(_templateObject5$5 || (_templateObject5$5 = _taggedTemplateLiteralLoose(["\n      ", "[\"", "\"] = ", ";\n    "])), exports, exportName, namespaceImport);
    },
    spec: function spec(_ref4) {
      var exports = _ref4.exports,
        exportName = _ref4.exportName,
        namespaceImport = _ref4.namespaceImport;
      return template$1.statement.ast(_templateObject6$3 || (_templateObject6$3 = _taggedTemplateLiteralLoose(["\n      Object.defineProperty(", ", \"", "\", {\n        enumerable: true,\n        get: function() {\n          return ", ";\n        },\n      });\n    "])), exports, exportName, namespaceImport);
    }
  };
  function buildReexportsFromMeta(meta, metadata, constantReexports, wrapReference) {
    var _wrapReference2;
    var namespace = identifier$d(metadata.name);
    namespace = (_wrapReference2 = wrapReference(namespace, metadata.wrap)) != null ? _wrapReference2 : namespace;
    var stringSpecifiers = meta.stringSpecifiers;
    return Array.from(metadata.reexports, function (_ref5) {
      var _ref6 = _slicedToArray(_ref5, 2),
        exportName = _ref6[0],
        importName = _ref6[1];
      var namespaceImport = cloneNode$e(namespace);
      if (importName === "default" && metadata.interop === "node-default") ; else if (stringSpecifiers.has(importName)) {
        namespaceImport = memberExpression$9(namespaceImport, stringLiteral$6(importName), true);
      } else {
        namespaceImport = memberExpression$9(namespaceImport, identifier$d(importName));
      }
      var astNodes = {
        exports: meta.exportName,
        exportName: exportName,
        namespaceImport: namespaceImport
      };
      if (constantReexports || isIdentifier$e(namespaceImport)) {
        if (stringSpecifiers.has(exportName)) {
          return ReexportTemplate.constantComputed(astNodes);
        } else {
          return ReexportTemplate.constant(astNodes);
        }
      } else {
        return ReexportTemplate.spec(astNodes);
      }
    });
  }
  function buildESModuleHeader(metadata, enumerableModuleMeta) {
    if (enumerableModuleMeta === void 0) {
      enumerableModuleMeta = false;
    }
    return (enumerableModuleMeta ? template$1.statement(_templateObject7$2 || (_templateObject7$2 = _taggedTemplateLiteralLoose(["\n        EXPORTS.__esModule = true;\n      "]))) : template$1.statement(_templateObject8$2 || (_templateObject8$2 = _taggedTemplateLiteralLoose(["\n        Object.defineProperty(EXPORTS, \"__esModule\", {\n          value: true,\n        });\n      "]))))({
      EXPORTS: metadata.exportName
    });
  }
  function buildNamespaceReexport(metadata, namespace, constantReexports) {
    return (constantReexports ? template$1.statement(_templateObject9$2 || (_templateObject9$2 = _taggedTemplateLiteralLoose(["\n        Object.keys(NAMESPACE).forEach(function(key) {\n          if (key === \"default\" || key === \"__esModule\") return;\n          VERIFY_NAME_LIST;\n          if (key in EXPORTS && EXPORTS[key] === NAMESPACE[key]) return;\n\n          EXPORTS[key] = NAMESPACE[key];\n        });\n      "]))) : template$1.statement(_templateObject10$2 || (_templateObject10$2 = _taggedTemplateLiteralLoose(["\n        Object.keys(NAMESPACE).forEach(function(key) {\n          if (key === \"default\" || key === \"__esModule\") return;\n          VERIFY_NAME_LIST;\n          if (key in EXPORTS && EXPORTS[key] === NAMESPACE[key]) return;\n\n          Object.defineProperty(EXPORTS, key, {\n            enumerable: true,\n            get: function() {\n              return NAMESPACE[key];\n            },\n          });\n        });\n    "]))))({
      NAMESPACE: namespace,
      EXPORTS: metadata.exportName,
      VERIFY_NAME_LIST: metadata.exportNameListName ? template$1(_templateObject11$2 || (_templateObject11$2 = _taggedTemplateLiteralLoose(["\n            if (Object.prototype.hasOwnProperty.call(EXPORTS_LIST, key)) return;\n          "])))({
        EXPORTS_LIST: metadata.exportNameListName
      }) : null
    });
  }
  function buildExportNameListDeclaration(programPath, metadata) {
    var exportedVars = Object.create(null);
    for (var _iterator3 = _createForOfIteratorHelperLoose(metadata.local.values()), _step3; !(_step3 = _iterator3()).done;) {
      var data = _step3.value;
      for (var _iterator5 = _createForOfIteratorHelperLoose(data.names), _step5; !(_step5 = _iterator5()).done;) {
        var _name = _step5.value;
        exportedVars[_name] = true;
      }
    }
    var hasReexport = false;
    for (var _iterator4 = _createForOfIteratorHelperLoose(metadata.source.values()), _step4; !(_step4 = _iterator4()).done;) {
      var _data = _step4.value;
      for (var _iterator6 = _createForOfIteratorHelperLoose(_data.reexports.keys()), _step6; !(_step6 = _iterator6()).done;) {
        var exportName = _step6.value;
        exportedVars[exportName] = true;
      }
      for (var _iterator7 = _createForOfIteratorHelperLoose(_data.reexportNamespace), _step7; !(_step7 = _iterator7()).done;) {
        var _exportName = _step7.value;
        exportedVars[_exportName] = true;
      }
      hasReexport = hasReexport || !!_data.reexportAll;
    }
    if (!hasReexport || Object.keys(exportedVars).length === 0) return null;
    var name = programPath.scope.generateUidIdentifier("exportNames");
    delete exportedVars["default"];
    return {
      name: name.name,
      statement: variableDeclaration$6("var", [variableDeclarator$6(name, valueToNode(exportedVars))])
    };
  }
  function buildExportInitializationStatements(programPath, metadata, wrapReference, constantReexports, noIncompleteNsImportDetection) {
    if (constantReexports === void 0) {
      constantReexports = false;
    }
    if (noIncompleteNsImportDetection === void 0) {
      noIncompleteNsImportDetection = false;
    }
    var initStatements = [];
    for (var _iterator8 = _createForOfIteratorHelperLoose(metadata.local), _step8; !(_step8 = _iterator8()).done;) {
      var _step8$value = _slicedToArray(_step8.value, 2),
        localName = _step8$value[0],
        data = _step8$value[1];
      if (data.kind === "import") ; else if (data.kind === "hoisted") {
        initStatements.push([data.names[0], buildInitStatement(metadata, data.names, identifier$d(localName))]);
      } else if (!noIncompleteNsImportDetection) {
        for (var _iterator11 = _createForOfIteratorHelperLoose(data.names), _step11; !(_step11 = _iterator11()).done;) {
          var _exportName2 = _step11.value;
          initStatements.push([_exportName2, null]);
        }
      }
    }
    for (var _iterator9 = _createForOfIteratorHelperLoose(metadata.source.values()), _step9; !(_step9 = _iterator9()).done;) {
      var _data2 = _step9.value;
      if (!constantReexports) {
        var reexportsStatements = buildReexportsFromMeta(metadata, _data2, false, wrapReference);
        var reexports = _toConsumableArray(_data2.reexports.keys());
        for (var _i = 0; _i < reexportsStatements.length; _i++) {
          initStatements.push([reexports[_i], reexportsStatements[_i]]);
        }
      }
      if (!noIncompleteNsImportDetection) {
        for (var _iterator12 = _createForOfIteratorHelperLoose(_data2.reexportNamespace), _step12; !(_step12 = _iterator12()).done;) {
          var _exportName3 = _step12.value;
          initStatements.push([_exportName3, null]);
        }
      }
    }
    initStatements.sort(function (_ref7, _ref8) {
      var _ref9 = _slicedToArray(_ref7, 1),
        a = _ref9[0];
      var _ref10 = _slicedToArray(_ref8, 1),
        b = _ref10[0];
      if (a < b) return -1;
      if (b < a) return 1;
      return 0;
    });
    var results = [];
    if (noIncompleteNsImportDetection) {
      for (var _iterator10 = _createForOfIteratorHelperLoose(initStatements), _step10; !(_step10 = _iterator10()).done;) {
        var _step10$value = _slicedToArray(_step10.value, 2),
          initStatement = _step10$value[1];
        results.push(initStatement);
      }
    } else {
      var chunkSize = 100;
      for (var i = 0; i < initStatements.length; i += chunkSize) {
        var uninitializedExportNames = [];
        for (var j = 0; j < chunkSize && i + j < initStatements.length; j++) {
          var _initStatements = _slicedToArray(initStatements[i + j], 2),
            exportName = _initStatements[0],
            _initStatement = _initStatements[1];
          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: function computed(_ref11) {
      var exports = _ref11.exports,
        name = _ref11.name,
        value = _ref11.value;
      return template$1.expression.ast(_templateObject12$2 || (_templateObject12$2 = _taggedTemplateLiteralLoose(["", "[\"", "\"] = ", ""])), exports, name, value);
    },
    "default": function _default(_ref12) {
      var exports = _ref12.exports,
        name = _ref12.name,
        value = _ref12.value;
      return template$1.expression.ast(_templateObject13$2 || (_templateObject13$2 = _taggedTemplateLiteralLoose(["", ".", " = ", ""])), exports, name, value);
    },
    define: function define(_ref13) {
      var exports = _ref13.exports,
        name = _ref13.name,
        value = _ref13.value;
      return template$1.expression.ast(_templateObject14$2 || (_templateObject14$2 = _taggedTemplateLiteralLoose(["\n      Object.defineProperty(", ", \"", "\", {\n        enumerable: true,\n        value: void 0,\n        writable: true\n      })[\"", "\"] = ", ""])), exports, name, name, value);
    }
  };
  function buildInitStatement(metadata, exportNames, initExpr) {
    var stringSpecifiers = metadata.stringSpecifiers,
      exports = metadata.exportName;
    return expressionStatement$7(exportNames.reduce(function (value, name) {
      var params = {
        exports: exports,
        name: name,
        value: value
      };
      if (name === "__proto__") {
        return InitTemplate.define(params);
      }
      if (stringSpecifiers.has(name)) {
        return InitTemplate.computed(params);
      }
      return InitTemplate["default"](params);
    }, initExpr));
  }

var src$3 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    buildDynamicImport: buildDynamicImport,
    buildNamespaceInitStatements: buildNamespaceInitStatements,
    ensureStatementsHoisted: ensureStatementsHoisted,
    getModuleName: getModuleName$1,
    hasExports: hasExports,
    isModule: isModule,
    isSideEffectImport: isSideEffectImport,
    rewriteModuleStatementsAndPrepareHeader: rewriteModuleStatementsAndPrepareHeader,
    rewriteThis: rewriteThis,
    wrapInterop: wrapInterop
  });

var require$$0$a = /*@__PURE__*/getAugmentedNamespace(src$3);

var getModuleName = function () {
    return require$$0$a.getModuleName;
  };

var _templateObject$B;
  var arrayExpression = arrayExpression$1,
    assignmentExpression$3 = assignmentExpression$8,
    binaryExpression$2 = binaryExpression$4,
    blockStatement$1 = blockStatement$6,
    callExpression$6 = callExpression$c,
    cloneNode$4 = cloneNode$e,
    conditionalExpression$2 = conditionalExpression$5,
    exportNamedDeclaration = exportNamedDeclaration$2,
    exportSpecifier = exportSpecifier$2,
    expressionStatement = expressionStatement$7,
    functionExpression$1 = functionExpression$2,
    identifier$4 = identifier$d,
    memberExpression$5 = memberExpression$9,
    objectExpression$1 = objectExpression$3,
    program = program$3,
    stringLiteral$2 = stringLiteral$6,
    unaryExpression$1 = unaryExpression$4,
    variableDeclaration$1 = variableDeclaration$6,
    variableDeclarator$1 = variableDeclarator$6;
  var buildUmdWrapper = function buildUmdWrapper(replacements) {
    return template$1.statement(_templateObject$B || (_templateObject$B = _taggedTemplateLiteralLoose(["\n    (function (root, factory) {\n      if (typeof define === \"function\" && define.amd) {\n        define(AMD_ARGUMENTS, factory);\n      } else if (typeof exports === \"object\") {\n        factory(COMMON_ARGUMENTS);\n      } else {\n        factory(BROWSER_ARGUMENTS);\n      }\n    })(UMD_ROOT, function (FACTORY_PARAMETERS) {\n      FACTORY_BODY\n    });\n  "])))(replacements);
  };
  function buildGlobal(allowlist) {
    var namespace = identifier$4("babelHelpers");
    var body = [];
    var container = functionExpression$1(null, [identifier$4("global")], blockStatement$1(body));
    var tree = program([expressionStatement(callExpression$6(container, [conditionalExpression$2(binaryExpression$2("===", unaryExpression$1("typeof", identifier$4("global")), stringLiteral$2("undefined")), identifier$4("self"), identifier$4("global"))]))]);
    body.push(variableDeclaration$1("var", [variableDeclarator$1(namespace, assignmentExpression$3("=", memberExpression$5(identifier$4("global"), namespace), objectExpression$1([])))]));
    buildHelpers(body, namespace, allowlist);
    return tree;
  }
  function buildModule(allowlist) {
    var body = [];
    var refs = buildHelpers(body, null, allowlist);
    body.unshift(exportNamedDeclaration(null, Object.keys(refs).map(function (name) {
      return exportSpecifier(cloneNode$4(refs[name]), identifier$4(name));
    })));
    return program(body, [], "module");
  }
  function buildUmd(allowlist) {
    var namespace = identifier$4("babelHelpers");
    var body = [];
    body.push(variableDeclaration$1("var", [variableDeclarator$1(namespace, identifier$4("global"))]));
    buildHelpers(body, namespace, allowlist);
    return program([buildUmdWrapper({
      FACTORY_PARAMETERS: identifier$4("global"),
      BROWSER_ARGUMENTS: assignmentExpression$3("=", memberExpression$5(identifier$4("root"), namespace), objectExpression$1([])),
      COMMON_ARGUMENTS: identifier$4("exports"),
      AMD_ARGUMENTS: arrayExpression([stringLiteral$2("exports")]),
      FACTORY_BODY: body,
      UMD_ROOT: identifier$4("this")
    })]);
  }
  function buildVar(allowlist) {
    var namespace = identifier$4("babelHelpers");
    var body = [];
    body.push(variableDeclaration$1("var", [variableDeclarator$1(namespace, objectExpression$1([]))]));
    var tree = program(body);
    buildHelpers(body, namespace, allowlist);
    body.push(expressionStatement(namespace));
    return tree;
  }
  function buildHelpers(body, namespace, allowlist) {
    var getHelperReference = function getHelperReference(name) {
      return namespace ? memberExpression$5(namespace, identifier$4(name)) : identifier$4("_" + name);
    };
    var refs = {};
    list.forEach(function (name) {
      if (allowlist && !allowlist.includes(name)) return;
      var ref = refs[name] = getHelperReference(name);
      var _helpers$get = get$2(name, getHelperReference, namespace ? null : "_" + name, [], namespace ? function (ast, exportName, mapExportBindingAssignments) {
          mapExportBindingAssignments(function (node) {
            return assignmentExpression$3("=", ref, node);
          });
          ast.body.push(expressionStatement(assignmentExpression$3("=", ref, identifier$4(exportName))));
        } : null),
        nodes = _helpers$get.nodes;
      body.push.apply(body, _toConsumableArray(nodes));
    });
    return refs;
  }
  function babelBuildExternalHelpers (allowlist, outputType) {
    if (outputType === void 0) {
      outputType = "global";
    }
    var tree;
    var build = {
      global: buildGlobal,
      module: buildModule,
      umd: buildUmd,
      "var": buildVar
    }[outputType];
    if (build) {
      tree = build(allowlist);
    } else {
      throw new Error("Unsupported output type " + outputType);
    }
    return generate$1(tree).code;
  }

function getEnv(defaultValue) {
    if (defaultValue === void 0) {
      defaultValue = "development";
    }
    return browser$1$1.env.BABEL_ENV || "production" || defaultValue;
  }

var require$$0$9 = [
  	{
  		name: "nodejs",
  		version: "0.2.0",
  		date: "2011-08-26",
  		lts: false,
  		security: false,
  		v8: "2.3.8.0"
  	},
  	{
  		name: "nodejs",
  		version: "0.3.0",
  		date: "2011-08-26",
  		lts: false,
  		security: false,
  		v8: "2.5.1.0"
  	},
  	{
  		name: "nodejs",
  		version: "0.4.0",
  		date: "2011-08-26",
  		lts: false,
  		security: false,
  		v8: "3.1.2.0"
  	},
  	{
  		name: "nodejs",
  		version: "0.5.0",
  		date: "2011-08-26",
  		lts: false,
  		security: false,
  		v8: "3.1.8.25"
  	},
  	{
  		name: "nodejs",
  		version: "0.6.0",
  		date: "2011-11-04",
  		lts: false,
  		security: false,
  		v8: "3.6.6.6"
  	},
  	{
  		name: "nodejs",
  		version: "0.7.0",
  		date: "2012-01-17",
  		lts: false,
  		security: false,
  		v8: "3.8.6.0"
  	},
  	{
  		name: "nodejs",
  		version: "0.8.0",
  		date: "2012-06-22",
  		lts: false,
  		security: false,
  		v8: "3.11.10.10"
  	},
  	{
  		name: "nodejs",
  		version: "0.9.0",
  		date: "2012-07-20",
  		lts: false,
  		security: false,
  		v8: "3.11.10.15"
  	},
  	{
  		name: "nodejs",
  		version: "0.10.0",
  		date: "2013-03-11",
  		lts: false,
  		security: false,
  		v8: "3.14.5.8"
  	},
  	{
  		name: "nodejs",
  		version: "0.11.0",
  		date: "2013-03-28",
  		lts: false,
  		security: false,
  		v8: "3.17.13.0"
  	},
  	{
  		name: "nodejs",
  		version: "0.12.0",
  		date: "2015-02-06",
  		lts: false,
  		security: false,
  		v8: "3.28.73.0"
  	},
  	{
  		name: "nodejs",
  		version: "4.0.0",
  		date: "2015-09-08",
  		lts: false,
  		security: false,
  		v8: "4.5.103.30"
  	},
  	{
  		name: "nodejs",
  		version: "4.1.0",
  		date: "2015-09-17",
  		lts: false,
  		security: false,
  		v8: "4.5.103.33"
  	},
  	{
  		name: "nodejs",
  		version: "4.2.0",
  		date: "2015-10-12",
  		lts: "Argon",
  		security: false,
  		v8: "4.5.103.35"
  	},
  	{
  		name: "nodejs",
  		version: "4.3.0",
  		date: "2016-02-09",
  		lts: "Argon",
  		security: false,
  		v8: "4.5.103.35"
  	},
  	{
  		name: "nodejs",
  		version: "4.4.0",
  		date: "2016-03-08",
  		lts: "Argon",
  		security: false,
  		v8: "4.5.103.35"
  	},
  	{
  		name: "nodejs",
  		version: "4.5.0",
  		date: "2016-08-16",
  		lts: "Argon",
  		security: false,
  		v8: "4.5.103.37"
  	},
  	{
  		name: "nodejs",
  		version: "4.6.0",
  		date: "2016-09-27",
  		lts: "Argon",
  		security: true,
  		v8: "4.5.103.37"
  	},
  	{
  		name: "nodejs",
  		version: "4.7.0",
  		date: "2016-12-06",
  		lts: "Argon",
  		security: false,
  		v8: "4.5.103.43"
  	},
  	{
  		name: "nodejs",
  		version: "4.8.0",
  		date: "2017-02-21",
  		lts: "Argon",
  		security: false,
  		v8: "4.5.103.45"
  	},
  	{
  		name: "nodejs",
  		version: "4.9.0",
  		date: "2018-03-28",
  		lts: "Argon",
  		security: true,
  		v8: "4.5.103.53"
  	},
  	{
  		name: "nodejs",
  		version: "5.0.0",
  		date: "2015-10-29",
  		lts: false,
  		security: false,
  		v8: "4.6.85.28"
  	},
  	{
  		name: "nodejs",
  		version: "5.1.0",
  		date: "2015-11-17",
  		lts: false,
  		security: false,
  		v8: "4.6.85.31"
  	},
  	{
  		name: "nodejs",
  		version: "5.2.0",
  		date: "2015-12-09",
  		lts: false,
  		security: false,
  		v8: "4.6.85.31"
  	},
  	{
  		name: "nodejs",
  		version: "5.3.0",
  		date: "2015-12-15",
  		lts: false,
  		security: false,
  		v8: "4.6.85.31"
  	},
  	{
  		name: "nodejs",
  		version: "5.4.0",
  		date: "2016-01-06",
  		lts: false,
  		security: false,
  		v8: "4.6.85.31"
  	},
  	{
  		name: "nodejs",
  		version: "5.5.0",
  		date: "2016-01-21",
  		lts: false,
  		security: false,
  		v8: "4.6.85.31"
  	},
  	{
  		name: "nodejs",
  		version: "5.6.0",
  		date: "2016-02-09",
  		lts: false,
  		security: false,
  		v8: "4.6.85.31"
  	},
  	{
  		name: "nodejs",
  		version: "5.7.0",
  		date: "2016-02-23",
  		lts: false,
  		security: false,
  		v8: "4.6.85.31"
  	},
  	{
  		name: "nodejs",
  		version: "5.8.0",
  		date: "2016-03-09",
  		lts: false,
  		security: false,
  		v8: "4.6.85.31"
  	},
  	{
  		name: "nodejs",
  		version: "5.9.0",
  		date: "2016-03-16",
  		lts: false,
  		security: false,
  		v8: "4.6.85.31"
  	},
  	{
  		name: "nodejs",
  		version: "5.10.0",
  		date: "2016-04-01",
  		lts: false,
  		security: false,
  		v8: "4.6.85.31"
  	},
  	{
  		name: "nodejs",
  		version: "5.11.0",
  		date: "2016-04-21",
  		lts: false,
  		security: false,
  		v8: "4.6.85.31"
  	},
  	{
  		name: "nodejs",
  		version: "5.12.0",
  		date: "2016-06-23",
  		lts: false,
  		security: false,
  		v8: "4.6.85.32"
  	},
  	{
  		name: "nodejs",
  		version: "6.0.0",
  		date: "2016-04-26",
  		lts: false,
  		security: false,
  		v8: "5.0.71.35"
  	},
  	{
  		name: "nodejs",
  		version: "6.1.0",
  		date: "2016-05-05",
  		lts: false,
  		security: false,
  		v8: "5.0.71.35"
  	},
  	{
  		name: "nodejs",
  		version: "6.2.0",
  		date: "2016-05-17",
  		lts: false,
  		security: false,
  		v8: "5.0.71.47"
  	},
  	{
  		name: "nodejs",
  		version: "6.3.0",
  		date: "2016-07-06",
  		lts: false,
  		security: false,
  		v8: "5.0.71.52"
  	},
  	{
  		name: "nodejs",
  		version: "6.4.0",
  		date: "2016-08-12",
  		lts: false,
  		security: false,
  		v8: "5.0.71.60"
  	},
  	{
  		name: "nodejs",
  		version: "6.5.0",
  		date: "2016-08-26",
  		lts: false,
  		security: false,
  		v8: "5.1.281.81"
  	},
  	{
  		name: "nodejs",
  		version: "6.6.0",
  		date: "2016-09-14",
  		lts: false,
  		security: false,
  		v8: "5.1.281.83"
  	},
  	{
  		name: "nodejs",
  		version: "6.7.0",
  		date: "2016-09-27",
  		lts: false,
  		security: true,
  		v8: "5.1.281.83"
  	},
  	{
  		name: "nodejs",
  		version: "6.8.0",
  		date: "2016-10-12",
  		lts: false,
  		security: false,
  		v8: "5.1.281.84"
  	},
  	{
  		name: "nodejs",
  		version: "6.9.0",
  		date: "2016-10-18",
  		lts: "Boron",
  		security: false,
  		v8: "5.1.281.84"
  	},
  	{
  		name: "nodejs",
  		version: "6.10.0",
  		date: "2017-02-21",
  		lts: "Boron",
  		security: false,
  		v8: "5.1.281.93"
  	},
  	{
  		name: "nodejs",
  		version: "6.11.0",
  		date: "2017-06-06",
  		lts: "Boron",
  		security: false,
  		v8: "5.1.281.102"
  	},
  	{
  		name: "nodejs",
  		version: "6.12.0",
  		date: "2017-11-06",
  		lts: "Boron",
  		security: false,
  		v8: "5.1.281.108"
  	},
  	{
  		name: "nodejs",
  		version: "6.13.0",
  		date: "2018-02-10",
  		lts: "Boron",
  		security: false,
  		v8: "5.1.281.111"
  	},
  	{
  		name: "nodejs",
  		version: "6.14.0",
  		date: "2018-03-28",
  		lts: "Boron",
  		security: true,
  		v8: "5.1.281.111"
  	},
  	{
  		name: "nodejs",
  		version: "6.15.0",
  		date: "2018-11-27",
  		lts: "Boron",
  		security: true,
  		v8: "5.1.281.111"
  	},
  	{
  		name: "nodejs",
  		version: "6.16.0",
  		date: "2018-12-26",
  		lts: "Boron",
  		security: false,
  		v8: "5.1.281.111"
  	},
  	{
  		name: "nodejs",
  		version: "6.17.0",
  		date: "2019-02-28",
  		lts: "Boron",
  		security: true,
  		v8: "5.1.281.111"
  	},
  	{
  		name: "nodejs",
  		version: "7.0.0",
  		date: "2016-10-25",
  		lts: false,
  		security: false,
  		v8: "5.4.500.36"
  	},
  	{
  		name: "nodejs",
  		version: "7.1.0",
  		date: "2016-11-08",
  		lts: false,
  		security: false,
  		v8: "5.4.500.36"
  	},
  	{
  		name: "nodejs",
  		version: "7.2.0",
  		date: "2016-11-22",
  		lts: false,
  		security: false,
  		v8: "5.4.500.43"
  	},
  	{
  		name: "nodejs",
  		version: "7.3.0",
  		date: "2016-12-20",
  		lts: false,
  		security: false,
  		v8: "5.4.500.45"
  	},
  	{
  		name: "nodejs",
  		version: "7.4.0",
  		date: "2017-01-04",
  		lts: false,
  		security: false,
  		v8: "5.4.500.45"
  	},
  	{
  		name: "nodejs",
  		version: "7.5.0",
  		date: "2017-01-31",
  		lts: false,
  		security: false,
  		v8: "5.4.500.48"
  	},
  	{
  		name: "nodejs",
  		version: "7.6.0",
  		date: "2017-02-21",
  		lts: false,
  		security: false,
  		v8: "5.5.372.40"
  	},
  	{
  		name: "nodejs",
  		version: "7.7.0",
  		date: "2017-02-28",
  		lts: false,
  		security: false,
  		v8: "5.5.372.41"
  	},
  	{
  		name: "nodejs",
  		version: "7.8.0",
  		date: "2017-03-29",
  		lts: false,
  		security: false,
  		v8: "5.5.372.43"
  	},
  	{
  		name: "nodejs",
  		version: "7.9.0",
  		date: "2017-04-11",
  		lts: false,
  		security: false,
  		v8: "5.5.372.43"
  	},
  	{
  		name: "nodejs",
  		version: "7.10.0",
  		date: "2017-05-02",
  		lts: false,
  		security: false,
  		v8: "5.5.372.43"
  	},
  	{
  		name: "nodejs",
  		version: "8.0.0",
  		date: "2017-05-30",
  		lts: false,
  		security: false,
  		v8: "5.8.283.41"
  	},
  	{
  		name: "nodejs",
  		version: "8.1.0",
  		date: "2017-06-08",
  		lts: false,
  		security: false,
  		v8: "5.8.283.41"
  	},
  	{
  		name: "nodejs",
  		version: "8.2.0",
  		date: "2017-07-19",
  		lts: false,
  		security: false,
  		v8: "5.8.283.41"
  	},
  	{
  		name: "nodejs",
  		version: "8.3.0",
  		date: "2017-08-08",
  		lts: false,
  		security: false,
  		v8: "6.0.286.52"
  	},
  	{
  		name: "nodejs",
  		version: "8.4.0",
  		date: "2017-08-15",
  		lts: false,
  		security: false,
  		v8: "6.0.286.52"
  	},
  	{
  		name: "nodejs",
  		version: "8.5.0",
  		date: "2017-09-12",
  		lts: false,
  		security: false,
  		v8: "6.0.287.53"
  	},
  	{
  		name: "nodejs",
  		version: "8.6.0",
  		date: "2017-09-26",
  		lts: false,
  		security: false,
  		v8: "6.0.287.53"
  	},
  	{
  		name: "nodejs",
  		version: "8.7.0",
  		date: "2017-10-11",
  		lts: false,
  		security: false,
  		v8: "6.1.534.42"
  	},
  	{
  		name: "nodejs",
  		version: "8.8.0",
  		date: "2017-10-24",
  		lts: false,
  		security: false,
  		v8: "6.1.534.42"
  	},
  	{
  		name: "nodejs",
  		version: "8.9.0",
  		date: "2017-10-31",
  		lts: "Carbon",
  		security: false,
  		v8: "6.1.534.46"
  	},
  	{
  		name: "nodejs",
  		version: "8.10.0",
  		date: "2018-03-06",
  		lts: "Carbon",
  		security: false,
  		v8: "6.2.414.50"
  	},
  	{
  		name: "nodejs",
  		version: "8.11.0",
  		date: "2018-03-28",
  		lts: "Carbon",
  		security: true,
  		v8: "6.2.414.50"
  	},
  	{
  		name: "nodejs",
  		version: "8.12.0",
  		date: "2018-09-10",
  		lts: "Carbon",
  		security: false,
  		v8: "6.2.414.66"
  	},
  	{
  		name: "nodejs",
  		version: "8.13.0",
  		date: "2018-11-20",
  		lts: "Carbon",
  		security: false,
  		v8: "6.2.414.72"
  	},
  	{
  		name: "nodejs",
  		version: "8.14.0",
  		date: "2018-11-27",
  		lts: "Carbon",
  		security: true,
  		v8: "6.2.414.72"
  	},
  	{
  		name: "nodejs",
  		version: "8.15.0",
  		date: "2018-12-26",
  		lts: "Carbon",
  		security: false,
  		v8: "6.2.414.75"
  	},
  	{
  		name: "nodejs",
  		version: "8.16.0",
  		date: "2019-04-16",
  		lts: "Carbon",
  		security: false,
  		v8: "6.2.414.77"
  	},
  	{
  		name: "nodejs",
  		version: "8.17.0",
  		date: "2019-12-17",
  		lts: "Carbon",
  		security: true,
  		v8: "6.2.414.78"
  	},
  	{
  		name: "nodejs",
  		version: "9.0.0",
  		date: "2017-10-31",
  		lts: false,
  		security: false,
  		v8: "6.2.414.32"
  	},
  	{
  		name: "nodejs",
  		version: "9.1.0",
  		date: "2017-11-07",
  		lts: false,
  		security: false,
  		v8: "6.2.414.32"
  	},
  	{
  		name: "nodejs",
  		version: "9.2.0",
  		date: "2017-11-14",
  		lts: false,
  		security: false,
  		v8: "6.2.414.44"
  	},
  	{
  		name: "nodejs",
  		version: "9.3.0",
  		date: "2017-12-12",
  		lts: false,
  		security: false,
  		v8: "6.2.414.46"
  	},
  	{
  		name: "nodejs",
  		version: "9.4.0",
  		date: "2018-01-10",
  		lts: false,
  		security: false,
  		v8: "6.2.414.46"
  	},
  	{
  		name: "nodejs",
  		version: "9.5.0",
  		date: "2018-01-31",
  		lts: false,
  		security: false,
  		v8: "6.2.414.46"
  	},
  	{
  		name: "nodejs",
  		version: "9.6.0",
  		date: "2018-02-21",
  		lts: false,
  		security: false,
  		v8: "6.2.414.46"
  	},
  	{
  		name: "nodejs",
  		version: "9.7.0",
  		date: "2018-03-01",
  		lts: false,
  		security: false,
  		v8: "6.2.414.46"
  	},
  	{
  		name: "nodejs",
  		version: "9.8.0",
  		date: "2018-03-07",
  		lts: false,
  		security: false,
  		v8: "6.2.414.46"
  	},
  	{
  		name: "nodejs",
  		version: "9.9.0",
  		date: "2018-03-21",
  		lts: false,
  		security: false,
  		v8: "6.2.414.46"
  	},
  	{
  		name: "nodejs",
  		version: "9.10.0",
  		date: "2018-03-28",
  		lts: false,
  		security: true,
  		v8: "6.2.414.46"
  	},
  	{
  		name: "nodejs",
  		version: "9.11.0",
  		date: "2018-04-04",
  		lts: false,
  		security: false,
  		v8: "6.2.414.46"
  	},
  	{
  		name: "nodejs",
  		version: "10.0.0",
  		date: "2018-04-24",
  		lts: false,
  		security: false,
  		v8: "6.6.346.24"
  	},
  	{
  		name: "nodejs",
  		version: "10.1.0",
  		date: "2018-05-08",
  		lts: false,
  		security: false,
  		v8: "6.6.346.27"
  	},
  	{
  		name: "nodejs",
  		version: "10.2.0",
  		date: "2018-05-23",
  		lts: false,
  		security: false,
  		v8: "6.6.346.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.3.0",
  		date: "2018-05-29",
  		lts: false,
  		security: false,
  		v8: "6.6.346.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.4.0",
  		date: "2018-06-06",
  		lts: false,
  		security: false,
  		v8: "6.7.288.43"
  	},
  	{
  		name: "nodejs",
  		version: "10.5.0",
  		date: "2018-06-20",
  		lts: false,
  		security: false,
  		v8: "6.7.288.46"
  	},
  	{
  		name: "nodejs",
  		version: "10.6.0",
  		date: "2018-07-04",
  		lts: false,
  		security: false,
  		v8: "6.7.288.46"
  	},
  	{
  		name: "nodejs",
  		version: "10.7.0",
  		date: "2018-07-18",
  		lts: false,
  		security: false,
  		v8: "6.7.288.49"
  	},
  	{
  		name: "nodejs",
  		version: "10.8.0",
  		date: "2018-08-01",
  		lts: false,
  		security: false,
  		v8: "6.7.288.49"
  	},
  	{
  		name: "nodejs",
  		version: "10.9.0",
  		date: "2018-08-15",
  		lts: false,
  		security: false,
  		v8: "6.8.275.24"
  	},
  	{
  		name: "nodejs",
  		version: "10.10.0",
  		date: "2018-09-06",
  		lts: false,
  		security: false,
  		v8: "6.8.275.30"
  	},
  	{
  		name: "nodejs",
  		version: "10.11.0",
  		date: "2018-09-19",
  		lts: false,
  		security: false,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.12.0",
  		date: "2018-10-10",
  		lts: false,
  		security: false,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.13.0",
  		date: "2018-10-30",
  		lts: "Dubnium",
  		security: false,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.14.0",
  		date: "2018-11-27",
  		lts: "Dubnium",
  		security: true,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.15.0",
  		date: "2018-12-26",
  		lts: "Dubnium",
  		security: false,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.16.0",
  		date: "2019-05-28",
  		lts: "Dubnium",
  		security: false,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.17.0",
  		date: "2019-10-22",
  		lts: "Dubnium",
  		security: false,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.18.0",
  		date: "2019-12-17",
  		lts: "Dubnium",
  		security: true,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.19.0",
  		date: "2020-02-05",
  		lts: "Dubnium",
  		security: true,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.20.0",
  		date: "2020-03-26",
  		lts: "Dubnium",
  		security: false,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.21.0",
  		date: "2020-06-02",
  		lts: "Dubnium",
  		security: true,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.22.0",
  		date: "2020-07-21",
  		lts: "Dubnium",
  		security: false,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.23.0",
  		date: "2020-10-27",
  		lts: "Dubnium",
  		security: false,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "10.24.0",
  		date: "2021-02-23",
  		lts: "Dubnium",
  		security: true,
  		v8: "6.8.275.32"
  	},
  	{
  		name: "nodejs",
  		version: "11.0.0",
  		date: "2018-10-23",
  		lts: false,
  		security: false,
  		v8: "7.0.276.28"
  	},
  	{
  		name: "nodejs",
  		version: "11.1.0",
  		date: "2018-10-30",
  		lts: false,
  		security: false,
  		v8: "7.0.276.32"
  	},
  	{
  		name: "nodejs",
  		version: "11.2.0",
  		date: "2018-11-15",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.3.0",
  		date: "2018-11-27",
  		lts: false,
  		security: true,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.4.0",
  		date: "2018-12-07",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.5.0",
  		date: "2018-12-18",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.6.0",
  		date: "2018-12-26",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.7.0",
  		date: "2019-01-17",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.8.0",
  		date: "2019-01-24",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.9.0",
  		date: "2019-01-30",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.10.0",
  		date: "2019-02-14",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.11.0",
  		date: "2019-03-05",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.12.0",
  		date: "2019-03-14",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.13.0",
  		date: "2019-03-28",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.14.0",
  		date: "2019-04-10",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "11.15.0",
  		date: "2019-04-30",
  		lts: false,
  		security: false,
  		v8: "7.0.276.38"
  	},
  	{
  		name: "nodejs",
  		version: "12.0.0",
  		date: "2019-04-23",
  		lts: false,
  		security: false,
  		v8: "7.4.288.21"
  	},
  	{
  		name: "nodejs",
  		version: "12.1.0",
  		date: "2019-04-29",
  		lts: false,
  		security: false,
  		v8: "7.4.288.21"
  	},
  	{
  		name: "nodejs",
  		version: "12.2.0",
  		date: "2019-05-07",
  		lts: false,
  		security: false,
  		v8: "7.4.288.21"
  	},
  	{
  		name: "nodejs",
  		version: "12.3.0",
  		date: "2019-05-21",
  		lts: false,
  		security: false,
  		v8: "7.4.288.27"
  	},
  	{
  		name: "nodejs",
  		version: "12.4.0",
  		date: "2019-06-04",
  		lts: false,
  		security: false,
  		v8: "7.4.288.27"
  	},
  	{
  		name: "nodejs",
  		version: "12.5.0",
  		date: "2019-06-26",
  		lts: false,
  		security: false,
  		v8: "7.5.288.22"
  	},
  	{
  		name: "nodejs",
  		version: "12.6.0",
  		date: "2019-07-03",
  		lts: false,
  		security: false,
  		v8: "7.5.288.22"
  	},
  	{
  		name: "nodejs",
  		version: "12.7.0",
  		date: "2019-07-23",
  		lts: false,
  		security: false,
  		v8: "7.5.288.22"
  	},
  	{
  		name: "nodejs",
  		version: "12.8.0",
  		date: "2019-08-06",
  		lts: false,
  		security: false,
  		v8: "7.5.288.22"
  	},
  	{
  		name: "nodejs",
  		version: "12.9.0",
  		date: "2019-08-20",
  		lts: false,
  		security: false,
  		v8: "7.6.303.29"
  	},
  	{
  		name: "nodejs",
  		version: "12.10.0",
  		date: "2019-09-04",
  		lts: false,
  		security: false,
  		v8: "7.6.303.29"
  	},
  	{
  		name: "nodejs",
  		version: "12.11.0",
  		date: "2019-09-25",
  		lts: false,
  		security: false,
  		v8: "7.7.299.11"
  	},
  	{
  		name: "nodejs",
  		version: "12.12.0",
  		date: "2019-10-11",
  		lts: false,
  		security: false,
  		v8: "7.7.299.13"
  	},
  	{
  		name: "nodejs",
  		version: "12.13.0",
  		date: "2019-10-21",
  		lts: "Erbium",
  		security: false,
  		v8: "7.7.299.13"
  	},
  	{
  		name: "nodejs",
  		version: "12.14.0",
  		date: "2019-12-17",
  		lts: "Erbium",
  		security: true,
  		v8: "7.7.299.13"
  	},
  	{
  		name: "nodejs",
  		version: "12.15.0",
  		date: "2020-02-05",
  		lts: "Erbium",
  		security: true,
  		v8: "7.7.299.13"
  	},
  	{
  		name: "nodejs",
  		version: "12.16.0",
  		date: "2020-02-11",
  		lts: "Erbium",
  		security: false,
  		v8: "7.8.279.23"
  	},
  	{
  		name: "nodejs",
  		version: "12.17.0",
  		date: "2020-05-26",
  		lts: "Erbium",
  		security: false,
  		v8: "7.8.279.23"
  	},
  	{
  		name: "nodejs",
  		version: "12.18.0",
  		date: "2020-06-02",
  		lts: "Erbium",
  		security: true,
  		v8: "7.8.279.23"
  	},
  	{
  		name: "nodejs",
  		version: "12.19.0",
  		date: "2020-10-06",
  		lts: "Erbium",
  		security: false,
  		v8: "7.8.279.23"
  	},
  	{
  		name: "nodejs",
  		version: "12.20.0",
  		date: "2020-11-24",
  		lts: "Erbium",
  		security: false,
  		v8: "7.8.279.23"
  	},
  	{
  		name: "nodejs",
  		version: "12.21.0",
  		date: "2021-02-23",
  		lts: "Erbium",
  		security: true,
  		v8: "7.8.279.23"
  	},
  	{
  		name: "nodejs",
  		version: "12.22.0",
  		date: "2021-03-30",
  		lts: "Erbium",
  		security: false,
  		v8: "7.8.279.23"
  	},
  	{
  		name: "nodejs",
  		version: "13.0.0",
  		date: "2019-10-22",
  		lts: false,
  		security: false,
  		v8: "7.8.279.17"
  	},
  	{
  		name: "nodejs",
  		version: "13.1.0",
  		date: "2019-11-05",
  		lts: false,
  		security: false,
  		v8: "7.8.279.17"
  	},
  	{
  		name: "nodejs",
  		version: "13.2.0",
  		date: "2019-11-21",
  		lts: false,
  		security: false,
  		v8: "7.9.317.23"
  	},
  	{
  		name: "nodejs",
  		version: "13.3.0",
  		date: "2019-12-03",
  		lts: false,
  		security: false,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "13.4.0",
  		date: "2019-12-17",
  		lts: false,
  		security: true,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "13.5.0",
  		date: "2019-12-18",
  		lts: false,
  		security: false,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "13.6.0",
  		date: "2020-01-07",
  		lts: false,
  		security: false,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "13.7.0",
  		date: "2020-01-21",
  		lts: false,
  		security: false,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "13.8.0",
  		date: "2020-02-05",
  		lts: false,
  		security: true,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "13.9.0",
  		date: "2020-02-18",
  		lts: false,
  		security: false,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "13.10.0",
  		date: "2020-03-04",
  		lts: false,
  		security: false,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "13.11.0",
  		date: "2020-03-12",
  		lts: false,
  		security: false,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "13.12.0",
  		date: "2020-03-26",
  		lts: false,
  		security: false,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "13.13.0",
  		date: "2020-04-14",
  		lts: false,
  		security: false,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "13.14.0",
  		date: "2020-04-29",
  		lts: false,
  		security: false,
  		v8: "7.9.317.25"
  	},
  	{
  		name: "nodejs",
  		version: "14.0.0",
  		date: "2020-04-21",
  		lts: false,
  		security: false,
  		v8: "8.1.307.30"
  	},
  	{
  		name: "nodejs",
  		version: "14.1.0",
  		date: "2020-04-29",
  		lts: false,
  		security: false,
  		v8: "8.1.307.31"
  	},
  	{
  		name: "nodejs",
  		version: "14.2.0",
  		date: "2020-05-05",
  		lts: false,
  		security: false,
  		v8: "8.1.307.31"
  	},
  	{
  		name: "nodejs",
  		version: "14.3.0",
  		date: "2020-05-19",
  		lts: false,
  		security: false,
  		v8: "8.1.307.31"
  	},
  	{
  		name: "nodejs",
  		version: "14.4.0",
  		date: "2020-06-02",
  		lts: false,
  		security: true,
  		v8: "8.1.307.31"
  	},
  	{
  		name: "nodejs",
  		version: "14.5.0",
  		date: "2020-06-30",
  		lts: false,
  		security: false,
  		v8: "8.3.110.9"
  	},
  	{
  		name: "nodejs",
  		version: "14.6.0",
  		date: "2020-07-20",
  		lts: false,
  		security: false,
  		v8: "8.4.371.19"
  	},
  	{
  		name: "nodejs",
  		version: "14.7.0",
  		date: "2020-07-29",
  		lts: false,
  		security: false,
  		v8: "8.4.371.19"
  	},
  	{
  		name: "nodejs",
  		version: "14.8.0",
  		date: "2020-08-11",
  		lts: false,
  		security: false,
  		v8: "8.4.371.19"
  	},
  	{
  		name: "nodejs",
  		version: "14.9.0",
  		date: "2020-08-27",
  		lts: false,
  		security: false,
  		v8: "8.4.371.19"
  	},
  	{
  		name: "nodejs",
  		version: "14.10.0",
  		date: "2020-09-08",
  		lts: false,
  		security: false,
  		v8: "8.4.371.19"
  	},
  	{
  		name: "nodejs",
  		version: "14.11.0",
  		date: "2020-09-15",
  		lts: false,
  		security: true,
  		v8: "8.4.371.19"
  	},
  	{
  		name: "nodejs",
  		version: "14.12.0",
  		date: "2020-09-22",
  		lts: false,
  		security: false,
  		v8: "8.4.371.19"
  	},
  	{
  		name: "nodejs",
  		version: "14.13.0",
  		date: "2020-09-29",
  		lts: false,
  		security: false,
  		v8: "8.4.371.19"
  	},
  	{
  		name: "nodejs",
  		version: "14.14.0",
  		date: "2020-10-15",
  		lts: false,
  		security: false,
  		v8: "8.4.371.19"
  	},
  	{
  		name: "nodejs",
  		version: "14.15.0",
  		date: "2020-10-27",
  		lts: "Fermium",
  		security: false,
  		v8: "8.4.371.19"
  	},
  	{
  		name: "nodejs",
  		version: "14.16.0",
  		date: "2021-02-23",
  		lts: "Fermium",
  		security: true,
  		v8: "8.4.371.19"
  	},
  	{
  		name: "nodejs",
  		version: "14.17.0",
  		date: "2021-05-11",
  		lts: "Fermium",
  		security: false,
  		v8: "8.4.371.23"
  	},
  	{
  		name: "nodejs",
  		version: "14.18.0",
  		date: "2021-09-28",
  		lts: "Fermium",
  		security: false,
  		v8: "8.4.371.23"
  	},
  	{
  		name: "nodejs",
  		version: "14.19.0",
  		date: "2022-02-01",
  		lts: "Fermium",
  		security: false,
  		v8: "8.4.371.23"
  	},
  	{
  		name: "nodejs",
  		version: "14.20.0",
  		date: "2022-07-07",
  		lts: "Fermium",
  		security: true,
  		v8: "8.4.371.23"
  	},
  	{
  		name: "nodejs",
  		version: "14.21.0",
  		date: "2022-11-01",
  		lts: "Fermium",
  		security: false,
  		v8: "8.4.371.23"
  	},
  	{
  		name: "nodejs",
  		version: "15.0.0",
  		date: "2020-10-20",
  		lts: false,
  		security: false,
  		v8: "8.6.395.16"
  	},
  	{
  		name: "nodejs",
  		version: "15.1.0",
  		date: "2020-11-04",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.2.0",
  		date: "2020-11-10",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.3.0",
  		date: "2020-11-24",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.4.0",
  		date: "2020-12-09",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.5.0",
  		date: "2020-12-22",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.6.0",
  		date: "2021-01-14",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.7.0",
  		date: "2021-01-25",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.8.0",
  		date: "2021-02-02",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.9.0",
  		date: "2021-02-18",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.10.0",
  		date: "2021-02-23",
  		lts: false,
  		security: true,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.11.0",
  		date: "2021-03-03",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.12.0",
  		date: "2021-03-17",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.13.0",
  		date: "2021-03-31",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "15.14.0",
  		date: "2021-04-06",
  		lts: false,
  		security: false,
  		v8: "8.6.395.17"
  	},
  	{
  		name: "nodejs",
  		version: "16.0.0",
  		date: "2021-04-20",
  		lts: false,
  		security: false,
  		v8: "9.0.257.17"
  	},
  	{
  		name: "nodejs",
  		version: "16.1.0",
  		date: "2021-05-04",
  		lts: false,
  		security: false,
  		v8: "9.0.257.24"
  	},
  	{
  		name: "nodejs",
  		version: "16.2.0",
  		date: "2021-05-19",
  		lts: false,
  		security: false,
  		v8: "9.0.257.25"
  	},
  	{
  		name: "nodejs",
  		version: "16.3.0",
  		date: "2021-06-03",
  		lts: false,
  		security: false,
  		v8: "9.0.257.25"
  	},
  	{
  		name: "nodejs",
  		version: "16.4.0",
  		date: "2021-06-23",
  		lts: false,
  		security: false,
  		v8: "9.1.269.36"
  	},
  	{
  		name: "nodejs",
  		version: "16.5.0",
  		date: "2021-07-14",
  		lts: false,
  		security: false,
  		v8: "9.1.269.38"
  	},
  	{
  		name: "nodejs",
  		version: "16.6.0",
  		date: "2021-07-29",
  		lts: false,
  		security: true,
  		v8: "9.2.230.21"
  	},
  	{
  		name: "nodejs",
  		version: "16.7.0",
  		date: "2021-08-18",
  		lts: false,
  		security: false,
  		v8: "9.2.230.21"
  	},
  	{
  		name: "nodejs",
  		version: "16.8.0",
  		date: "2021-08-25",
  		lts: false,
  		security: false,
  		v8: "9.2.230.21"
  	},
  	{
  		name: "nodejs",
  		version: "16.9.0",
  		date: "2021-09-07",
  		lts: false,
  		security: false,
  		v8: "9.3.345.16"
  	},
  	{
  		name: "nodejs",
  		version: "16.10.0",
  		date: "2021-09-22",
  		lts: false,
  		security: false,
  		v8: "9.3.345.19"
  	},
  	{
  		name: "nodejs",
  		version: "16.11.0",
  		date: "2021-10-08",
  		lts: false,
  		security: false,
  		v8: "9.4.146.19"
  	},
  	{
  		name: "nodejs",
  		version: "16.12.0",
  		date: "2021-10-20",
  		lts: false,
  		security: false,
  		v8: "9.4.146.19"
  	},
  	{
  		name: "nodejs",
  		version: "16.13.0",
  		date: "2021-10-26",
  		lts: "Gallium",
  		security: false,
  		v8: "9.4.146.19"
  	},
  	{
  		name: "nodejs",
  		version: "16.14.0",
  		date: "2022-02-08",
  		lts: "Gallium",
  		security: false,
  		v8: "9.4.146.24"
  	},
  	{
  		name: "nodejs",
  		version: "16.15.0",
  		date: "2022-04-26",
  		lts: "Gallium",
  		security: false,
  		v8: "9.4.146.24"
  	},
  	{
  		name: "nodejs",
  		version: "16.16.0",
  		date: "2022-07-07",
  		lts: "Gallium",
  		security: true,
  		v8: "9.4.146.24"
  	},
  	{
  		name: "nodejs",
  		version: "16.17.0",
  		date: "2022-08-16",
  		lts: "Gallium",
  		security: false,
  		v8: "9.4.146.26"
  	},
  	{
  		name: "nodejs",
  		version: "16.18.0",
  		date: "2022-10-12",
  		lts: "Gallium",
  		security: false,
  		v8: "9.4.146.26"
  	},
  	{
  		name: "nodejs",
  		version: "16.19.0",
  		date: "2022-12-13",
  		lts: "Gallium",
  		security: false,
  		v8: "9.4.146.26"
  	},
  	{
  		name: "nodejs",
  		version: "16.20.0",
  		date: "2023-03-28",
  		lts: "Gallium",
  		security: false,
  		v8: "9.4.146.26"
  	},
  	{
  		name: "nodejs",
  		version: "17.0.0",
  		date: "2021-10-19",
  		lts: false,
  		security: false,
  		v8: "9.5.172.21"
  	},
  	{
  		name: "nodejs",
  		version: "17.1.0",
  		date: "2021-11-09",
  		lts: false,
  		security: false,
  		v8: "9.5.172.25"
  	},
  	{
  		name: "nodejs",
  		version: "17.2.0",
  		date: "2021-11-30",
  		lts: false,
  		security: false,
  		v8: "9.6.180.14"
  	},
  	{
  		name: "nodejs",
  		version: "17.3.0",
  		date: "2021-12-17",
  		lts: false,
  		security: false,
  		v8: "9.6.180.15"
  	},
  	{
  		name: "nodejs",
  		version: "17.4.0",
  		date: "2022-01-18",
  		lts: false,
  		security: false,
  		v8: "9.6.180.15"
  	},
  	{
  		name: "nodejs",
  		version: "17.5.0",
  		date: "2022-02-10",
  		lts: false,
  		security: false,
  		v8: "9.6.180.15"
  	},
  	{
  		name: "nodejs",
  		version: "17.6.0",
  		date: "2022-02-22",
  		lts: false,
  		security: false,
  		v8: "9.6.180.15"
  	},
  	{
  		name: "nodejs",
  		version: "17.7.0",
  		date: "2022-03-09",
  		lts: false,
  		security: false,
  		v8: "9.6.180.15"
  	},
  	{
  		name: "nodejs",
  		version: "17.8.0",
  		date: "2022-03-22",
  		lts: false,
  		security: false,
  		v8: "9.6.180.15"
  	},
  	{
  		name: "nodejs",
  		version: "17.9.0",
  		date: "2022-04-07",
  		lts: false,
  		security: false,
  		v8: "9.6.180.15"
  	},
  	{
  		name: "nodejs",
  		version: "18.0.0",
  		date: "2022-04-18",
  		lts: false,
  		security: false,
  		v8: "10.1.124.8"
  	},
  	{
  		name: "nodejs",
  		version: "18.1.0",
  		date: "2022-05-03",
  		lts: false,
  		security: false,
  		v8: "10.1.124.8"
  	},
  	{
  		name: "nodejs",
  		version: "18.2.0",
  		date: "2022-05-17",
  		lts: false,
  		security: false,
  		v8: "10.1.124.8"
  	},
  	{
  		name: "nodejs",
  		version: "18.3.0",
  		date: "2022-06-02",
  		lts: false,
  		security: false,
  		v8: "10.2.154.4"
  	},
  	{
  		name: "nodejs",
  		version: "18.4.0",
  		date: "2022-06-16",
  		lts: false,
  		security: false,
  		v8: "10.2.154.4"
  	},
  	{
  		name: "nodejs",
  		version: "18.5.0",
  		date: "2022-07-06",
  		lts: false,
  		security: true,
  		v8: "10.2.154.4"
  	},
  	{
  		name: "nodejs",
  		version: "18.6.0",
  		date: "2022-07-13",
  		lts: false,
  		security: false,
  		v8: "10.2.154.13"
  	},
  	{
  		name: "nodejs",
  		version: "18.7.0",
  		date: "2022-07-26",
  		lts: false,
  		security: false,
  		v8: "10.2.154.13"
  	},
  	{
  		name: "nodejs",
  		version: "18.8.0",
  		date: "2022-08-24",
  		lts: false,
  		security: false,
  		v8: "10.2.154.13"
  	},
  	{
  		name: "nodejs",
  		version: "18.9.0",
  		date: "2022-09-07",
  		lts: false,
  		security: false,
  		v8: "10.2.154.15"
  	},
  	{
  		name: "nodejs",
  		version: "18.10.0",
  		date: "2022-09-28",
  		lts: false,
  		security: false,
  		v8: "10.2.154.15"
  	},
  	{
  		name: "nodejs",
  		version: "18.11.0",
  		date: "2022-10-13",
  		lts: false,
  		security: false,
  		v8: "10.2.154.15"
  	},
  	{
  		name: "nodejs",
  		version: "18.12.0",
  		date: "2022-10-25",
  		lts: "Hydrogen",
  		security: false,
  		v8: "10.2.154.15"
  	},
  	{
  		name: "nodejs",
  		version: "18.13.0",
  		date: "2023-01-05",
  		lts: "Hydrogen",
  		security: false,
  		v8: "10.2.154.23"
  	},
  	{
  		name: "nodejs",
  		version: "18.14.0",
  		date: "2023-02-01",
  		lts: "Hydrogen",
  		security: false,
  		v8: "10.2.154.23"
  	},
  	{
  		name: "nodejs",
  		version: "18.15.0",
  		date: "2023-03-05",
  		lts: "Hydrogen",
  		security: false,
  		v8: "10.2.154.26"
  	},
  	{
  		name: "nodejs",
  		version: "18.16.0",
  		date: "2023-04-12",
  		lts: "Hydrogen",
  		security: false,
  		v8: "10.2.154.26"
  	},
  	{
  		name: "nodejs",
  		version: "18.17.0",
  		date: "2023-07-18",
  		lts: "Hydrogen",
  		security: false,
  		v8: "10.2.154.26"
  	},
  	{
  		name: "nodejs",
  		version: "18.18.0",
  		date: "2023-09-18",
  		lts: "Hydrogen",
  		security: false,
  		v8: "10.2.154.26"
  	},
  	{
  		name: "nodejs",
  		version: "18.19.0",
  		date: "2023-11-29",
  		lts: "Hydrogen",
  		security: false,
  		v8: "10.2.154.26"
  	},
  	{
  		name: "nodejs",
  		version: "18.20.0",
  		date: "2024-03-26",
  		lts: "Hydrogen",
  		security: false,
  		v8: "10.2.154.26"
  	},
  	{
  		name: "nodejs",
  		version: "19.0.0",
  		date: "2022-10-17",
  		lts: false,
  		security: false,
  		v8: "10.7.193.13"
  	},
  	{
  		name: "nodejs",
  		version: "19.1.0",
  		date: "2022-11-14",
  		lts: false,
  		security: false,
  		v8: "10.7.193.20"
  	},
  	{
  		name: "nodejs",
  		version: "19.2.0",
  		date: "2022-11-29",
  		lts: false,
  		security: false,
  		v8: "10.8.168.20"
  	},
  	{
  		name: "nodejs",
  		version: "19.3.0",
  		date: "2022-12-14",
  		lts: false,
  		security: false,
  		v8: "10.8.168.21"
  	},
  	{
  		name: "nodejs",
  		version: "19.4.0",
  		date: "2023-01-05",
  		lts: false,
  		security: false,
  		v8: "10.8.168.25"
  	},
  	{
  		name: "nodejs",
  		version: "19.5.0",
  		date: "2023-01-24",
  		lts: false,
  		security: false,
  		v8: "10.8.168.25"
  	},
  	{
  		name: "nodejs",
  		version: "19.6.0",
  		date: "2023-02-01",
  		lts: false,
  		security: false,
  		v8: "10.8.168.25"
  	},
  	{
  		name: "nodejs",
  		version: "19.7.0",
  		date: "2023-02-21",
  		lts: false,
  		security: false,
  		v8: "10.8.168.25"
  	},
  	{
  		name: "nodejs",
  		version: "19.8.0",
  		date: "2023-03-14",
  		lts: false,
  		security: false,
  		v8: "10.8.168.25"
  	},
  	{
  		name: "nodejs",
  		version: "19.9.0",
  		date: "2023-04-10",
  		lts: false,
  		security: false,
  		v8: "10.8.168.25"
  	},
  	{
  		name: "nodejs",
  		version: "20.0.0",
  		date: "2023-04-17",
  		lts: false,
  		security: false,
  		v8: "11.3.244.4"
  	},
  	{
  		name: "nodejs",
  		version: "20.1.0",
  		date: "2023-05-03",
  		lts: false,
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.2.0",
  		date: "2023-05-16",
  		lts: false,
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.3.0",
  		date: "2023-06-08",
  		lts: false,
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.4.0",
  		date: "2023-07-04",
  		lts: false,
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.5.0",
  		date: "2023-07-19",
  		lts: false,
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.6.0",
  		date: "2023-08-23",
  		lts: false,
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.7.0",
  		date: "2023-09-18",
  		lts: false,
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.8.0",
  		date: "2023-09-28",
  		lts: false,
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.9.0",
  		date: "2023-10-24",
  		lts: "Iron",
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.10.0",
  		date: "2023-11-22",
  		lts: "Iron",
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.11.0",
  		date: "2024-01-09",
  		lts: "Iron",
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.12.0",
  		date: "2024-03-26",
  		lts: "Iron",
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.13.0",
  		date: "2024-05-07",
  		lts: "Iron",
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.14.0",
  		date: "2024-05-28",
  		lts: "Iron",
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "20.15.0",
  		date: "2024-06-20",
  		lts: "Iron",
  		security: false,
  		v8: "11.3.244.8"
  	},
  	{
  		name: "nodejs",
  		version: "21.0.0",
  		date: "2023-10-17",
  		lts: false,
  		security: false,
  		v8: "11.8.172.13"
  	},
  	{
  		name: "nodejs",
  		version: "21.1.0",
  		date: "2023-10-24",
  		lts: false,
  		security: false,
  		v8: "11.8.172.15"
  	},
  	{
  		name: "nodejs",
  		version: "21.2.0",
  		date: "2023-11-14",
  		lts: false,
  		security: false,
  		v8: "11.8.172.17"
  	},
  	{
  		name: "nodejs",
  		version: "21.3.0",
  		date: "2023-11-30",
  		lts: false,
  		security: false,
  		v8: "11.8.172.17"
  	},
  	{
  		name: "nodejs",
  		version: "21.4.0",
  		date: "2023-12-05",
  		lts: false,
  		security: false,
  		v8: "11.8.172.17"
  	},
  	{
  		name: "nodejs",
  		version: "21.5.0",
  		date: "2023-12-19",
  		lts: false,
  		security: false,
  		v8: "11.8.172.17"
  	},
  	{
  		name: "nodejs",
  		version: "21.6.0",
  		date: "2024-01-14",
  		lts: false,
  		security: false,
  		v8: "11.8.172.17"
  	},
  	{
  		name: "nodejs",
  		version: "21.7.0",
  		date: "2024-03-06",
  		lts: false,
  		security: false,
  		v8: "11.8.172.17"
  	},
  	{
  		name: "nodejs",
  		version: "22.0.0",
  		date: "2024-04-24",
  		lts: false,
  		security: false,
  		v8: "12.4.254.14"
  	},
  	{
  		name: "nodejs",
  		version: "22.1.0",
  		date: "2024-05-02",
  		lts: false,
  		security: false,
  		v8: "12.4.254.14"
  	},
  	{
  		name: "nodejs",
  		version: "22.2.0",
  		date: "2024-05-15",
  		lts: false,
  		security: false,
  		v8: "12.4.254.14"
  	},
  	{
  		name: "nodejs",
  		version: "22.3.0",
  		date: "2024-06-11",
  		lts: false,
  		security: false,
  		v8: "12.4.254.20"
  	},
  	{
  		name: "nodejs",
  		version: "22.4.0",
  		date: "2024-07-02",
  		lts: false,
  		security: false,
  		v8: "12.4.254.21"
  	},
  	{
  		name: "nodejs",
  		version: "22.5.0",
  		date: "2024-07-17",
  		lts: false,
  		security: false,
  		v8: "12.4.254.21"
  	}
  ];

var agents$2 = {};

var browsers$2 = {};

var browsers$1 = {
    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"
  };

browsers$2.browsers = browsers$1;

var browserVersions$1 = {};

var browserVersions = {
    "0": "24",
    "1": "25",
    "2": "112",
    "3": "113",
    "4": "114",
    "5": "115",
    "6": "116",
    "7": "117",
    "8": "118",
    "9": "119",
    A: "10",
    B: "11",
    C: "12",
    D: "7",
    E: "8",
    F: "9",
    G: "15",
    H: "80",
    I: "128",
    J: "4",
    K: "6",
    L: "13",
    M: "14",
    N: "16",
    O: "17",
    P: "18",
    Q: "79",
    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: "96",
    g: "97",
    h: "98",
    i: "99",
    j: "100",
    k: "101",
    l: "102",
    m: "103",
    n: "104",
    o: "105",
    p: "106",
    q: "107",
    r: "108",
    s: "109",
    t: "110",
    u: "111",
    v: "127",
    w: "20",
    x: "21",
    y: "22",
    z: "23",
    AB: "120",
    BB: "121",
    CB: "122",
    DB: "123",
    EB: "124",
    FB: "125",
    GB: "126",
    HB: "5",
    IB: "19",
    JB: "26",
    KB: "27",
    LB: "28",
    MB: "29",
    NB: "30",
    OB: "31",
    PB: "32",
    QB: "33",
    RB: "34",
    SB: "35",
    TB: "36",
    UB: "37",
    VB: "38",
    WB: "39",
    XB: "40",
    YB: "41",
    ZB: "42",
    aB: "43",
    bB: "44",
    cB: "45",
    dB: "46",
    eB: "47",
    fB: "48",
    gB: "49",
    hB: "50",
    iB: "51",
    jB: "52",
    kB: "53",
    lB: "54",
    mB: "55",
    nB: "56",
    oB: "57",
    pB: "58",
    qB: "60",
    rB: "62",
    sB: "63",
    tB: "64",
    uB: "65",
    vB: "66",
    wB: "67",
    xB: "68",
    yB: "69",
    zB: "70",
    "0B": "71",
    "1B": "72",
    "2B": "73",
    "3B": "74",
    "4B": "75",
    "5B": "76",
    "6B": "77",
    "7B": "78",
    "8B": "11.1",
    "9B": "12.1",
    AC: "15.5",
    BC: "16.0",
    CC: "17.0",
    DC: "18.0",
    EC: "3",
    FC: "59",
    GC: "61",
    HC: "82",
    IC: "129",
    JC: "130",
    KC: "131",
    LC: "132",
    MC: "3.2",
    NC: "10.1",
    OC: "15.2-15.3",
    PC: "15.4",
    QC: "16.1",
    RC: "16.2",
    SC: "16.3",
    TC: "16.4",
    UC: "16.5",
    VC: "17.1",
    WC: "17.2",
    XC: "17.3",
    YC: "17.4",
    ZC: "17.5",
    aC: "17.6",
    bC: "18.1",
    cC: "11.5",
    dC: "4.2-4.3",
    eC: "5.5",
    fC: "2",
    gC: "133",
    hC: "3.5",
    iC: "3.6",
    jC: "3.1",
    kC: "5.1",
    lC: "6.1",
    mC: "7.1",
    nC: "9.1",
    oC: "13.1",
    pC: "14.1",
    qC: "15.1",
    rC: "15.6",
    sC: "16.6",
    tC: "TP",
    uC: "9.5-9.6",
    vC: "10.0-10.1",
    wC: "10.5",
    xC: "10.6",
    yC: "11.6",
    zC: "4.0-4.1",
    "0C": "5.0-5.1",
    "1C": "6.0-6.1",
    "2C": "7.0-7.1",
    "3C": "8.1-8.4",
    "4C": "9.0-9.2",
    "5C": "9.3",
    "6C": "10.0-10.2",
    "7C": "10.3",
    "8C": "11.0-11.2",
    "9C": "11.3-11.4",
    AD: "12.0-12.1",
    BD: "12.2-12.5",
    CD: "13.0-13.1",
    DD: "13.2",
    ED: "13.3",
    FD: "13.4-13.7",
    GD: "14.0-14.4",
    HD: "14.5-14.8",
    ID: "15.0-15.1",
    JD: "15.6-15.8",
    KD: "16.6-16.7",
    LD: "all",
    MD: "2.1",
    ND: "2.2",
    OD: "2.3",
    PD: "4.1",
    QD: "4.4",
    RD: "4.4.3-4.4.4",
    SD: "5.0-5.4",
    TD: "6.2-6.4",
    UD: "7.2-7.4",
    VD: "8.2",
    WD: "9.2",
    XD: "11.1-11.2",
    YD: "12.0",
    ZD: "13.0",
    aD: "14.0",
    bD: "15.0",
    cD: "19.0",
    dD: "14.9",
    eD: "13.52",
    fD: "2.5",
    gD: "3.0-3.1"
  };

browserVersions$1.browserVersions = browserVersions;

var agents$1 = {
    A: {
      A: {
        K: 0,
        D: 0,
        E: 0.0563043,
        F: 0.0422282,
        A: 0.0140761,
        B: 0.478586,
        eC: 0
      },
      B: "ms",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "eC", "K", "D", "E", "F", "A", "B", "", "", ""],
      E: "IE",
      F: {
        eC: 962323200,
        K: 998870400,
        D: 1161129600,
        E: 1237420800,
        F: 1300060800,
        A: 1346716800,
        B: 1381968000
      }
    },
    B: {
      A: {
        "2": 0.007166,
        "3": 0.010749,
        "4": 0.014332,
        "5": 0.007166,
        "6": 0.007166,
        "7": 0.010749,
        "8": 0.007166,
        "9": 0.010749,
        C: 0,
        L: 0,
        M: 0.003583,
        G: 0,
        N: 0,
        O: 0.007166,
        P: 0.057328,
        Q: 0,
        H: 0,
        R: 0,
        S: 0,
        T: 0,
        U: 0,
        V: 0,
        W: 0,
        X: 0,
        Y: 0,
        Z: 0,
        a: 0,
        b: 0.014332,
        c: 0,
        d: 0,
        e: 0,
        f: 0,
        g: 0,
        h: 0,
        i: 0,
        j: 0,
        k: 0,
        l: 0,
        m: 0,
        n: 0,
        o: 0,
        p: 0,
        q: 0.003583,
        r: 0.007166,
        s: 0.064494,
        t: 0.007166,
        u: 0.007166,
        AB: 0.039413,
        BB: 0.017915,
        CB: 0.025081,
        DB: 0.014332,
        EB: 0.025081,
        FB: 0.053745,
        GB: 0.254393,
        v: 3.38594,
        I: 0.917248
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "C", "L", "M", "G", "N", "O", "P", "Q", "H", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "2", "3", "4", "5", "6", "7", "8", "9", "AB", "BB", "CB", "DB", "EB", "FB", "GB", "v", "I", "", "", ""],
      E: "Edge",
      F: {
        "2": 1680825600,
        "3": 1683158400,
        "4": 1685664000,
        "5": 1689897600,
        "6": 1692576000,
        "7": 1694649600,
        "8": 1697155200,
        "9": 1698969600,
        C: 1438128000,
        L: 1447286400,
        M: 1470096000,
        G: 1491868800,
        N: 1508198400,
        O: 1525046400,
        P: 1542067200,
        Q: 1579046400,
        H: 1581033600,
        R: 1586736000,
        S: 1590019200,
        T: 1594857600,
        U: 1598486400,
        V: 1602201600,
        W: 1605830400,
        X: 1611360000,
        Y: 1614816000,
        Z: 1618358400,
        a: 1622073600,
        b: 1626912000,
        c: 1630627200,
        d: 1632441600,
        e: 1634774400,
        f: 1637539200,
        g: 1641427200,
        h: 1643932800,
        i: 1646265600,
        j: 1649635200,
        k: 1651190400,
        l: 1653955200,
        m: 1655942400,
        n: 1659657600,
        o: 1661990400,
        p: 1664755200,
        q: 1666915200,
        r: 1670198400,
        s: 1673481600,
        t: 1675900800,
        u: 1678665600,
        AB: 1701993600,
        BB: 1706227200,
        CB: 1708732800,
        DB: 1711152000,
        EB: 1713398400,
        FB: 1715990400,
        GB: 1718841600,
        v: 1721865600,
        I: 1724371200
      },
      D: {
        C: "ms",
        L: "ms",
        M: "ms",
        G: "ms",
        N: "ms",
        O: "ms",
        P: "ms"
      }
    },
    C: {
      A: {
        "0": 0,
        "1": 0,
        "2": 0,
        "3": 0.007166,
        "4": 0,
        "5": 0.351134,
        "6": 0,
        "7": 0.007166,
        "8": 0.089575,
        "9": 0,
        fC: 0,
        EC: 0,
        J: 0.003583,
        HB: 0,
        K: 0,
        D: 0,
        E: 0,
        F: 0,
        A: 0,
        B: 0.014332,
        C: 0,
        L: 0,
        M: 0,
        G: 0,
        N: 0,
        O: 0,
        P: 0,
        IB: 0,
        w: 0,
        x: 0,
        y: 0,
        z: 0,
        JB: 0,
        KB: 0,
        LB: 0,
        MB: 0,
        NB: 0,
        OB: 0,
        PB: 0,
        QB: 0,
        RB: 0,
        SB: 0,
        TB: 0,
        UB: 0,
        VB: 0,
        WB: 0,
        XB: 0,
        YB: 0,
        ZB: 0,
        aB: 0.003583,
        bB: 0.007166,
        cB: 0.003583,
        dB: 0,
        eB: 0,
        fB: 0,
        gB: 0,
        hB: 0.003583,
        iB: 0,
        jB: 0.042996,
        kB: 0,
        lB: 0.007166,
        mB: 0.003583,
        nB: 0.017915,
        oB: 0,
        pB: 0,
        FC: 0.003583,
        qB: 0,
        GC: 0,
        rB: 0,
        sB: 0,
        tB: 0,
        uB: 0,
        vB: 0,
        wB: 0,
        xB: 0,
        yB: 0,
        zB: 0,
        "0B": 0,
        "1B": 0,
        "2B": 0,
        "3B": 0,
        "4B": 0,
        "5B": 0,
        "6B": 0,
        "7B": 0.014332,
        Q: 0,
        H: 0,
        R: 0,
        HC: 0,
        S: 0,
        T: 0,
        U: 0,
        V: 0,
        W: 0,
        X: 0.007166,
        Y: 0,
        Z: 0,
        a: 0,
        b: 0,
        c: 0,
        d: 0.003583,
        e: 0,
        f: 0,
        g: 0,
        h: 0,
        i: 0,
        j: 0,
        k: 0,
        l: 0.007166,
        m: 0.010749,
        n: 0,
        o: 0.003583,
        p: 0,
        q: 0,
        r: 0,
        s: 0.007166,
        t: 0,
        u: 0,
        AB: 0.007166,
        BB: 0.007166,
        CB: 0.003583,
        DB: 0.007166,
        EB: 0.007166,
        FB: 0.014332,
        GB: 0.032247,
        v: 0.042996,
        I: 0.447875,
        IC: 1.08923,
        JC: 0.007166,
        KC: 0,
        LC: 0,
        gC: 0,
        hC: 0,
        iC: 0
      },
      B: "moz",
      C: ["fC", "EC", "hC", "iC", "J", "HB", "K", "D", "E", "F", "A", "B", "C", "L", "M", "G", "N", "O", "P", "IB", "w", "x", "y", "z", "0", "1", "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", "nB", "oB", "pB", "FC", "qB", "GC", "rB", "sB", "tB", "uB", "vB", "wB", "xB", "yB", "zB", "0B", "1B", "2B", "3B", "4B", "5B", "6B", "7B", "Q", "H", "R", "HC", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "2", "3", "4", "5", "6", "7", "8", "9", "AB", "BB", "CB", "DB", "EB", "FB", "GB", "v", "I", "IC", "JC", "KC", "LC", "gC"],
      E: "Firefox",
      F: {
        "0": 1375747200,
        "1": 1379376000,
        "2": 1681171200,
        "3": 1683590400,
        "4": 1686009600,
        "5": 1688428800,
        "6": 1690848000,
        "7": 1693267200,
        "8": 1695686400,
        "9": 1698105600,
        fC: 1161648000,
        EC: 1213660800,
        hC: 1246320000,
        iC: 1264032000,
        J: 1300752000,
        HB: 1308614400,
        K: 1313452800,
        D: 1317081600,
        E: 1317081600,
        F: 1320710400,
        A: 1324339200,
        B: 1327968000,
        C: 1331596800,
        L: 1335225600,
        M: 1338854400,
        G: 1342483200,
        N: 1346112000,
        O: 1349740800,
        P: 1353628800,
        IB: 1357603200,
        w: 1361232000,
        x: 1364860800,
        y: 1368489600,
        z: 1372118400,
        JB: 1386633600,
        KB: 1391472000,
        LB: 1395100800,
        MB: 1398729600,
        NB: 1402358400,
        OB: 1405987200,
        PB: 1409616000,
        QB: 1413244800,
        RB: 1417392000,
        SB: 1421107200,
        TB: 1424736000,
        UB: 1428278400,
        VB: 1431475200,
        WB: 1435881600,
        XB: 1439251200,
        YB: 1442880000,
        ZB: 1446508800,
        aB: 1450137600,
        bB: 1453852800,
        cB: 1457395200,
        dB: 1461628800,
        eB: 1465257600,
        fB: 1470096000,
        gB: 1474329600,
        hB: 1479168000,
        iB: 1485216000,
        jB: 1488844800,
        kB: 1492560000,
        lB: 1497312000,
        mB: 1502150400,
        nB: 1506556800,
        oB: 1510617600,
        pB: 1516665600,
        FC: 1520985600,
        qB: 1525824000,
        GC: 1529971200,
        rB: 1536105600,
        sB: 1540252800,
        tB: 1544486400,
        uB: 1548720000,
        vB: 1552953600,
        wB: 1558396800,
        xB: 1562630400,
        yB: 1567468800,
        zB: 1571788800,
        "0B": 1575331200,
        "1B": 1578355200,
        "2B": 1581379200,
        "3B": 1583798400,
        "4B": 1586304000,
        "5B": 1588636800,
        "6B": 1591056000,
        "7B": 1593475200,
        Q: 1595894400,
        H: 1598313600,
        R: 1600732800,
        HC: 1603152000,
        S: 1605571200,
        T: 1607990400,
        U: 1611619200,
        V: 1614038400,
        W: 1616457600,
        X: 1618790400,
        Y: 1622505600,
        Z: 1626134400,
        a: 1628553600,
        b: 1630972800,
        c: 1633392000,
        d: 1635811200,
        e: 1638835200,
        f: 1641859200,
        g: 1644364800,
        h: 1646697600,
        i: 1649116800,
        j: 1651536000,
        k: 1653955200,
        l: 1656374400,
        m: 1658793600,
        n: 1661212800,
        o: 1663632000,
        p: 1666051200,
        q: 1668470400,
        r: 1670889600,
        s: 1673913600,
        t: 1676332800,
        u: 1678752000,
        AB: 1700524800,
        BB: 1702944000,
        CB: 1705968000,
        DB: 1708387200,
        EB: 1710806400,
        FB: 1713225600,
        GB: 1715644800,
        v: 1718064000,
        I: 1720483200,
        IC: 1722902400,
        JC: 1725321600,
        KC: null,
        LC: null,
        gC: null
      }
    },
    D: {
      A: {
        "0": 0,
        "1": 0,
        "2": 0.050162,
        "3": 0.10749,
        "4": 0.103907,
        "5": 0.03583,
        "6": 0.168401,
        "7": 0.10749,
        "8": 0.07166,
        "9": 0.068077,
        J: 0,
        HB: 0,
        K: 0,
        D: 0,
        E: 0,
        F: 0,
        A: 0,
        B: 0,
        C: 0,
        L: 0,
        M: 0,
        G: 0,
        N: 0,
        O: 0,
        P: 0,
        IB: 0,
        w: 0,
        x: 0,
        y: 0,
        z: 0,
        JB: 0,
        KB: 0,
        LB: 0,
        MB: 0,
        NB: 0,
        OB: 0,
        PB: 0,
        QB: 0,
        RB: 0,
        SB: 0,
        TB: 0,
        UB: 0,
        VB: 0.010749,
        WB: 0,
        XB: 0,
        YB: 0,
        ZB: 0,
        aB: 0,
        bB: 0,
        cB: 0.003583,
        dB: 0,
        eB: 0.007166,
        fB: 0.025081,
        gB: 0.021498,
        hB: 0.007166,
        iB: 0.003583,
        jB: 0.003583,
        kB: 0.007166,
        lB: 0,
        mB: 0,
        nB: 0.032247,
        oB: 0.003583,
        pB: 0.007166,
        FC: 0,
        qB: 0,
        GC: 0.003583,
        rB: 0,
        sB: 0,
        tB: 0,
        uB: 0,
        vB: 0.025081,
        wB: 0.007166,
        xB: 0,
        yB: 0.028664,
        zB: 0.028664,
        "0B": 0,
        "1B": 0,
        "2B": 0.007166,
        "3B": 0.010749,
        "4B": 0.010749,
        "5B": 0.007166,
        "6B": 0.021498,
        "7B": 0.017915,
        Q: 0.103907,
        H: 0.014332,
        R: 0.021498,
        S: 0.032247,
        T: 0.010749,
        U: 0.014332,
        V: 0.025081,
        W: 0.075243,
        X: 0.017915,
        Y: 0.010749,
        Z: 0.014332,
        a: 0.053745,
        b: 0.014332,
        c: 0.014332,
        d: 0.050162,
        e: 0.010749,
        f: 0.010749,
        g: 0.017915,
        h: 0.046579,
        i: 0.025081,
        j: 0.021498,
        k: 0.021498,
        l: 0.017915,
        m: 0.111073,
        n: 0.085992,
        o: 0.017915,
        p: 0.028664,
        q: 0.03583,
        r: 0.046579,
        s: 1.42603,
        t: 0.025081,
        u: 0.039413,
        AB: 0.10749,
        BB: 0.10749,
        CB: 0.118239,
        DB: 0.14332,
        EB: 0.229312,
        FB: 0.369049,
        GB: 1.49053,
        v: 12.777,
        I: 2.30745,
        IC: 0.014332,
        JC: 0.003583,
        KC: 0,
        LC: 0
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "J", "HB", "K", "D", "E", "F", "A", "B", "C", "L", "M", "G", "N", "O", "P", "IB", "w", "x", "y", "z", "0", "1", "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", "nB", "oB", "pB", "FC", "qB", "GC", "rB", "sB", "tB", "uB", "vB", "wB", "xB", "yB", "zB", "0B", "1B", "2B", "3B", "4B", "5B", "6B", "7B", "Q", "H", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "2", "3", "4", "5", "6", "7", "8", "9", "AB", "BB", "CB", "DB", "EB", "FB", "GB", "v", "I", "IC", "JC", "KC", "LC"],
      E: "Chrome",
      F: {
        "0": 1352246400,
        "1": 1357862400,
        "2": 1680566400,
        "3": 1682985600,
        "4": 1685404800,
        "5": 1689724800,
        "6": 1692057600,
        "7": 1694476800,
        "8": 1696896000,
        "9": 1698710400,
        J: 1264377600,
        HB: 1274745600,
        K: 1283385600,
        D: 1287619200,
        E: 1291248000,
        F: 1296777600,
        A: 1299542400,
        B: 1303862400,
        C: 1307404800,
        L: 1312243200,
        M: 1316131200,
        G: 1316131200,
        N: 1319500800,
        O: 1323734400,
        P: 1328659200,
        IB: 1332892800,
        w: 1337040000,
        x: 1340668800,
        y: 1343692800,
        z: 1348531200,
        JB: 1361404800,
        KB: 1364428800,
        LB: 1369094400,
        MB: 1374105600,
        NB: 1376956800,
        OB: 1384214400,
        PB: 1389657600,
        QB: 1392940800,
        RB: 1397001600,
        SB: 1400544000,
        TB: 1405468800,
        UB: 1409011200,
        VB: 1412640000,
        WB: 1416268800,
        XB: 1421798400,
        YB: 1425513600,
        ZB: 1429401600,
        aB: 1432080000,
        bB: 1437523200,
        cB: 1441152000,
        dB: 1444780800,
        eB: 1449014400,
        fB: 1453248000,
        gB: 1456963200,
        hB: 1460592000,
        iB: 1464134400,
        jB: 1469059200,
        kB: 1472601600,
        lB: 1476230400,
        mB: 1480550400,
        nB: 1485302400,
        oB: 1489017600,
        pB: 1492560000,
        FC: 1496707200,
        qB: 1500940800,
        GC: 1504569600,
        rB: 1508198400,
        sB: 1512518400,
        tB: 1516752000,
        uB: 1520294400,
        vB: 1523923200,
        wB: 1527552000,
        xB: 1532390400,
        yB: 1536019200,
        zB: 1539648000,
        "0B": 1543968000,
        "1B": 1548720000,
        "2B": 1552348800,
        "3B": 1555977600,
        "4B": 1559606400,
        "5B": 1564444800,
        "6B": 1568073600,
        "7B": 1571702400,
        Q: 1575936000,
        H: 1580860800,
        R: 1586304000,
        S: 1589846400,
        T: 1594684800,
        U: 1598313600,
        V: 1601942400,
        W: 1605571200,
        X: 1611014400,
        Y: 1614556800,
        Z: 1618272000,
        a: 1621987200,
        b: 1626739200,
        c: 1630368000,
        d: 1632268800,
        e: 1634601600,
        f: 1637020800,
        g: 1641340800,
        h: 1643673600,
        i: 1646092800,
        j: 1648512000,
        k: 1650931200,
        l: 1653350400,
        m: 1655769600,
        n: 1659398400,
        o: 1661817600,
        p: 1664236800,
        q: 1666656000,
        r: 1669680000,
        s: 1673308800,
        t: 1675728000,
        u: 1678147200,
        AB: 1701993600,
        BB: 1705968000,
        CB: 1708387200,
        DB: 1710806400,
        EB: 1713225600,
        FB: 1715644800,
        GB: 1718064000,
        v: 1721174400,
        I: 1724112000,
        IC: 1726531200,
        JC: null,
        KC: null,
        LC: null
      }
    },
    E: {
      A: {
        J: 0,
        HB: 0,
        K: 0,
        D: 0,
        E: 0,
        F: 0.003583,
        A: 0,
        B: 0,
        C: 0,
        L: 0.007166,
        M: 0.028664,
        G: 0.007166,
        jC: 0,
        MC: 0,
        kC: 0,
        lC: 0,
        mC: 0,
        nC: 0,
        NC: 0,
        "8B": 0.007166,
        "9B": 0.010749,
        oC: 0.057328,
        pC: 0.078826,
        qC: 0.025081,
        OC: 0.010749,
        PC: 0.021498,
        AC: 0.028664,
        rC: 0.218563,
        BC: 0.028664,
        QC: 0.03583,
        RC: 0.032247,
        SC: 0.182733,
        TC: 0.021498,
        UC: 0.042996,
        sC: 0.290223,
        CC: 0.017915,
        VC: 0.039413,
        WC: 0.039413,
        XC: 0.042996,
        YC: 0.118239,
        ZC: 1.44753,
        aC: 0.415628,
        DC: 0.017915,
        bC: 0,
        tC: 0
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "jC", "MC", "J", "HB", "kC", "K", "lC", "D", "mC", "E", "F", "nC", "A", "NC", "B", "8B", "C", "9B", "L", "oC", "M", "pC", "G", "qC", "OC", "PC", "AC", "rC", "BC", "QC", "RC", "SC", "TC", "UC", "sC", "CC", "VC", "WC", "XC", "YC", "ZC", "aC", "DC", "bC", "tC", ""],
      E: "Safari",
      F: {
        jC: 1205798400,
        MC: 1226534400,
        J: 1244419200,
        HB: 1275868800,
        kC: 1311120000,
        K: 1343174400,
        lC: 1382400000,
        D: 1382400000,
        mC: 1410998400,
        E: 1413417600,
        F: 1443657600,
        nC: 1458518400,
        A: 1474329600,
        NC: 1490572800,
        B: 1505779200,
        "8B": 1522281600,
        C: 1537142400,
        "9B": 1553472000,
        L: 1568851200,
        oC: 1585008000,
        M: 1600214400,
        pC: 1619395200,
        G: 1632096000,
        qC: 1635292800,
        OC: 1639353600,
        PC: 1647216000,
        AC: 1652745600,
        rC: 1658275200,
        BC: 1662940800,
        QC: 1666569600,
        RC: 1670889600,
        SC: 1674432000,
        TC: 1679875200,
        UC: 1684368000,
        sC: 1690156800,
        CC: 1695686400,
        VC: 1698192000,
        WC: 1702252800,
        XC: 1705881600,
        YC: 1709596800,
        ZC: 1715558400,
        aC: 1722211200,
        DC: 1726444800,
        bC: null,
        tC: null
      }
    },
    F: {
      A: {
        "0": 0,
        "1": 0,
        F: 0,
        B: 0,
        C: 0,
        G: 0,
        N: 0,
        O: 0,
        P: 0,
        IB: 0,
        w: 0,
        x: 0,
        y: 0,
        z: 0,
        JB: 0,
        KB: 0,
        LB: 0,
        MB: 0,
        NB: 0,
        OB: 0,
        PB: 0,
        QB: 0,
        RB: 0,
        SB: 0,
        TB: 0,
        UB: 0,
        VB: 0,
        WB: 0,
        XB: 0.003583,
        YB: 0,
        ZB: 0,
        aB: 0,
        bB: 0,
        cB: 0,
        dB: 0.017915,
        eB: 0,
        fB: 0,
        gB: 0,
        hB: 0,
        iB: 0,
        jB: 0,
        kB: 0,
        lB: 0,
        mB: 0,
        nB: 0,
        oB: 0,
        pB: 0,
        qB: 0,
        rB: 0,
        sB: 0,
        tB: 0,
        uB: 0,
        vB: 0,
        wB: 0,
        xB: 0,
        yB: 0,
        zB: 0,
        "0B": 0,
        "1B": 0,
        "2B": 0,
        "3B": 0,
        "4B": 0,
        "5B": 0,
        "6B": 0,
        "7B": 0,
        Q: 0,
        H: 0,
        R: 0,
        HC: 0,
        S: 0.028664,
        T: 0.003583,
        U: 0,
        V: 0,
        W: 0,
        X: 0,
        Y: 0,
        Z: 0,
        a: 0,
        b: 0,
        c: 0,
        d: 0,
        e: 0.039413,
        f: 0,
        g: 0,
        h: 0,
        i: 0,
        j: 0,
        k: 0,
        l: 0.032247,
        m: 0,
        n: 0,
        o: 0,
        p: 0,
        q: 0,
        r: 0,
        s: 0.154069,
        t: 0,
        u: 0.060911,
        uC: 0,
        vC: 0,
        wC: 0,
        xC: 0,
        "8B": 0,
        cC: 0,
        yC: 0,
        "9B": 0
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "F", "uC", "vC", "wC", "xC", "B", "8B", "cC", "yC", "C", "9B", "G", "N", "O", "P", "IB", "w", "x", "y", "z", "0", "1", "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", "nB", "oB", "pB", "qB", "rB", "sB", "tB", "uB", "vB", "wB", "xB", "yB", "zB", "0B", "1B", "2B", "3B", "4B", "5B", "6B", "7B", "Q", "H", "R", "HC", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "", "", ""],
      E: "Opera",
      F: {
        "0": 1409616000,
        "1": 1413331200,
        F: 1150761600,
        uC: 1223424000,
        vC: 1251763200,
        wC: 1267488000,
        xC: 1277942400,
        B: 1292457600,
        "8B": 1302566400,
        cC: 1309219200,
        yC: 1323129600,
        C: 1323129600,
        "9B": 1352073600,
        G: 1372723200,
        N: 1377561600,
        O: 1381104000,
        P: 1386288000,
        IB: 1390867200,
        w: 1393891200,
        x: 1399334400,
        y: 1401753600,
        z: 1405987200,
        JB: 1417132800,
        KB: 1422316800,
        LB: 1425945600,
        MB: 1430179200,
        NB: 1433808000,
        OB: 1438646400,
        PB: 1442448000,
        QB: 1445904000,
        RB: 1449100800,
        SB: 1454371200,
        TB: 1457308800,
        UB: 1462320000,
        VB: 1465344000,
        WB: 1470096000,
        XB: 1474329600,
        YB: 1477267200,
        ZB: 1481587200,
        aB: 1486425600,
        bB: 1490054400,
        cB: 1494374400,
        dB: 1498003200,
        eB: 1502236800,
        fB: 1506470400,
        gB: 1510099200,
        hB: 1515024000,
        iB: 1517961600,
        jB: 1521676800,
        kB: 1525910400,
        lB: 1530144000,
        mB: 1534982400,
        nB: 1537833600,
        oB: 1543363200,
        pB: 1548201600,
        qB: 1554768000,
        rB: 1561593600,
        sB: 1566259200,
        tB: 1570406400,
        uB: 1573689600,
        vB: 1578441600,
        wB: 1583971200,
        xB: 1587513600,
        yB: 1592956800,
        zB: 1595894400,
        "0B": 1600128000,
        "1B": 1603238400,
        "2B": 1613520000,
        "3B": 1612224000,
        "4B": 1616544000,
        "5B": 1619568000,
        "6B": 1623715200,
        "7B": 1627948800,
        Q: 1631577600,
        H: 1633392000,
        R: 1635984000,
        HC: 1638403200,
        S: 1642550400,
        T: 1644969600,
        U: 1647993600,
        V: 1650412800,
        W: 1652745600,
        X: 1654646400,
        Y: 1657152000,
        Z: 1660780800,
        a: 1663113600,
        b: 1668816000,
        c: 1668643200,
        d: 1671062400,
        e: 1675209600,
        f: 1677024000,
        g: 1679529600,
        h: 1681948800,
        i: 1684195200,
        j: 1687219200,
        k: 1690329600,
        l: 1692748800,
        m: 1696204800,
        n: 1699920000,
        o: 1699920000,
        p: 1702944000,
        q: 1707264000,
        r: 1710115200,
        s: 1711497600,
        t: 1716336000,
        u: 1719273600
      },
      D: {
        F: "o",
        B: "o",
        C: "o",
        uC: "o",
        vC: "o",
        wC: "o",
        xC: "o",
        "8B": "o",
        cC: "o",
        yC: "o",
        "9B": "o"
      }
    },
    G: {
      A: {
        E: 0,
        MC: 0,
        zC: 0,
        dC: 0.00447708,
        "0C": 0.00149236,
        "1C": 0.00746181,
        "2C": 0.00895417,
        "3C": 0,
        "4C": 0.00746181,
        "5C": 0.0298472,
        "6C": 0.00895417,
        "7C": 0.0462632,
        "8C": 0.117897,
        "9C": 0.0149236,
        AD: 0.0119389,
        BD: 0.199976,
        CD: 0.00298472,
        DD: 0.0656639,
        ED: 0.00895417,
        FD: 0.037309,
        GD: 0.152221,
        HD: 0.105958,
        ID: 0.0567097,
        OC: 0.0567097,
        PC: 0.0671563,
        AC: 0.0790952,
        JD: 0.741704,
        BC: 0.150729,
        QC: 0.317873,
        RC: 0.15819,
        SC: 0.264148,
        TC: 0.0656639,
        UC: 0.10745,
        KD: 0.920787,
        CC: 0.0850646,
        VC: 0.131328,
        WC: 0.120881,
        XC: 0.179083,
        YC: 0.419354,
        ZC: 8.55869,
        aC: 1.44162,
        DC: 0.156698,
        bC: 0
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "MC", "zC", "dC", "0C", "1C", "2C", "E", "3C", "4C", "5C", "6C", "7C", "8C", "9C", "AD", "BD", "CD", "DD", "ED", "FD", "GD", "HD", "ID", "OC", "PC", "AC", "JD", "BC", "QC", "RC", "SC", "TC", "UC", "KD", "CC", "VC", "WC", "XC", "YC", "ZC", "aC", "DC", "bC", "", ""],
      E: "Safari on iOS",
      F: {
        MC: 1270252800,
        zC: 1283904000,
        dC: 1299628800,
        "0C": 1331078400,
        "1C": 1359331200,
        "2C": 1394409600,
        E: 1410912000,
        "3C": 1413763200,
        "4C": 1442361600,
        "5C": 1458518400,
        "6C": 1473724800,
        "7C": 1490572800,
        "8C": 1505779200,
        "9C": 1522281600,
        AD: 1537142400,
        BD: 1553472000,
        CD: 1568851200,
        DD: 1572220800,
        ED: 1580169600,
        FD: 1585008000,
        GD: 1600214400,
        HD: 1619395200,
        ID: 1632096000,
        OC: 1639353600,
        PC: 1647216000,
        AC: 1652659200,
        JD: 1658275200,
        BC: 1662940800,
        QC: 1666569600,
        RC: 1670889600,
        SC: 1674432000,
        TC: 1679875200,
        UC: 1684368000,
        KD: 1690156800,
        CC: 1694995200,
        VC: 1698192000,
        WC: 1702252800,
        XC: 1705881600,
        YC: 1709596800,
        ZC: 1715558400,
        aC: 1722211200,
        DC: 1726444800,
        bC: null
      }
    },
    H: {
      A: {
        LD: 0.05
      },
      B: "o",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "LD", "", "", ""],
      E: "Opera Mini",
      F: {
        LD: 1426464000
      }
    },
    I: {
      A: {
        EC: 0,
        J: 0.0000327216,
        I: 0.326169,
        MD: 0,
        ND: 0,
        OD: 0,
        PD: 0.000130886,
        dC: 0.000130886,
        QD: 0,
        RD: 0.000523546
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "MD", "ND", "OD", "EC", "J", "PD", "dC", "QD", "RD", "I", "", "", ""],
      E: "Android Browser",
      F: {
        MD: 1256515200,
        ND: 1274313600,
        OD: 1291593600,
        EC: 1298332800,
        J: 1318896000,
        PD: 1341792000,
        dC: 1374624000,
        QD: 1386547200,
        RD: 1401667200,
        I: 1725408000
      }
    },
    J: {
      A: {
        D: 0,
        A: 0
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "D", "A", "", "", ""],
      E: "Blackberry Browser",
      F: {
        D: 1325376000,
        A: 1359504000
      }
    },
    K: {
      A: {
        A: 0,
        B: 0,
        C: 0,
        H: 1.24603,
        "8B": 0,
        cC: 0,
        "9B": 0
      },
      B: "o",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "A", "B", "8B", "cC", "C", "9B", "H", "", "", ""],
      E: "Opera Mobile",
      F: {
        A: 1287100800,
        B: 1300752000,
        "8B": 1314835200,
        cC: 1318291200,
        C: 1330300800,
        "9B": 1349740800,
        H: 1709769600
      },
      D: {
        H: "webkit"
      }
    },
    L: {
      A: {
        I: 44.331
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "I", "", "", ""],
      E: "Chrome for Android",
      F: {
        I: 1725408000
      }
    },
    M: {
      A: {
        v: 0.365712
      },
      B: "moz",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "v", "", "", ""],
      E: "Firefox for Android",
      F: {
        v: 1718064000
      }
    },
    N: {
      A: {
        A: 0,
        B: 0
      },
      B: "ms",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "A", "B", "", "", ""],
      E: "IE Mobile",
      F: {
        A: 1340150400,
        B: 1353456000
      }
    },
    O: {
      A: {
        AC: 1.13563
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "AC", "", "", ""],
      E: "UC Browser for Android",
      F: {
        AC: 1710115200
      },
      D: {
        AC: "webkit"
      }
    },
    P: {
      A: {
        "0": 0.0755255,
        "1": 1.27314,
        J: 0.0971042,
        w: 0.0215787,
        x: 0.0431574,
        y: 0.0647361,
        z: 0.0647361,
        SD: 0.0107894,
        TD: 0.0107894,
        UD: 0.0323681,
        VD: 0,
        WD: 0,
        NC: 0,
        XD: 0.0107894,
        YD: 0,
        ZD: 0.0107894,
        aD: 0,
        bD: 0,
        BC: 0,
        CC: 0.0215787,
        DC: 0,
        cD: 0.0215787
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "J", "SD", "TD", "UD", "VD", "WD", "NC", "XD", "YD", "ZD", "aD", "bD", "BC", "CC", "DC", "cD", "w", "x", "y", "z", "0", "1", "", "", ""],
      E: "Samsung Internet",
      F: {
        "0": 1711497600,
        "1": 1715126400,
        J: 1461024000,
        SD: 1481846400,
        TD: 1509408000,
        UD: 1528329600,
        VD: 1546128000,
        WD: 1554163200,
        NC: 1567900800,
        XD: 1582588800,
        YD: 1593475200,
        ZD: 1605657600,
        aD: 1618531200,
        bD: 1629072000,
        BC: 1640736000,
        CC: 1651708800,
        DC: 1659657600,
        cD: 1667260800,
        w: 1677369600,
        x: 1684454400,
        y: 1689292800,
        z: 1697587200
      }
    },
    Q: {
      A: {
        dD: 0.3208
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "dD", "", "", ""],
      E: "QQ Browser",
      F: {
        dD: 1710288000
      }
    },
    R: {
      A: {
        eD: 0
      },
      B: "webkit",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "eD", "", "", ""],
      E: "Baidu Browser",
      F: {
        eD: 1710201600
      }
    },
    S: {
      A: {
        fD: 0.051328,
        gD: 0
      },
      B: "moz",
      C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "fD", "gD", "", "", ""],
      E: "KaiOS Browser",
      F: {
        fD: 1527811200,
        gD: 1631664000
      }
    }
  };

var versions = {
    "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",
    "23.3": "110",
    "24.0": "112",
    "24.1": "112",
    "24.2": "112",
    "24.3": "112",
    "24.4": "112",
    "24.5": "112",
    "24.6": "112",
    "24.7": "112",
    "24.8": "112",
    "25.0": "114",
    "25.1": "114",
    "25.2": "114",
    "25.3": "114",
    "25.4": "114",
    "25.5": "114",
    "25.6": "114",
    "25.7": "114",
    "25.8": "114",
    "25.9": "114",
    "26.0": "116",
    "26.1": "116",
    "26.2": "116",
    "26.3": "116",
    "26.4": "116",
    "26.5": "116",
    "26.6": "116",
    "27.0": "118",
    "27.1": "118",
    "27.2": "118",
    "27.3": "118",
    "28.0": "120",
    "28.1": "120",
    "28.2": "120",
    "28.3": "120",
    "29.0": "122",
    "29.1": "122",
    "29.2": "122",
    "29.3": "122",
    "29.4": "122",
    "30.0": "124",
    "30.1": "124",
    "30.2": "124",
    "30.3": "124",
    "30.4": "124",
    "30.5": "124",
    "31.0": "126",
    "31.1": "126",
    "31.2": "126",
    "31.3": "126",
    "31.4": "126",
    "31.5": "126",
    "31.6": "126",
    "32.0": "128",
    "32.1": "128",
    "33.0": "130"
  };

var require$$4 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_path);

function BrowserslistError$2(message) {
    this.name = 'BrowserslistError';
    this.message = message;
    this.browserslist = true;
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, BrowserslistError$2);
    }
  }
  BrowserslistError$2.prototype = Error.prototype;
  var error = BrowserslistError$2;

var require$$0$8 = {
  	"es6.module": {
  	chrome: "61",
  	and_chr: "61",
  	edge: "16",
  	firefox: "60",
  	and_ff: "60",
  	node: "13.2.0",
  	opera: "48",
  	op_mob: "45",
  	safari: "10.1",
  	ios: "10.3",
  	samsung: "8.2",
  	android: "61",
  	electron: "2.0",
  	ios_saf: "10.3"
  }
  };

var nativeModules = require$$0$8;

var iterator;
  var hasRequiredIterator;
  function requireIterator() {
    if (hasRequiredIterator) return iterator;
    hasRequiredIterator = 1;
    iterator = function iterator(Yallist) {
      Yallist.prototype[Symbol.iterator] = _regeneratorRuntime().mark(function _callee() {
        var walker;
        return _regeneratorRuntime().wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              walker = this.head;
            case 1:
              if (!walker) {
                _context.next = 7;
                break;
              }
              _context.next = 4;
              return walker.value;
            case 4:
              walker = walker.next;
              _context.next = 1;
              break;
            case 7:
            case "end":
              return _context.stop();
          }
        }, _callee, this);
      });
    };
    return iterator;
  }

var yallist;
  var hasRequiredYallist;
  function requireYallist() {
    if (hasRequiredYallist) return yallist;
    hasRequiredYallist = 1;
    yallist = Yallist;
    Yallist.Node = Node;
    Yallist.create = Yallist;
    function Yallist(list) {
      var self = this;
      if (!(self instanceof Yallist)) {
        self = new Yallist();
      }
      self.tail = null;
      self.head = null;
      self.length = 0;
      if (list && typeof list.forEach === 'function') {
        list.forEach(function (item) {
          self.push(item);
        });
      } else if (arguments.length > 0) {
        for (var i = 0, l = arguments.length; i < l; i++) {
          self.push(arguments[i]);
        }
      }
      return self;
    }
    Yallist.prototype.removeNode = function (node) {
      if (node.list !== this) {
        throw new Error('removing node which does not belong to this list');
      }
      var next = node.next;
      var prev = node.prev;
      if (next) {
        next.prev = prev;
      }
      if (prev) {
        prev.next = next;
      }
      if (node === this.head) {
        this.head = next;
      }
      if (node === this.tail) {
        this.tail = prev;
      }
      node.list.length--;
      node.next = null;
      node.prev = null;
      node.list = null;
      return next;
    };
    Yallist.prototype.unshiftNode = function (node) {
      if (node === this.head) {
        return;
      }
      if (node.list) {
        node.list.removeNode(node);
      }
      var head = this.head;
      node.list = this;
      node.next = head;
      if (head) {
        head.prev = node;
      }
      this.head = node;
      if (!this.tail) {
        this.tail = node;
      }
      this.length++;
    };
    Yallist.prototype.pushNode = function (node) {
      if (node === this.tail) {
        return;
      }
      if (node.list) {
        node.list.removeNode(node);
      }
      var tail = this.tail;
      node.list = this;
      node.prev = tail;
      if (tail) {
        tail.next = node;
      }
      this.tail = node;
      if (!this.head) {
        this.head = node;
      }
      this.length++;
    };
    Yallist.prototype.push = function () {
      for (var i = 0, l = arguments.length; i < l; i++) {
        push(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 undefined;
      }
      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 undefined;
      }
      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 (start, deleteCount) {
      if (start > this.length) {
        start = this.length - 1;
      }
      if (start < 0) {
        start = this.length + start;
      }
      for (var i = 0, walker = this.head; walker !== null && i < start; 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(self, node, value) {
      var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
      if (inserted.next === null) {
        self.tail = inserted;
      }
      if (inserted.prev === null) {
        self.head = inserted;
      }
      self.length++;
      return inserted;
    }
    function push(self, item) {
      self.tail = new Node(item, self.tail, null, self);
      if (!self.head) {
        self.head = self.tail;
      }
      self.length++;
    }
    function unshift(self, item) {
      self.head = new Node(item, null, self.head, self);
      if (!self.tail) {
        self.tail = self.head;
      }
      self.length++;
    }
    function Node(value, prev, next, list) {
      if (!(this instanceof Node)) {
        return new Node(value, prev, next, list);
      }
      this.list = list;
      this.value = value;
      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 lruCacheBABEL_8_BREAKINGFalse;
  var hasRequiredLruCacheBABEL_8_BREAKINGFalse;
  function requireLruCacheBABEL_8_BREAKINGFalse() {
    if (hasRequiredLruCacheBABEL_8_BREAKINGFalse) return lruCacheBABEL_8_BREAKINGFalse;
    hasRequiredLruCacheBABEL_8_BREAKINGFalse = 1;
    var Yallist = requireYallist();
    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 = function naiveLength() {
      return 1;
    };
    var LRUCache = function () {
      function LRUCache(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;
        var 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();
      }
      var _proto = LRUCache.prototype;
      _proto.rforEach = function rforEach(fn, thisp) {
        thisp = thisp || this;
        for (var walker = this[LRU_LIST].tail; walker !== null;) {
          var prev = walker.prev;
          forEachStep(this, fn, walker, thisp);
          walker = prev;
        }
      };
      _proto.forEach = function forEach(fn, thisp) {
        thisp = thisp || this;
        for (var walker = this[LRU_LIST].head; walker !== null;) {
          var next = walker.next;
          forEachStep(this, fn, walker, thisp);
          walker = next;
        }
      };
      _proto.keys = function keys() {
        return this[LRU_LIST].toArray().map(function (k) {
          return k.key;
        });
      };
      _proto.values = function values() {
        return this[LRU_LIST].toArray().map(function (k) {
          return k.value;
        });
      };
      _proto.reset = function reset() {
        var _this = this;
        if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
          this[LRU_LIST].forEach(function (hit) {
            return _this[DISPOSE](hit.key, hit.value);
          });
        }
        this[CACHE] = new Map();
        this[LRU_LIST] = new Yallist();
        this[LENGTH] = 0;
      };
      _proto.dump = function dump() {
        var _this2 = this;
        return this[LRU_LIST].map(function (hit) {
          return isStale(_this2, hit) ? false : {
            k: hit.key,
            v: hit.value,
            e: hit.now + (hit.maxAge || 0)
          };
        }).toArray().filter(function (h) {
          return h;
        });
      };
      _proto.dumpLru = function dumpLru() {
        return this[LRU_LIST];
      };
      _proto.set = function set(key, value, maxAge) {
        maxAge = maxAge || this[MAX_AGE];
        if (maxAge && typeof maxAge !== 'number') throw new TypeError('maxAge must be a number');
        var now = maxAge ? Date.now() : 0;
        var len = this[LENGTH_CALCULATOR](value, key);
        if (this[CACHE].has(key)) {
          if (len > this[MAX]) {
            _del(this, this[CACHE].get(key));
            return false;
          }
          var node = this[CACHE].get(key);
          var item = node.value;
          if (this[DISPOSE]) {
            if (!this[NO_DISPOSE_ON_SET]) this[DISPOSE](key, item.value);
          }
          item.now = now;
          item.maxAge = maxAge;
          item.value = value;
          this[LENGTH] += len - item.length;
          item.length = len;
          this.get(key);
          trim(this);
          return true;
        }
        var hit = new Entry(key, value, len, now, maxAge);
        if (hit.length > this[MAX]) {
          if (this[DISPOSE]) this[DISPOSE](key, value);
          return false;
        }
        this[LENGTH] += hit.length;
        this[LRU_LIST].unshift(hit);
        this[CACHE].set(key, this[LRU_LIST].head);
        trim(this);
        return true;
      };
      _proto.has = function has(key) {
        if (!this[CACHE].has(key)) return false;
        var hit = this[CACHE].get(key).value;
        return !isStale(this, hit);
      };
      _proto.get = function get(key) {
        return _get(this, key, true);
      };
      _proto.peek = function peek(key) {
        return _get(this, key, false);
      };
      _proto.pop = function pop() {
        var node = this[LRU_LIST].tail;
        if (!node) return null;
        _del(this, node);
        return node.value;
      };
      _proto.del = function del(key) {
        _del(this, this[CACHE].get(key));
      };
      _proto.load = function load(arr) {
        this.reset();
        var now = Date.now();
        for (var l = arr.length - 1; l >= 0; l--) {
          var hit = arr[l];
          var expiresAt = hit.e || 0;
          if (expiresAt === 0) this.set(hit.k, hit.v);else {
            var maxAge = expiresAt - now;
            if (maxAge > 0) {
              this.set(hit.k, hit.v, maxAge);
            }
          }
        }
      };
      _proto.prune = function prune() {
        var _this3 = this;
        this[CACHE].forEach(function (value, key) {
          return _get(_this3, key, false);
        });
      };
      return _createClass(LRUCache, [{
        key: "max",
        get: function get() {
          return this[MAX];
        },
        set: function set(mL) {
          if (typeof mL !== 'number' || mL < 0) throw new TypeError('max must be a non-negative number');
          this[MAX] = mL || Infinity;
          trim(this);
        }
      }, {
        key: "allowStale",
        get: function get() {
          return this[ALLOW_STALE];
        },
        set: function set(allowStale) {
          this[ALLOW_STALE] = !!allowStale;
        }
      }, {
        key: "maxAge",
        get: function get() {
          return this[MAX_AGE];
        },
        set: function set(mA) {
          if (typeof mA !== 'number') throw new TypeError('maxAge must be a non-negative number');
          this[MAX_AGE] = mA;
          trim(this);
        }
      }, {
        key: "lengthCalculator",
        get: function get() {
          return this[LENGTH_CALCULATOR];
        },
        set: function set(lC) {
          var _this4 = this;
          if (typeof lC !== 'function') lC = naiveLength;
          if (lC !== this[LENGTH_CALCULATOR]) {
            this[LENGTH_CALCULATOR] = lC;
            this[LENGTH] = 0;
            this[LRU_LIST].forEach(function (hit) {
              hit.length = _this4[LENGTH_CALCULATOR](hit.value, hit.key);
              _this4[LENGTH] += hit.length;
            });
          }
          trim(this);
        }
      }, {
        key: "length",
        get: function get() {
          return this[LENGTH];
        }
      }, {
        key: "itemCount",
        get: function get() {
          return this[LRU_LIST].length;
        }
      }]);
    }();
    var _get = function _get(self, key, doUse) {
      var node = self[CACHE].get(key);
      if (node) {
        var hit = node.value;
        if (isStale(self, hit)) {
          _del(self, node);
          if (!self[ALLOW_STALE]) return undefined;
        } else {
          if (doUse) {
            if (self[UPDATE_AGE_ON_GET]) node.value.now = Date.now();
            self[LRU_LIST].unshiftNode(node);
          }
        }
        return hit.value;
      }
    };
    var isStale = function isStale(self, hit) {
      if (!hit || !hit.maxAge && !self[MAX_AGE]) return false;
      var diff = Date.now() - hit.now;
      return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
    };
    var trim = function trim(self) {
      if (self[LENGTH] > self[MAX]) {
        for (var walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null;) {
          var prev = walker.prev;
          _del(self, walker);
          walker = prev;
        }
      }
    };
    var _del = function _del(self, node) {
      if (node) {
        var hit = node.value;
        if (self[DISPOSE]) self[DISPOSE](hit.key, hit.value);
        self[LENGTH] -= hit.length;
        self[CACHE]["delete"](hit.key);
        self[LRU_LIST].removeNode(node);
      }
    };
    var Entry = _createClass(function Entry(key, value, length, now, maxAge) {
      this.key = key;
      this.value = value;
      this.length = length;
      this.now = now;
      this.maxAge = maxAge || 0;
    });
    var forEachStep = function forEachStep(self, fn, node, thisp) {
      var hit = node.value;
      if (isStale(self, hit)) {
        _del(self, node);
        if (!self[ALLOW_STALE]) hit = undefined;
      }
      if (hit) fn.call(thisp, hit.value, hit.key, self);
    };
    lruCacheBABEL_8_BREAKINGFalse = LRUCache;
    return lruCacheBABEL_8_BREAKINGFalse;
  }

function bool$6(value) {
    if (value == null) return false;
    return value && value !== "false" && value !== "0";
  }
  var lruCache = bool$6(browser$1$1.env["BABEL_8_BREAKING"]) ? requireLruCacheBABEL_8_BREAKINGFalse() : requireLruCacheBABEL_8_BREAKINGFalse();

function bool$5(value) {
    if (value == null) return false;
    return value && value !== "false" && value !== "0";
  }
  var semver$8 = bool$5(browser$1$1.env["BABEL_8_BREAKING"]) ? requireSemver$2() : requireSemver$2();

var unreleasedLabels = {
    safari: "tp"
  };
  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_mobile",
    opera: "opera",
    safari: "safari",
    samsung: "samsung"
  };

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",
    opera_mobile: "opera_mobile"
  };

var require$$0$7 = {
  	"transform-duplicate-named-capturing-groups-regex": {
  	chrome: "126",
  	opera: "112",
  	edge: "126",
  	firefox: "129",
  	safari: "17.4",
  	node: "23",
  	ios: "17.4",
  	electron: "31.0"
  },
  	"transform-regexp-modifiers": {
  	chrome: "125",
  	opera: "111",
  	edge: "125",
  	firefox: "132",
  	node: "23",
  	electron: "31.0"
  },
  	"transform-unicode-sets-regex": {
  	chrome: "112",
  	opera: "98",
  	edge: "112",
  	firefox: "116",
  	safari: "17",
  	node: "20",
  	deno: "1.32",
  	ios: "17",
  	opera_mobile: "75",
  	electron: "24.0"
  },
  	"bugfix/transform-v8-static-class-fields-redefine-readonly": {
  	chrome: "98",
  	opera: "84",
  	edge: "98",
  	firefox: "75",
  	safari: "15",
  	node: "12",
  	deno: "1.18",
  	ios: "15",
  	samsung: "11",
  	opera_mobile: "52",
  	electron: "17.0"
  },
  	"bugfix/transform-firefox-class-in-computed-class-key": {
  	chrome: "74",
  	opera: "62",
  	edge: "79",
  	safari: "16",
  	node: "12",
  	deno: "1",
  	ios: "16",
  	samsung: "11",
  	opera_mobile: "53",
  	electron: "6.0"
  },
  	"bugfix/transform-safari-class-field-initializer-scope": {
  	chrome: "74",
  	opera: "62",
  	edge: "79",
  	firefox: "69",
  	safari: "16",
  	node: "12",
  	deno: "1",
  	ios: "16",
  	samsung: "11",
  	opera_mobile: "53",
  	electron: "6.0"
  },
  	"transform-class-static-block": {
  	chrome: "94",
  	opera: "80",
  	edge: "94",
  	firefox: "93",
  	safari: "16.4",
  	node: "16.11",
  	deno: "1.14",
  	ios: "16.4",
  	samsung: "17",
  	opera_mobile: "66",
  	electron: "15.0"
  },
  	"proposal-class-static-block": {
  	chrome: "94",
  	opera: "80",
  	edge: "94",
  	firefox: "93",
  	safari: "16.4",
  	node: "16.11",
  	deno: "1.14",
  	ios: "16.4",
  	samsung: "17",
  	opera_mobile: "66",
  	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",
  	opera_mobile: "64",
  	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",
  	opera_mobile: "64",
  	electron: "13.0"
  },
  	"transform-class-properties": {
  	chrome: "74",
  	opera: "62",
  	edge: "79",
  	firefox: "90",
  	safari: "14.1",
  	node: "12",
  	deno: "1",
  	ios: "14.5",
  	samsung: "11",
  	opera_mobile: "53",
  	electron: "6.0"
  },
  	"proposal-class-properties": {
  	chrome: "74",
  	opera: "62",
  	edge: "79",
  	firefox: "90",
  	safari: "14.1",
  	node: "12",
  	deno: "1",
  	ios: "14.5",
  	samsung: "11",
  	opera_mobile: "53",
  	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",
  	opera_mobile: "60",
  	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",
  	opera_mobile: "60",
  	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",
  	opera_mobile: "54",
  	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",
  	opera_mobile: "54",
  	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",
  	opera_mobile: "60",
  	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",
  	opera_mobile: "60",
  	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",
  	opera_mobile: "57",
  	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",
  	opera_mobile: "57",
  	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",
  	opera_mobile: "64",
  	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",
  	opera_mobile: "64",
  	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",
  	opera_mobile: "47",
  	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",
  	opera_mobile: "47",
  	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",
  	opera_mobile: "47",
  	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",
  	opera_mobile: "47",
  	electron: "3.0"
  },
  	"transform-parameters": {
  	chrome: "49",
  	opera: "36",
  	edge: "18",
  	firefox: "53",
  	safari: "16.3",
  	node: "6",
  	deno: "1",
  	ios: "16.3",
  	samsung: "5",
  	opera_mobile: "36",
  	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",
  	opera_mobile: "46",
  	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",
  	opera_mobile: "46",
  	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",
  	opera_mobile: "44",
  	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",
  	opera_mobile: "44",
  	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",
  	rhino: "1.7.15",
  	opera_mobile: "46",
  	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",
  	opera_mobile: "47",
  	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",
  	opera_mobile: "47",
  	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",
  	opera_mobile: "47",
  	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",
  	opera_mobile: "42",
  	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",
  	opera_mobile: "41",
  	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",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"transform-literals": {
  	chrome: "44",
  	opera: "31",
  	edge: "12",
  	firefox: "53",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "4",
  	rhino: "1.7.15",
  	opera_mobile: "32",
  	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",
  	opera_mobile: "41",
  	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",
  	opera_mobile: "34",
  	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",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"transform-classes": {
  	chrome: "46",
  	opera: "33",
  	edge: "13",
  	firefox: "45",
  	safari: "10",
  	node: "5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "33",
  	electron: "0.36"
  },
  	"transform-object-super": {
  	chrome: "46",
  	opera: "33",
  	edge: "13",
  	firefox: "45",
  	safari: "10",
  	node: "5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "33",
  	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",
  	opera_mobile: "30",
  	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",
  	opera_mobile: "29",
  	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",
  	opera_mobile: "32",
  	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",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"transform-sticky-regex": {
  	chrome: "49",
  	opera: "36",
  	edge: "13",
  	firefox: "3",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	rhino: "1.7.15",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"transform-unicode-escapes": {
  	chrome: "44",
  	opera: "31",
  	edge: "12",
  	firefox: "53",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "4",
  	rhino: "1.7.15",
  	opera_mobile: "32",
  	electron: "0.30"
  },
  	"transform-unicode-regex": {
  	chrome: "50",
  	opera: "37",
  	edge: "13",
  	firefox: "46",
  	safari: "12",
  	node: "6",
  	deno: "1",
  	ios: "12",
  	samsung: "5",
  	opera_mobile: "37",
  	electron: "1.1"
  },
  	"transform-spread": {
  	chrome: "46",
  	opera: "33",
  	edge: "13",
  	firefox: "45",
  	safari: "10",
  	node: "5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "33",
  	electron: "0.36"
  },
  	"transform-destructuring": {
  	chrome: "51",
  	opera: "38",
  	edge: "15",
  	firefox: "53",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"transform-block-scoping": {
  	chrome: "50",
  	opera: "37",
  	edge: "14",
  	firefox: "53",
  	safari: "11",
  	node: "6",
  	deno: "1",
  	ios: "11",
  	samsung: "5",
  	opera_mobile: "37",
  	electron: "1.1"
  },
  	"transform-typeof-symbol": {
  	chrome: "48",
  	opera: "35",
  	edge: "12",
  	firefox: "36",
  	safari: "9",
  	node: "6",
  	deno: "1",
  	ios: "9",
  	samsung: "5",
  	opera_mobile: "35",
  	electron: "0.37"
  },
  	"transform-new-target": {
  	chrome: "46",
  	opera: "33",
  	edge: "14",
  	firefox: "41",
  	safari: "10",
  	node: "5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "33",
  	electron: "0.36"
  },
  	"transform-regenerator": {
  	chrome: "50",
  	opera: "37",
  	edge: "13",
  	firefox: "53",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "37",
  	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",
  	opera_mobile: "12",
  	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",
  	opera_mobile: "12",
  	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",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"transform-export-namespace-from": {
  	chrome: "72",
  	deno: "1.0",
  	edge: "79",
  	firefox: "80",
  	node: "13.2",
  	opera: "60",
  	opera_mobile: "51",
  	safari: "14.1",
  	ios: "14.5",
  	samsung: "11.0",
  	android: "72",
  	electron: "5.0"
  },
  	"proposal-export-namespace-from": {
  	chrome: "72",
  	deno: "1.0",
  	edge: "79",
  	firefox: "80",
  	node: "13.2",
  	opera: "60",
  	opera_mobile: "51",
  	safari: "14.1",
  	ios: "14.5",
  	samsung: "11.0",
  	android: "72",
  	electron: "5.0"
  }
  };

var plugins$1 = require$$0$7;

var src$2 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    TargetNames: TargetNames,
    default: getTargets$1,
    filterItems: filterItems,
    getInclusionReasons: getInclusionReasons,
    isBrowsersQueryValid: isBrowsersQueryValid,
    isRequired: isRequired,
    prettifyTargets: prettifyTargets,
    unreleasedLabels: unreleasedLabels
  });

var removed = {
    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."
    }
  };

var _Object$getOwnPropert;
  var ErrorToString = Function.call.bind(Error.prototype.toString);
  var SUPPORTED = !!Error.captureStackTrace && ((_Object$getOwnPropert = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit")) == null ? void 0 : _Object$getOwnPropert.writable) === true;
  var START_HIDING = "startHiding - secret - don't use this - v1";
  var STOP_HIDING = "stopHiding - secret - don't use this - v1";
  var expectedErrors = new WeakSet();
  var virtualFrames = new WeakMap();
  function CallSite(filename) {
    return Object.create({
      isNative: function isNative() {
        return false;
      },
      isConstructor: function isConstructor() {
        return false;
      },
      isToplevel: function isToplevel() {
        return true;
      },
      getFileName: function getFileName() {
        return filename;
      },
      getLineNumber: function getLineNumber() {
        return undefined;
      },
      getColumnNumber: function getColumnNumber() {
        return undefined;
      },
      getFunctionName: function getFunctionName() {
        return undefined;
      },
      getMethodName: function getMethodName() {
        return undefined;
      },
      getTypeName: function getTypeName() {
        return undefined;
      },
      toString: function toString() {
        return filename;
      }
    });
  }
  function injectVirtualStackFrame(error, filename) {
    if (!SUPPORTED) return;
    var 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 () {
      setupPrepareStackTrace();
      return fn.apply(void 0, arguments);
    }, "name", {
      value: STOP_HIDING
    });
  }
  function endHiddenCallStack(fn) {
    if (!SUPPORTED) return fn;
    return Object.defineProperty(function () {
      return fn.apply(void 0, arguments);
    }, "name", {
      value: START_HIDING
    });
  }
  function setupPrepareStackTrace() {
    setupPrepareStackTrace = function setupPrepareStackTrace() {};
    var _Error$prepareStackTr = Error.prepareStackTrace,
      prepareStackTrace = _Error$prepareStackTr === void 0 ? defaultPrepareStackTrace : _Error$prepareStackTr;
    var MIN_STACK_TRACE_LIMIT = 50;
    Error.stackTraceLimit && (Error.stackTraceLimit = Math.max(Error.stackTraceLimit, MIN_STACK_TRACE_LIMIT));
    Error.prepareStackTrace = function stackTraceRewriter(err, trace) {
      var newTrace = [];
      var isExpected = expectedErrors.has(err);
      var status = isExpected ? "hiding" : "unknown";
      for (var i = 0; i < trace.length; i++) {
        var name = trace[i].getFunctionName();
        if (name === START_HIDING) {
          status = "hiding";
        } else if (name === STOP_HIDING) {
          if (status === "hiding") {
            status = "showing";
            if (virtualFrames.has(err)) {
              var _newTrace;
              (_newTrace = newTrace).unshift.apply(_newTrace, _toConsumableArray(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) + "\n    at " + trace.join("\n    at ");
  }

var ConfigError = function (_Error) {
    function ConfigError(message, filename) {
      var _this;
      _this = _Error.call(this, message) || this;
      expectedError(_this);
      if (filename) injectVirtualStackFrame(_this, filename);
      return _this;
    }
    _inherits(ConfigError, _Error);
    return _createClass(ConfigError);
  }(_wrapNativeSuper(Error));

var LOADED_PLUGIN;
  var blockHoistPlugin = {
    name: "internal.blockHoist",
    visitor: {
      Block: {
        exit: function exit(_ref) {
          var node = _ref.node;
          node.body = performHoisting(node.body);
        }
      },
      SwitchCase: {
        exit: function exit(_ref2) {
          var node = _ref2.node;
          node.consequent = performHoisting(node.consequent);
        }
      }
    }
  };
  function performHoisting(body) {
    var max = Math.pow(2, 30) - 1;
    var hasChange = false;
    for (var i = 0; i < body.length; i++) {
      var n = body[i];
      var p = priority(n);
      if (p > max) {
        hasChange = true;
        break;
      }
      max = p;
    }
    if (!hasChange) return body;
    return stableSort(body.slice());
  }
  function loadBlockHoistPlugin() {
    if (!LOADED_PLUGIN) {
      LOADED_PLUGIN = new Plugin(Object.assign({}, blockHoistPlugin, {
        visitor: traverse.explode(blockHoistPlugin.visitor)
      }), {});
    }
    return LOADED_PLUGIN;
  }
  function priority(bodyNode) {
    var priority = bodyNode == null ? void 0 : bodyNode._blockHoist;
    if (priority == null) return 1;
    if (priority === true) return 2;
    return priority;
  }
  function stableSort(body) {
    var buckets = Object.create(null);
    for (var i = 0; i < body.length; i++) {
      var n = body[i];
      var p = priority(n);
      var bucket = buckets[p] || (buckets[p] = []);
      bucket.push(n);
    }
    var keys = Object.keys(buckets).map(function (k) {
      return +k;
    }).sort(function (a, b) {
      return b - a;
    });
    var index = 0;
    for (var _iterator = _createForOfIteratorHelperLoose(keys), _step; !(_step = _iterator()).done;) {
      var key = _step.value;
      var _bucket = buckets[key];
      for (var _iterator2 = _createForOfIteratorHelperLoose(_bucket), _step2; !(_step2 = _iterator2()).done;) {
        var _n = _step2.value;
        body[index++] = _n;
      }
    }
    return body;
  }

var fs = {};

var convertSourceMap = {};

(function (exports) {

Object.defineProperty(exports, 'commentRegex', {
      get: function getCommentRegex() {
        return /^\s*?\/[\/\*][@#]\s+?sourceMappingURL=data:(((?:application|text)\/json)(?:;charset=([^;,]+?)?)?)?(?:;(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$1 !== 'undefined') {
      if (typeof Buffer$1.from === 'function') {
        decodeBase64 = decodeBase64WithBufferFrom;
      } else {
        decodeBase64 = decodeBase64WithNewBuffer;
      }
    } else {
      decodeBase64 = decodeBase64WithAtob;
    }
    function decodeBase64WithBufferFrom(base64) {
      return Buffer$1.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$1(base64, 'base64').toString();
    }
    function decodeBase64WithAtob(base64) {
      return decodeURIComponent(escape(atob(base64)));
    }
    function stripComment(sm) {
      return sm.split(',').pop();
    }
    function readFromFileMap(sm, read) {
      var r = exports.mapFileCommentRegex.exec(sm);
      var filename = r[1] || r[2];
      try {
        var sm = read(filename);
        if (sm != null && typeof sm["catch"] === 'function') {
          return sm["catch"](throwError);
        } else {
          return sm;
        }
      } catch (e) {
        throwError(e);
      }
      function throwError(e) {
        throw new Error('An error occurred while trying to read the map file at ' + filename + '\n' + e.stack);
      }
    }
    function Converter(sm, opts) {
      opts = opts || {};
      if (opts.hasComment) {
        sm = stripComment(sm);
      }
      if (opts.encoding === 'base64') {
        sm = decodeBase64(sm);
      } else if (opts.encoding === 'uri') {
        sm = decodeURIComponent(sm);
      }
      if (opts.isJSON || opts.encoding) {
        sm = JSON.parse(sm);
      }
      this.sourcemap = sm;
    }
    Converter.prototype.toJSON = function (space) {
      return JSON.stringify(this.sourcemap, null, space);
    };
    if (typeof Buffer$1 !== 'undefined') {
      if (typeof Buffer$1.from === 'function') {
        Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
      } else {
        Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
      }
    } else {
      Converter.prototype.toBase64 = encodeBase64WithBtoa;
    }
    function encodeBase64WithBufferFrom() {
      var json = this.toJSON();
      return Buffer$1.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$1(json, 'utf8').toString('base64');
    }
    function encodeBase64WithBtoa() {
      var json = this.toJSON();
      return btoa(unescape(encodeURIComponent(json)));
    }
    Converter.prototype.toURI = function () {
      var json = this.toJSON();
      return encodeURIComponent(json);
    };
    Converter.prototype.toComment = function (options) {
      var encoding, content, data;
      if (options != null && options.encoding === 'uri') {
        encoding = '';
        content = this.toURI();
      } else {
        encoding = ';base64';
        content = this.toBase64();
      }
      data = 'sourceMappingURL=data:application/json;charset=utf-8' + encoding + ',' + content;
      return options != null && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
    };
    Converter.prototype.toObject = function () {
      return JSON.parse(this.toJSON());
    };
    Converter.prototype.addProperty = function (key, value) {
      if (this.sourcemap.hasOwnProperty(key)) throw new Error('property "' + key + '" already exists on the sourcemap, use set property instead');
      return this.setProperty(key, value);
    };
    Converter.prototype.setProperty = function (key, value) {
      this.sourcemap[key] = value;
      return this;
    };
    Converter.prototype.getProperty = function (key) {
      return this.sourcemap[key];
    };
    exports.fromObject = function (obj) {
      return new Converter(obj);
    };
    exports.fromJSON = function (json) {
      return new Converter(json, {
        isJSON: true
      });
    };
    exports.fromURI = function (uri) {
      return new Converter(uri, {
        encoding: 'uri'
      });
    };
    exports.fromBase64 = function (base64) {
      return new Converter(base64, {
        encoding: 'base64'
      });
    };
    exports.fromComment = function (comment) {
      var m, encoding;
      comment = comment.replace(/^\/\*/g, '//').replace(/\*\/$/g, '');
      m = exports.commentRegex.exec(comment);
      encoding = m && m[4] || 'uri';
      return new Converter(comment, {
        encoding: encoding,
        hasComment: true
      });
    };
    function makeConverter(sm) {
      return new Converter(sm, {
        isJSON: true
      });
    }
    exports.fromMapFileComment = function (comment, read) {
      if (typeof read === 'string') {
        throw new Error('String directory paths are no longer supported with `fromMapFileComment`\n' + 'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading');
      }
      var sm = readFromFileMap(comment, read);
      if (sm != null && typeof sm.then === 'function') {
        return sm.then(makeConverter);
      } else {
        return makeConverter(sm);
      }
    };
    exports.fromSource = function (content) {
      var m = content.match(exports.commentRegex);
      return m ? exports.fromComment(m.pop()) : null;
    };
    exports.fromMapFileSource = function (content, read) {
      if (typeof read === 'string') {
        throw new Error('String directory paths are no longer supported with `fromMapFileSource`\n' + 'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading');
      }
      var m = content.match(exports.mapFileCommentRegex);
      return m ? exports.fromMapFileComment(m.pop(), read) : 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 data = 'sourceMappingURL=' + file;
      return options && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
    };
  })(convertSourceMap);

var genMapping_umd = {exports: {}};

function makeNoopPlugin() {
    var p;
    return (p = function p() {
      return {};
    })["default"] = p;
  }

function declare(x) {
    return x;
  }

var pluginUtilsShim = /*#__PURE__*/Object.freeze({
    __proto__: null,
    declare: declare,
    declarePreset: declare
  });

var lib$9 = {};

var require$$0$6 = /*@__PURE__*/getAugmentedNamespace(pluginUtilsShim);

Object.defineProperty(lib$9, "__esModule", {
    value: true
  });
  lib$9["default"] = void 0;
  var _helperPluginUtils$1 = require$$0$6;
  lib$9["default"] = (0, _helperPluginUtils$1.declare)(function (api) {
    api.assertVersion(7);
    return {
      name: "syntax-decimal",
      manipulateOptions: function manipulateOptions(opts, parserOpts) {
        parserOpts.plugins.push("decimal");
      }
    };
  });

var src$1 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    default: syntaxImportAssertions
  });

var src = /*#__PURE__*/Object.freeze({
    __proto__: null,
    default: syntaxImportAttributes
  });

var lib$8 = {};

Object.defineProperty(lib$8, "__esModule", {
    value: true
  });
  lib$8["default"] = void 0;
  var _helperPluginUtils = require$$0$6;
  lib$8["default"] = (0, _helperPluginUtils.declare)(function (api) {
    api.assertVersion(7);
    return {
      name: "syntax-import-reflection",
      manipulateOptions: function manipulateOptions(_, parserOpts) {
        parserOpts.plugins.push("importReflection");
      }
    };
  });

{
    var removePlugin = function removePlugin(plugins, name) {
      var indices = [];
      plugins.forEach(function (plugin, i) {
        var n = Array.isArray(plugin) ? plugin[0] : plugin;
        if (n === name) {
          indices.unshift(i);
        }
      });
      for (var _i = 0, _indices = indices; _i < _indices.length; _i++) {
        var i = _indices[_i];
        plugins.splice(i, 1);
      }
    };
  }
  var syntaxTypescript = declare(function (api, opts) {
    api.assertVersion("*");
    var disallowAmbiguousJSXLike = opts.disallowAmbiguousJSXLike,
      dts = opts.dts;
    {
      var isTSX = opts.isTSX;
    }
    return {
      name: "syntax-typescript",
      manipulateOptions: function manipulateOptions(opts, parserOpts) {
        {
          var plugins = parserOpts.plugins;
          removePlugin(plugins, "flow");
          removePlugin(plugins, "jsx");
          {
            plugins.push("objectRestSpread", "classProperties");
          }
          if (isTSX) {
            plugins.push("jsx");
          }
        }
        parserOpts.plugins.push(["typescript", {
          disallowAmbiguousJSXLike: disallowAmbiguousJSXLike,
          dts: dts
        }]);
      }
    };
  });

var _templateObject$A, _templateObject2$h, _templateObject3$d, _templateObject4$8;
  var assignmentExpression$1 = assignmentExpression$8,
    callExpression$1 = callExpression$c,
    cloneNode$1 = cloneNode$e,
    identifier$1 = identifier$d,
    memberExpression$2 = memberExpression$9,
    sequenceExpression = sequenceExpression$6,
    stringLiteral$1 = stringLiteral$6,
    thisExpression$1 = thisExpression$4;
  var visitor$2 = environmentVisitor({
    Super: function Super(path, state) {
      var node = path.node,
        parentPath = path.parentPath;
      if (!parentPath.isMemberExpression({
        object: node
      })) return;
      state.handle(parentPath);
    }
  });
  var unshadowSuperBindingVisitor = environmentVisitor({
    Scopable: function Scopable(path, _ref) {
      var refName = _ref.refName;
      var binding = path.scope.getOwnBinding(refName);
      if (binding && binding.identifier.name === refName) {
        path.scope.rename(refName);
      }
    }
  });
  var specHandlers = {
    memoise: function memoise(superMember, count) {
      var scope = superMember.scope,
        node = superMember.node;
      var computed = node.computed,
        property = node.property;
      if (!computed) {
        return;
      }
      var memo = scope.maybeGenerateMemoised(property);
      if (!memo) {
        return;
      }
      this.memoiser.set(property, memo, count);
    },
    prop: function prop(superMember) {
      var _superMember$node = superMember.node,
        computed = _superMember$node.computed,
        property = _superMember$node.property;
      if (this.memoiser.has(property)) {
        return cloneNode$1(this.memoiser.get(property));
      }
      if (computed) {
        return cloneNode$1(property);
      }
      return stringLiteral$1(property.name);
    },
    _getPrototypeOfExpression: function _getPrototypeOfExpression() {
      var objectRef = cloneNode$1(this.getObjectRef());
      var targetRef = this.isStatic || this.isPrivateMethod ? objectRef : memberExpression$2(objectRef, identifier$1("prototype"));
      return callExpression$1(this.file.addHelper("getPrototypeOf"), [targetRef]);
    },
    get: function get(superMember) {
      var objectRef = cloneNode$1(this.getObjectRef());
      return callExpression$1(this.file.addHelper("superPropGet"), [this.isDerivedConstructor ? sequenceExpression([thisExpression$1(), objectRef]) : objectRef, this.prop(superMember), thisExpression$1()].concat(_toConsumableArray(this.isStatic || this.isPrivateMethod ? [] : [numericLiteral$5(1)])));
    },
    _call: function _call(superMember, args, optional) {
      var objectRef = cloneNode$1(this.getObjectRef());
      var argsNode;
      if (args.length === 1 && isSpreadElement$1(args[0]) && (isIdentifier$e(args[0].argument) || isArrayExpression$2(args[0].argument))) {
        argsNode = args[0].argument;
      } else {
        argsNode = arrayExpression$1(args);
      }
      var call = callExpression$c(this.file.addHelper("superPropGet"), [this.isDerivedConstructor ? sequenceExpression([thisExpression$1(), objectRef]) : objectRef, this.prop(superMember), thisExpression$1(), numericLiteral$5(2 | (this.isStatic || this.isPrivateMethod ? 0 : 1))]);
      if (optional) {
        return optionalCallExpression$2(call, [argsNode], true);
      }
      return callExpression$1(call, [argsNode]);
    },
    set: function set(superMember, value) {
      var objectRef = cloneNode$1(this.getObjectRef());
      return callExpression$1(this.file.addHelper("superPropSet"), [this.isDerivedConstructor ? sequenceExpression([thisExpression$1(), objectRef]) : objectRef, this.prop(superMember), value, thisExpression$1(), numericLiteral$5(superMember.isInStrictMode() ? 1 : 0)].concat(_toConsumableArray(this.isStatic || this.isPrivateMethod ? [] : [numericLiteral$5(1)])));
    },
    destructureSet: function destructureSet(superMember) {
      throw superMember.buildCodeFrameError("Destructuring to a super field is not supported yet.");
    },
    call: function call(superMember, args) {
      return this._call(superMember, args, false);
    },
    optionalCall: function optionalCall(superMember, args) {
      return this._call(superMember, args, true);
    },
    "delete": function _delete(superMember) {
      if (superMember.node.computed) {
        return sequenceExpression([callExpression$1(this.file.addHelper("toPropertyKey"), [cloneNode$1(superMember.node.property)]), template$1.expression.ast(_templateObject$A || (_templateObject$A = _taggedTemplateLiteralLoose(["\n          function () { throw new ReferenceError(\"'delete super[expr]' is invalid\"); }()\n        "])))]);
      } else {
        return template$1.expression.ast(_templateObject2$h || (_templateObject2$h = _taggedTemplateLiteralLoose(["\n        function () { throw new ReferenceError(\"'delete super.prop' is invalid\"); }()\n      "])));
      }
    }
  };
  var specHandlers_old = {
    memoise: function memoise(superMember, count) {
      var scope = superMember.scope,
        node = superMember.node;
      var computed = node.computed,
        property = node.property;
      if (!computed) {
        return;
      }
      var memo = scope.maybeGenerateMemoised(property);
      if (!memo) {
        return;
      }
      this.memoiser.set(property, memo, count);
    },
    prop: function prop(superMember) {
      var _superMember$node2 = superMember.node,
        computed = _superMember$node2.computed,
        property = _superMember$node2.property;
      if (this.memoiser.has(property)) {
        return cloneNode$1(this.memoiser.get(property));
      }
      if (computed) {
        return cloneNode$1(property);
      }
      return stringLiteral$1(property.name);
    },
    _getPrototypeOfExpression: function _getPrototypeOfExpression() {
      var objectRef = cloneNode$1(this.getObjectRef());
      var targetRef = this.isStatic || this.isPrivateMethod ? objectRef : memberExpression$2(objectRef, identifier$1("prototype"));
      return callExpression$1(this.file.addHelper("getPrototypeOf"), [targetRef]);
    },
    get: function get(superMember) {
      return this._get(superMember);
    },
    _get: function _get(superMember) {
      var proto = this._getPrototypeOfExpression();
      return callExpression$1(this.file.addHelper("get"), [this.isDerivedConstructor ? sequenceExpression([thisExpression$1(), proto]) : proto, this.prop(superMember), thisExpression$1()]);
    },
    set: function set(superMember, value) {
      var proto = this._getPrototypeOfExpression();
      return callExpression$1(this.file.addHelper("set"), [this.isDerivedConstructor ? sequenceExpression([thisExpression$1(), proto]) : proto, this.prop(superMember), value, thisExpression$1(), booleanLiteral$2(superMember.isInStrictMode())]);
    },
    destructureSet: function destructureSet(superMember) {
      throw superMember.buildCodeFrameError("Destructuring to a super field is not supported yet.");
    },
    call: function call(superMember, args) {
      return optimiseCallExpression(this._get(superMember), thisExpression$1(), args, false);
    },
    optionalCall: function optionalCall(superMember, args) {
      return optimiseCallExpression(this._get(superMember), cloneNode$1(thisExpression$1()), args, true);
    },
    "delete": function _delete(superMember) {
      if (superMember.node.computed) {
        return sequenceExpression([callExpression$1(this.file.addHelper("toPropertyKey"), [cloneNode$1(superMember.node.property)]), template$1.expression.ast(_templateObject3$d || (_templateObject3$d = _taggedTemplateLiteralLoose(["\n          function () { throw new ReferenceError(\"'delete super[expr]' is invalid\"); }()\n        "])))]);
      } else {
        return template$1.expression.ast(_templateObject4$8 || (_templateObject4$8 = _taggedTemplateLiteralLoose(["\n        function () { throw new ReferenceError(\"'delete super.prop' is invalid\"); }()\n      "])));
      }
    }
  };
  var looseHandlers = Object.assign({}, specHandlers, {
    prop: function prop(superMember) {
      var property = superMember.node.property;
      if (this.memoiser.has(property)) {
        return cloneNode$1(this.memoiser.get(property));
      }
      return cloneNode$1(property);
    },
    get: function get(superMember) {
      var isStatic = this.isStatic,
        getSuperRef = this.getSuperRef;
      var computed = superMember.node.computed;
      var prop = this.prop(superMember);
      var object;
      if (isStatic) {
        var _getSuperRef;
        object = (_getSuperRef = getSuperRef()) != null ? _getSuperRef : memberExpression$2(identifier$1("Function"), identifier$1("prototype"));
      } else {
        var _getSuperRef2;
        object = memberExpression$2((_getSuperRef2 = getSuperRef()) != null ? _getSuperRef2 : identifier$1("Object"), identifier$1("prototype"));
      }
      return memberExpression$2(object, prop, computed);
    },
    set: function set(superMember, value) {
      var computed = superMember.node.computed;
      var prop = this.prop(superMember);
      return assignmentExpression$1("=", memberExpression$2(thisExpression$1(), prop, computed), value);
    },
    destructureSet: function destructureSet(superMember) {
      var computed = superMember.node.computed;
      var prop = this.prop(superMember);
      return memberExpression$2(thisExpression$1(), prop, computed);
    },
    call: function call(superMember, args) {
      return optimiseCallExpression(this.get(superMember), thisExpression$1(), args, false);
    },
    optionalCall: function optionalCall(superMember, args) {
      return optimiseCallExpression(this.get(superMember), thisExpression$1(), args, true);
    }
  });
  var ReplaceSupers = function () {
    function ReplaceSupers(opts) {
      var _opts$constantSuper;
      var 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;
    }
    var _proto = ReplaceSupers.prototype;
    _proto.getObjectRef = function getObjectRef() {
      return cloneNode$1(this.opts.objectRef || this.opts.getObjectRef());
    };
    _proto.getSuperRef = function getSuperRef() {
      if (this.opts.superRef) return cloneNode$1(this.opts.superRef);
      if (this.opts.getSuperRef) {
        return cloneNode$1(this.opts.getSuperRef());
      }
    };
    _proto.replace = function replace() {
      var methodPath = this.methodPath;
      if (this.opts.refToPreserve) {
        methodPath.traverse(unshadowSuperBindingVisitor, {
          refName: this.opts.refToPreserve.name
        });
      }
      var handler = this.constantSuper ? looseHandlers : this.file.availableHelper("superPropSet") ? specHandlers : specHandlers_old;
      visitor$2.shouldSkip = function (path) {
        if (path.parentPath === methodPath) {
          if (path.parentKey === "decorators" || path.parentKey === "key") {
            return true;
          }
        }
      };
      memberExpressionToFunctions(methodPath, visitor$2, 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));
    };
    return _createClass(ReplaceSupers);
  }();

function assertFieldTransformed(path) {
    if (path.node.declare || false) {
      throw path.buildCodeFrameError("TypeScript 'declare' fields must first be transformed by " + "@babel/plugin-transform-typescript.\n" + "If you have already enabled that plugin (or '@babel/preset-typescript'), make sure " + "that it runs before any plugin related to additional class features:\n" + " - @babel/plugin-transform-class-properties\n" + " - @babel/plugin-transform-private-methods\n" + " - @babel/plugin-proposal-decorators");
    }
  }

var _templateObject$z, _templateObject2$g, _templateObject3$c, _templateObject4$7, _templateObject5$4, _templateObject6$2, _templateObject7$1, _templateObject8$1, _templateObject9$1, _templateObject10$1, _templateObject11$1, _templateObject12$1, _templateObject13$1, _templateObject14$1, _templateObject15$1, _templateObject16$1, _templateObject17$1, _templateObject18$1, _templateObject19$1, _templateObject20$1, _templateObject21$1, _templateObject22;
  {
    var newHelpers = function newHelpers(file) {
      return file.availableHelper("classPrivateFieldGet2");
    };
  }
  function buildPrivateNamesMap(className, privateFieldsAsSymbolsOrProperties, props, file) {
    var privateNamesMap = new Map();
    var classBrandId;
    for (var _iterator = _createForOfIteratorHelperLoose(props), _step; !(_step = _iterator()).done;) {
      var prop = _step.value;
      if (prop.isPrivate()) {
        var name = prop.node.key.id.name;
        var update = privateNamesMap.get(name);
        if (!update) {
          var isMethod = !prop.isProperty();
          var isStatic = prop.node["static"];
          var initAdded = false;
          var id = void 0;
          if (!privateFieldsAsSymbolsOrProperties && newHelpers(file) && isMethod && !isStatic) {
            var _classBrandId;
            initAdded = !!classBrandId;
            (_classBrandId = classBrandId) != null ? _classBrandId : classBrandId = prop.scope.generateUidIdentifier(className + "_brand");
            id = classBrandId;
          } else {
            id = prop.scope.generateUidIdentifier(name);
          }
          update = {
            id: id,
            "static": isStatic,
            method: isMethod,
            initAdded: initAdded
          };
          privateNamesMap.set(name, update);
        }
        if (prop.isClassPrivateMethod()) {
          if (prop.node.kind === "get") {
            var body = prop.node.body.body;
            var $ = void 0;
            if (body.length === 1 && isReturnStatement($ = body[0]) && isCallExpression$8($ = $.argument) && $.arguments.length === 1 && isThisExpression$2($.arguments[0]) && isIdentifier$e($ = $.callee)) {
              update.getId = cloneNode$e($);
              update.getterDeclared = true;
            } else {
              update.getId = prop.scope.generateUidIdentifier("get_" + name);
            }
          } else if (prop.node.kind === "set") {
            var params = prop.node.params;
            var _body = prop.node.body.body;
            var _$ = void 0;
            if (_body.length === 1 && isExpressionStatement$2(_$ = _body[0]) && isCallExpression$8(_$ = _$.expression) && _$.arguments.length === 2 && isThisExpression$2(_$.arguments[0]) && isIdentifier$e(_$.arguments[1], {
              name: params[0].name
            }) && isIdentifier$e(_$ = _$.callee)) {
              update.setId = cloneNode$e(_$);
              update.setterDeclared = true;
            } else {
              update.setId = prop.scope.generateUidIdentifier("set_" + name);
            }
          } else if (prop.node.kind === "method") {
            update.methodId = prop.scope.generateUidIdentifier(name);
          }
        }
        privateNamesMap.set(name, update);
      }
    }
    return privateNamesMap;
  }
  function buildPrivateNamesNodes(privateNamesMap, privateFieldsAsProperties, privateFieldsAsSymbols, state) {
    var initNodes = [];
    var injectedIds = new Set();
    for (var _iterator2 = _createForOfIteratorHelperLoose(privateNamesMap), _step2; !(_step2 = _iterator2()).done;) {
      var _step2$value = _slicedToArray(_step2.value, 2),
        name = _step2$value[0],
        value = _step2$value[1];
      var isStatic = value["static"],
        isMethod = value.method,
        getId = value.getId,
        setId = value.setId;
      var isGetterOrSetter = getId || setId;
      var id = cloneNode$e(value.id);
      var init = void 0;
      if (privateFieldsAsProperties) {
        init = callExpression$c(state.addHelper("classPrivateFieldLooseKey"), [stringLiteral$6(name)]);
      } else if (privateFieldsAsSymbols) {
        init = callExpression$c(identifier$d("Symbol"), [stringLiteral$6(name)]);
      } else if (!isStatic) {
        if (injectedIds.has(id.name)) continue;
        injectedIds.add(id.name);
        init = newExpression(identifier$d(isMethod && (!isGetterOrSetter || newHelpers(state)) ? "WeakSet" : "WeakMap"), []);
      }
      if (init) {
        if (!privateFieldsAsSymbols) {
          annotateAsPure(init);
        }
        initNodes.push(template$1.statement.ast(_templateObject$z || (_templateObject$z = _taggedTemplateLiteralLoose(["var ", " = ", ""])), id, init));
      }
    }
    return initNodes;
  }
  function privateNameVisitorFactory(visitor) {
    var nestedVisitor = environmentVisitor(Object.assign({}, visitor));
    var privateNameVisitor = Object.assign({}, visitor, {
      Class: function Class(path) {
        var privateNamesMap = this.privateNamesMap;
        var body = path.get("body.body");
        var visiblePrivateNames = new Map(privateNamesMap);
        var redeclared = [];
        for (var _iterator3 = _createForOfIteratorHelperLoose(body), _step3; !(_step3 = _iterator3()).done;) {
          var prop = _step3.value;
          if (!prop.isPrivate()) continue;
          var name = prop.node.key.id.name;
          visiblePrivateNames["delete"](name);
          redeclared.push(name);
        }
        if (!redeclared.length) {
          return;
        }
        path.get("body").traverse(nestedVisitor, Object.assign({}, this, {
          redeclared: redeclared
        }));
        path.traverse(privateNameVisitor, Object.assign({}, this, {
          privateNamesMap: visiblePrivateNames
        }));
        path.skipKey("body");
      }
    });
    return privateNameVisitor;
  }
  var privateNameVisitor = privateNameVisitorFactory({
    PrivateName: function PrivateName(path, _ref) {
      var noDocumentAll = _ref.noDocumentAll;
      var privateNamesMap = this.privateNamesMap,
        redeclared = this.redeclared;
      var node = path.node,
        parentPath = path.parentPath;
      if (!parentPath.isMemberExpression({
        property: node
      }) && !parentPath.isOptionalMemberExpression({
        property: node
      })) {
        return;
      }
      var name = node.id.name;
      if (!privateNamesMap.has(name)) return;
      if (redeclared != null && redeclared.includes(name)) return;
      this.handle(parentPath, noDocumentAll);
    }
  });
  function unshadow(name, scope, innerBinding) {
    while ((_scope = scope) != null && _scope.hasBinding(name) && !scope.bindingIdentifierEquals(name, innerBinding)) {
      var _scope;
      scope.rename(name);
      scope = scope.parent;
    }
  }
  function buildCheckInRHS(rhs, file, inRHSIsObject) {
    if (!(file.availableHelper != null && file.availableHelper("checkInRHS"))) return rhs;
    return callExpression$c(file.addHelper("checkInRHS"), [rhs]);
  }
  var privateInVisitor = privateNameVisitorFactory({
    BinaryExpression: function BinaryExpression(path, _ref2) {
      var file = _ref2.file;
      var _path$node = path.node,
        operator = _path$node.operator,
        left = _path$node.left,
        right = _path$node.right;
      if (operator !== "in") return;
      if (!isPrivateName$2(left)) return;
      var privateFieldsAsProperties = this.privateFieldsAsProperties,
        privateNamesMap = this.privateNamesMap,
        redeclared = this.redeclared;
      var name = left.id.name;
      if (!privateNamesMap.has(name)) return;
      if (redeclared != null && redeclared.includes(name)) return;
      unshadow(this.classRef.name, path.scope, this.innerBinding);
      if (privateFieldsAsProperties) {
        var _privateNamesMap$get = privateNamesMap.get(name),
          _id = _privateNamesMap$get.id;
        path.replaceWith(template$1.expression.ast(_templateObject2$g || (_templateObject2$g = _taggedTemplateLiteralLoose(["\n        Object.prototype.hasOwnProperty.call(", ", ", ")\n      "])), buildCheckInRHS(right, file), cloneNode$e(_id)));
        return;
      }
      var _privateNamesMap$get2 = privateNamesMap.get(name),
        id = _privateNamesMap$get2.id,
        isStatic = _privateNamesMap$get2["static"];
      if (isStatic) {
        path.replaceWith(template$1.expression.ast(_templateObject3$c || (_templateObject3$c = _taggedTemplateLiteralLoose(["", " === ", ""])), buildCheckInRHS(right, file), cloneNode$e(this.classRef)));
        return;
      }
      path.replaceWith(template$1.expression.ast(_templateObject4$7 || (_templateObject4$7 = _taggedTemplateLiteralLoose(["", ".has(", ")"])), cloneNode$e(id), buildCheckInRHS(right, file)));
    }
  });
  function readOnlyError(file, name) {
    return callExpression$c(file.addHelper("readOnlyError"), [stringLiteral$6("#" + name)]);
  }
  function writeOnlyError(file, name) {
    if (!file.availableHelper("writeOnlyError")) {
      console.warn("@babel/helpers is outdated, update it to silence this warning.");
      return buildUndefinedNode$2();
    }
    return callExpression$c(file.addHelper("writeOnlyError"), [stringLiteral$6("#" + name)]);
  }
  function buildStaticPrivateFieldAccess(expr, noUninitializedPrivateFieldAccess) {
    if (noUninitializedPrivateFieldAccess) return expr;
    return memberExpression$9(expr, identifier$d("_"));
  }
  function autoInherits(fn) {
    return function (member) {
      return inherits$3(fn.apply(this, arguments), member.node);
    };
  }
  var privateNameHandlerSpec = {
    memoise: function memoise(member, count) {
      var scope = member.scope;
      var _ref3 = member.node,
        object = _ref3.object;
      var memo = scope.maybeGenerateMemoised(object);
      if (!memo) {
        return;
      }
      this.memoiser.set(object, memo, count);
    },
    receiver: function receiver(member) {
      var _ref4 = member.node,
        object = _ref4.object;
      if (this.memoiser.has(object)) {
        return cloneNode$e(this.memoiser.get(object));
      }
      return cloneNode$e(object);
    },
    get: autoInherits(function (member) {
      var classRef = this.classRef,
        privateNamesMap = this.privateNamesMap,
        file = this.file,
        innerBinding = this.innerBinding,
        noUninitializedPrivateFieldAccess = this.noUninitializedPrivateFieldAccess;
      var privateName = member.node.property;
      var name = privateName.id.name;
      var _privateNamesMap$get3 = privateNamesMap.get(name),
        id = _privateNamesMap$get3.id,
        isStatic = _privateNamesMap$get3["static"],
        isMethod = _privateNamesMap$get3.method,
        methodId = _privateNamesMap$get3.methodId,
        getId = _privateNamesMap$get3.getId,
        setId = _privateNamesMap$get3.setId;
      var isGetterOrSetter = getId || setId;
      var cloneId = function cloneId(id) {
        return inherits$3(cloneNode$e(id), privateName);
      };
      if (isStatic) {
        unshadow(classRef.name, member.scope, innerBinding);
        if (!newHelpers(file)) {
          var helperName = isMethod && !isGetterOrSetter ? "classStaticPrivateMethodGet" : "classStaticPrivateFieldSpecGet";
          return callExpression$c(file.addHelper(helperName), [this.receiver(member), cloneNode$e(classRef), cloneId(id)]);
        }
        var _receiver = this.receiver(member);
        var skipCheck = isIdentifier$e(_receiver) && _receiver.name === classRef.name;
        if (!isMethod) {
          if (skipCheck) {
            return buildStaticPrivateFieldAccess(cloneId(id), noUninitializedPrivateFieldAccess);
          }
          return buildStaticPrivateFieldAccess(callExpression$c(file.addHelper("assertClassBrand"), [cloneNode$e(classRef), _receiver, cloneId(id)]), noUninitializedPrivateFieldAccess);
        }
        if (getId) {
          if (skipCheck) {
            return callExpression$c(cloneId(getId), [_receiver]);
          }
          return callExpression$c(file.addHelper("classPrivateGetter"), [cloneNode$e(classRef), _receiver, cloneId(getId)]);
        }
        if (setId) {
          var err = buildUndefinedNode$2();
          if (skipCheck) return err;
          return sequenceExpression$6([callExpression$c(file.addHelper("assertClassBrand"), [cloneNode$e(classRef), _receiver]), err]);
        }
        if (skipCheck) return cloneId(id);
        return callExpression$c(file.addHelper("assertClassBrand"), [cloneNode$e(classRef), _receiver, cloneId(id)]);
      }
      if (isMethod) {
        if (isGetterOrSetter) {
          if (!getId) {
            return sequenceExpression$6([this.receiver(member), writeOnlyError(file, name)]);
          }
          if (!newHelpers(file)) {
            return callExpression$c(file.addHelper("classPrivateFieldGet"), [this.receiver(member), cloneId(id)]);
          }
          return callExpression$c(file.addHelper("classPrivateGetter"), [cloneNode$e(id), this.receiver(member), cloneId(getId)]);
        }
        if (!newHelpers(file)) {
          return callExpression$c(file.addHelper("classPrivateMethodGet"), [this.receiver(member), cloneNode$e(id), cloneId(methodId)]);
        }
        return callExpression$c(file.addHelper("assertClassBrand"), [cloneNode$e(id), this.receiver(member), cloneId(methodId)]);
      }
      if (newHelpers(file)) {
        return callExpression$c(file.addHelper("classPrivateFieldGet2"), [cloneId(id), this.receiver(member)]);
      }
      return callExpression$c(file.addHelper("classPrivateFieldGet"), [this.receiver(member), cloneId(id)]);
    }),
    boundGet: function boundGet(member) {
      this.memoise(member, 1);
      return callExpression$c(memberExpression$9(this.get(member), identifier$d("bind")), [this.receiver(member)]);
    },
    set: autoInherits(function (member, value) {
      var classRef = this.classRef,
        privateNamesMap = this.privateNamesMap,
        file = this.file,
        noUninitializedPrivateFieldAccess = this.noUninitializedPrivateFieldAccess;
      var privateName = member.node.property;
      var name = privateName.id.name;
      var _privateNamesMap$get4 = privateNamesMap.get(name),
        id = _privateNamesMap$get4.id,
        isStatic = _privateNamesMap$get4["static"],
        isMethod = _privateNamesMap$get4.method,
        setId = _privateNamesMap$get4.setId,
        getId = _privateNamesMap$get4.getId;
      var isGetterOrSetter = getId || setId;
      var cloneId = function cloneId(id) {
        return inherits$3(cloneNode$e(id), privateName);
      };
      if (isStatic) {
        if (!newHelpers(file)) {
          var helperName = isMethod && !isGetterOrSetter ? "classStaticPrivateMethodSet" : "classStaticPrivateFieldSpecSet";
          return callExpression$c(file.addHelper(helperName), [this.receiver(member), cloneNode$e(classRef), cloneId(id), value]);
        }
        var _receiver2 = this.receiver(member);
        var skipCheck = isIdentifier$e(_receiver2) && _receiver2.name === classRef.name;
        if (isMethod && !setId) {
          var err = readOnlyError(file, name);
          if (skipCheck) return sequenceExpression$6([value, err]);
          return sequenceExpression$6([value, callExpression$c(file.addHelper("assertClassBrand"), [cloneNode$e(classRef), _receiver2]), readOnlyError(file, name)]);
        }
        if (setId) {
          if (skipCheck) {
            return callExpression$c(cloneNode$e(setId), [_receiver2, value]);
          }
          return callExpression$c(file.addHelper("classPrivateSetter"), [cloneNode$e(classRef), cloneId(setId), _receiver2, value]);
        }
        return assignmentExpression$8("=", buildStaticPrivateFieldAccess(cloneId(id), noUninitializedPrivateFieldAccess), skipCheck ? value : callExpression$c(file.addHelper("assertClassBrand"), [cloneNode$e(classRef), _receiver2, value]));
      }
      if (isMethod) {
        if (setId) {
          if (!newHelpers(file)) {
            return callExpression$c(file.addHelper("classPrivateFieldSet"), [this.receiver(member), cloneId(id), value]);
          }
          return callExpression$c(file.addHelper("classPrivateSetter"), [cloneNode$e(id), cloneId(setId), this.receiver(member), value]);
        }
        return sequenceExpression$6([this.receiver(member), value, readOnlyError(file, name)]);
      }
      if (newHelpers(file)) {
        return callExpression$c(file.addHelper("classPrivateFieldSet2"), [cloneId(id), this.receiver(member), value]);
      }
      return callExpression$c(file.addHelper("classPrivateFieldSet"), [this.receiver(member), cloneId(id), value]);
    }),
    destructureSet: function destructureSet(member) {
      var classRef = this.classRef,
        privateNamesMap = this.privateNamesMap,
        file = this.file,
        noUninitializedPrivateFieldAccess = this.noUninitializedPrivateFieldAccess;
      var privateName = member.node.property;
      var name = privateName.id.name;
      var _privateNamesMap$get5 = privateNamesMap.get(name),
        id = _privateNamesMap$get5.id,
        isStatic = _privateNamesMap$get5["static"],
        isMethod = _privateNamesMap$get5.method,
        setId = _privateNamesMap$get5.setId;
      var cloneId = function cloneId(id) {
        return inherits$3(cloneNode$e(id), privateName);
      };
      if (!newHelpers(file)) {
        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, \n" + "please update @babel/helpers to the latest version.");
          }
          return memberExpression$9(callExpression$c(helper, [this.receiver(member), cloneNode$e(classRef), cloneId(id)]), identifier$d("value"));
        }
        return memberExpression$9(callExpression$c(file.addHelper("classPrivateFieldDestructureSet"), [this.receiver(member), cloneId(id)]), identifier$d("value"));
      }
      if (isMethod && !setId) {
        return memberExpression$9(sequenceExpression$6([member.node.object, readOnlyError(file, name)]), identifier$d("_"));
      }
      if (isStatic && !isMethod) {
        var getCall = this.get(member);
        if (!noUninitializedPrivateFieldAccess || !isCallExpression$8(getCall)) {
          return getCall;
        }
        var ref = getCall.arguments.pop();
        getCall.arguments.push(template$1.expression.ast(_templateObject5$4 || (_templateObject5$4 = _taggedTemplateLiteralLoose(["(_) => ", " = _"])), ref));
        return memberExpression$9(callExpression$c(file.addHelper("toSetter"), [getCall]), identifier$d("_"));
      }
      var setCall = this.set(member, identifier$d("_"));
      if (!isCallExpression$8(setCall) || !isIdentifier$e(setCall.arguments[setCall.arguments.length - 1], {
        name: "_"
      })) {
        throw member.buildCodeFrameError("Internal Babel error while compiling this code. This is a Babel bug. " + "Please report it at https://github.com/babel/babel/issues.");
      }
      var args;
      if (isMemberExpression$7(setCall.callee, {
        computed: false
      }) && isIdentifier$e(setCall.callee.property) && setCall.callee.property.name === "call") {
        args = [setCall.callee.object, arrayExpression$1(setCall.arguments.slice(1, -1)), setCall.arguments[0]];
      } else {
        args = [setCall.callee, arrayExpression$1(setCall.arguments.slice(0, -1))];
      }
      return memberExpression$9(callExpression$c(file.addHelper("toSetter"), args), identifier$d("_"));
    },
    call: function call(member, args) {
      this.memoise(member, 1);
      return optimiseCallExpression(this.get(member), this.receiver(member), args, false);
    },
    optionalCall: function optionalCall(member, args) {
      this.memoise(member, 1);
      return optimiseCallExpression(this.get(member), this.receiver(member), args, true);
    },
    "delete": function _delete() {
      throw new Error("Internal Babel error: deleting private elements is a parsing error.");
    }
  };
  var privateNameHandlerLoose = {
    get: function get(member) {
      var privateNamesMap = this.privateNamesMap,
        file = this.file;
      var object = member.node.object;
      var name = member.node.property.id.name;
      return template$1.expression(_templateObject6$2 || (_templateObject6$2 = _taggedTemplateLiteralLoose(["BASE(REF, PROP)[PROP]"])))({
        BASE: file.addHelper("classPrivateFieldLooseBase"),
        REF: cloneNode$e(object),
        PROP: cloneNode$e(privateNamesMap.get(name).id)
      });
    },
    set: function set() {
      throw new Error("private name handler with loose = true don't need set()");
    },
    boundGet: function boundGet(member) {
      return callExpression$c(memberExpression$9(this.get(member), identifier$d("bind")), [cloneNode$e(member.node.object)]);
    },
    simpleSet: function simpleSet(member) {
      return this.get(member);
    },
    destructureSet: function destructureSet(member) {
      return this.get(member);
    },
    call: function call(member, args) {
      return callExpression$c(this.get(member), args);
    },
    optionalCall: function optionalCall(member, args) {
      return optionalCallExpression$2(this.get(member), args, true);
    },
    "delete": function _delete() {
      throw new Error("Internal Babel error: deleting private elements is a parsing error.");
    }
  };
  function transformPrivateNamesUsage(ref, path, privateNamesMap, _ref5, state) {
    var privateFieldsAsProperties = _ref5.privateFieldsAsProperties,
      noUninitializedPrivateFieldAccess = _ref5.noUninitializedPrivateFieldAccess,
      noDocumentAll = _ref5.noDocumentAll,
      innerBinding = _ref5.innerBinding;
    if (!privateNamesMap.size) return;
    var body = path.get("body");
    var handler = privateFieldsAsProperties ? privateNameHandlerLoose : privateNameHandlerSpec;
    memberExpressionToFunctions(body, privateNameVisitor, Object.assign({
      privateNamesMap: privateNamesMap,
      classRef: ref,
      file: state
    }, handler, {
      noDocumentAll: noDocumentAll,
      noUninitializedPrivateFieldAccess: noUninitializedPrivateFieldAccess,
      innerBinding: innerBinding
    }));
    body.traverse(privateInVisitor, {
      privateNamesMap: privateNamesMap,
      classRef: ref,
      file: state,
      privateFieldsAsProperties: privateFieldsAsProperties,
      innerBinding: innerBinding
    });
  }
  function buildPrivateFieldInitLoose(ref, prop, privateNamesMap) {
    var _privateNamesMap$get6 = privateNamesMap.get(prop.node.key.id.name),
      id = _privateNamesMap$get6.id;
    var value = prop.node.value || prop.scope.buildUndefinedNode();
    return inheritPropComments(template$1.statement.ast(_templateObject7$1 || (_templateObject7$1 = _taggedTemplateLiteralLoose(["\n      Object.defineProperty(", ", ", ", {\n        // configurable is false by default\n        // enumerable is false by default\n        writable: true,\n        value: ", "\n      });\n    "])), ref, cloneNode$e(id), value), prop);
  }
  function buildPrivateInstanceFieldInitSpec(ref, prop, privateNamesMap, state) {
    var _privateNamesMap$get7 = privateNamesMap.get(prop.node.key.id.name),
      id = _privateNamesMap$get7.id;
    var value = prop.node.value || prop.scope.buildUndefinedNode();
    {
      if (!state.availableHelper("classPrivateFieldInitSpec")) {
        return inheritPropComments(template$1.statement.ast(_templateObject8$1 || (_templateObject8$1 = _taggedTemplateLiteralLoose(["", ".set(", ", {\n          // configurable is always false for private elements\n          // enumerable is always false for private elements\n          writable: true,\n          value: ", ",\n        })"])), cloneNode$e(id), ref, value), prop);
      }
    }
    var helper = state.addHelper("classPrivateFieldInitSpec");
    return inheritLoc(inheritPropComments(expressionStatement$7(callExpression$c(helper, [thisExpression$4(), inheritLoc(cloneNode$e(id), prop.node.key), newHelpers(state) ? value : template$1.expression.ast(_templateObject9$1 || (_templateObject9$1 = _taggedTemplateLiteralLoose(["{ writable: true, value: ", " }"])), value)])), prop), prop.node);
  }
  function buildPrivateStaticFieldInitSpec(prop, privateNamesMap, noUninitializedPrivateFieldAccess) {
    var privateName = privateNamesMap.get(prop.node.key.id.name);
    var value = noUninitializedPrivateFieldAccess ? prop.node.value : template$1.expression.ast(_templateObject10$1 || (_templateObject10$1 = _taggedTemplateLiteralLoose(["{\n        _: ", "\n      }"])), prop.node.value || buildUndefinedNode$2());
    return inheritPropComments(variableDeclaration$6("var", [variableDeclarator$6(cloneNode$e(privateName.id), value)]), prop);
  }
  {
    var buildPrivateStaticFieldInitSpecOld = function buildPrivateStaticFieldInitSpecOld(prop, privateNamesMap) {
      var privateName = privateNamesMap.get(prop.node.key.id.name);
      var id = privateName.id,
        getId = privateName.getId,
        setId = privateName.setId,
        initAdded = privateName.initAdded;
      var isGetterOrSetter = getId || setId;
      if (!prop.isProperty() && (initAdded || !isGetterOrSetter)) return;
      if (isGetterOrSetter) {
        privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
          initAdded: true
        }));
        return inheritPropComments(template$1.statement.ast(_templateObject11$1 || (_templateObject11$1 = _taggedTemplateLiteralLoose(["\n          var ", " = {\n            // configurable is false by default\n            // enumerable is false by default\n            // writable is false by default\n            get: ", ",\n            set: ", "\n          }\n        "])), cloneNode$e(id), getId ? getId.name : prop.scope.buildUndefinedNode(), setId ? setId.name : prop.scope.buildUndefinedNode()), prop);
      }
      var value = prop.node.value || prop.scope.buildUndefinedNode();
      return inheritPropComments(template$1.statement.ast(_templateObject12$1 || (_templateObject12$1 = _taggedTemplateLiteralLoose(["\n        var ", " = {\n          // configurable is false by default\n          // enumerable is false by default\n          writable: true,\n          value: ", "\n        };\n      "])), cloneNode$e(id), value), prop);
    };
  }
  function buildPrivateMethodInitLoose(ref, prop, privateNamesMap) {
    var privateName = privateNamesMap.get(prop.node.key.id.name);
    var methodId = privateName.methodId,
      id = privateName.id,
      getId = privateName.getId,
      setId = privateName.setId,
      initAdded = privateName.initAdded;
    if (initAdded) return;
    if (methodId) {
      return inheritPropComments(template$1.statement.ast(_templateObject13$1 || (_templateObject13$1 = _taggedTemplateLiteralLoose(["\n        Object.defineProperty(", ", ", ", {\n          // configurable is false by default\n          // enumerable is false by default\n          // writable is false by default\n          value: ", "\n        });\n      "])), ref, id, methodId.name), prop);
    }
    var isGetterOrSetter = getId || setId;
    if (isGetterOrSetter) {
      privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
        initAdded: true
      }));
      return inheritPropComments(template$1.statement.ast(_templateObject14$1 || (_templateObject14$1 = _taggedTemplateLiteralLoose(["\n        Object.defineProperty(", ", ", ", {\n          // configurable is false by default\n          // enumerable is false by default\n          // writable is false by default\n          get: ", ",\n          set: ", "\n        });\n      "])), ref, id, getId ? getId.name : prop.scope.buildUndefinedNode(), setId ? setId.name : prop.scope.buildUndefinedNode()), prop);
    }
  }
  function buildPrivateInstanceMethodInitSpec(ref, prop, privateNamesMap, state) {
    var privateName = privateNamesMap.get(prop.node.key.id.name);
    if (privateName.initAdded) return;
    if (!newHelpers(state)) {
      var isGetterOrSetter = privateName.getId || privateName.setId;
      if (isGetterOrSetter) {
        return buildPrivateAccessorInitialization(ref, prop, privateNamesMap, state);
      }
    }
    return buildPrivateInstanceMethodInitialization(ref, prop, privateNamesMap, state);
  }
  function buildPrivateAccessorInitialization(ref, prop, privateNamesMap, state) {
    var privateName = privateNamesMap.get(prop.node.key.id.name);
    var id = privateName.id,
      getId = privateName.getId,
      setId = privateName.setId;
    privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
      initAdded: true
    }));
    {
      if (!state.availableHelper("classPrivateFieldInitSpec")) {
        return inheritPropComments(template$1.statement.ast(_templateObject15$1 || (_templateObject15$1 = _taggedTemplateLiteralLoose(["\n          ", ".set(", ", {\n            get: ", ",\n            set: ", "\n          });\n        "])), id, ref, getId ? getId.name : prop.scope.buildUndefinedNode(), setId ? setId.name : prop.scope.buildUndefinedNode()), prop);
      }
    }
    var helper = state.addHelper("classPrivateFieldInitSpec");
    return inheritLoc(inheritPropComments(template$1.statement.ast(_templateObject16$1 || (_templateObject16$1 = _taggedTemplateLiteralLoose(["", "(\n      ", ",\n      ", ",\n      {\n        get: ", ",\n        set: ", "\n      },\n    )"])), helper, thisExpression$4(), cloneNode$e(id), getId ? getId.name : prop.scope.buildUndefinedNode(), setId ? setId.name : prop.scope.buildUndefinedNode()), prop), prop.node);
  }
  function buildPrivateInstanceMethodInitialization(ref, prop, privateNamesMap, state) {
    var privateName = privateNamesMap.get(prop.node.key.id.name);
    var id = privateName.id;
    {
      if (!state.availableHelper("classPrivateMethodInitSpec")) {
        return inheritPropComments(template$1.statement.ast(_templateObject17$1 || (_templateObject17$1 = _taggedTemplateLiteralLoose(["", ".add(", ")"])), id, ref), prop);
      }
    }
    var helper = state.addHelper("classPrivateMethodInitSpec");
    return inheritPropComments(template$1.statement.ast(_templateObject18$1 || (_templateObject18$1 = _taggedTemplateLiteralLoose(["", "(\n      ", ",\n      ", "\n    )"])), helper, thisExpression$4(), cloneNode$e(id)), prop);
  }
  function buildPublicFieldInitLoose(ref, prop) {
    var _prop$node = prop.node,
      key = _prop$node.key,
      computed = _prop$node.computed;
    var value = prop.node.value || prop.scope.buildUndefinedNode();
    return inheritPropComments(expressionStatement$7(assignmentExpression$8("=", memberExpression$9(ref, key, computed || isLiteral$4(key)), value)), prop);
  }
  function buildPublicFieldInitSpec(ref, prop, state) {
    var _prop$node2 = prop.node,
      key = _prop$node2.key,
      computed = _prop$node2.computed;
    var value = prop.node.value || prop.scope.buildUndefinedNode();
    return inheritPropComments(expressionStatement$7(callExpression$c(state.addHelper("defineProperty"), [ref, computed || isLiteral$4(key) ? key : stringLiteral$6(key.name), value])), prop);
  }
  function buildPrivateStaticMethodInitLoose(ref, prop, state, privateNamesMap) {
    var privateName = privateNamesMap.get(prop.node.key.id.name);
    var id = privateName.id,
      methodId = privateName.methodId,
      getId = privateName.getId,
      setId = privateName.setId,
      initAdded = privateName.initAdded;
    if (initAdded) return;
    var isGetterOrSetter = getId || setId;
    if (isGetterOrSetter) {
      privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
        initAdded: true
      }));
      return inheritPropComments(template$1.statement.ast(_templateObject19$1 || (_templateObject19$1 = _taggedTemplateLiteralLoose(["\n        Object.defineProperty(", ", ", ", {\n          // configurable is false by default\n          // enumerable is false by default\n          // writable is false by default\n          get: ", ",\n          set: ", "\n        })\n      "])), ref, id, getId ? getId.name : prop.scope.buildUndefinedNode(), setId ? setId.name : prop.scope.buildUndefinedNode()), prop);
    }
    return inheritPropComments(template$1.statement.ast(_templateObject20$1 || (_templateObject20$1 = _taggedTemplateLiteralLoose(["\n      Object.defineProperty(", ", ", ", {\n        // configurable is false by default\n        // enumerable is false by default\n        // writable is false by default\n        value: ", "\n      });\n    "])), ref, id, methodId.name), prop);
  }
  function buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties) {
    if (privateFieldsAsSymbolsOrProperties === void 0) {
      privateFieldsAsSymbolsOrProperties = false;
    }
    var privateName = privateNamesMap.get(prop.node.key.id.name);
    var id = privateName.id,
      methodId = privateName.methodId,
      getId = privateName.getId,
      setId = privateName.setId,
      getterDeclared = privateName.getterDeclared,
      setterDeclared = privateName.setterDeclared,
      isStatic = privateName["static"];
    var _prop$node3 = prop.node,
      params = _prop$node3.params,
      body = _prop$node3.body,
      generator = _prop$node3.generator,
      async = _prop$node3.async;
    var isGetter = getId && params.length === 0;
    var isSetter = setId && params.length > 0;
    if (isGetter && getterDeclared || isSetter && setterDeclared) {
      privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
        initAdded: true
      }));
      return null;
    }
    if (newHelpers(file) && (isGetter || isSetter) && !privateFieldsAsSymbolsOrProperties) {
      var scope = prop.get("body").scope;
      var thisArg = scope.generateUidIdentifier("this");
      var state = {
        thisRef: thisArg,
        argumentsPath: []
      };
      prop.traverse(thisContextVisitor, state);
      if (state.argumentsPath.length) {
        var argumentsId = scope.generateUidIdentifier("arguments");
        scope.push({
          id: argumentsId,
          init: template$1.expression.ast(_templateObject21$1 || (_templateObject21$1 = _taggedTemplateLiteralLoose(["[].slice.call(arguments, 1)"])))
        });
        for (var _iterator4 = _createForOfIteratorHelperLoose(state.argumentsPath), _step4; !(_step4 = _iterator4()).done;) {
          var path = _step4.value;
          path.replaceWith(cloneNode$e(argumentsId));
        }
      }
      params.unshift(cloneNode$e(thisArg));
    }
    var declId = methodId;
    if (isGetter) {
      privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
        getterDeclared: true,
        initAdded: true
      }));
      declId = getId;
    } else if (isSetter) {
      privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
        setterDeclared: true,
        initAdded: true
      }));
      declId = setId;
    } else if (isStatic && !privateFieldsAsSymbolsOrProperties) {
      declId = id;
    }
    return inheritPropComments(functionDeclaration(cloneNode$e(declId), params, body, generator, async), prop);
  }
  var thisContextVisitor = environmentVisitor({
    Identifier: function Identifier(path, state) {
      if (state.argumentsPath && path.node.name === "arguments") {
        state.argumentsPath.push(path);
      }
    },
    UnaryExpression: function UnaryExpression(path) {
      var node = path.node;
      if (node.operator === "delete") {
        var argument = skipTransparentExprWrapperNodes(node.argument);
        if (isThisExpression$2(argument)) {
          path.replaceWith(booleanLiteral$2(true));
        }
      }
    },
    ThisExpression: function ThisExpression(path, state) {
      state.needsClassRef = true;
      path.replaceWith(cloneNode$e(state.thisRef));
    },
    MetaProperty: function MetaProperty(path) {
      var node = path.node,
        scope = path.scope;
      if (node.meta.name === "new" && node.property.name === "target") {
        path.replaceWith(scope.buildUndefinedNode());
      }
    }
  });
  var innerReferencesVisitor = {
    ReferencedIdentifier: function ReferencedIdentifier(path, state) {
      if (path.scope.bindingIdentifierEquals(path.node.name, state.innerBinding)) {
        state.needsClassRef = true;
        path.node.name = state.thisRef.name;
      }
    }
  };
  function replaceThisContext(path, ref, innerBindingRef) {
    var _state$thisRef;
    var state = {
      thisRef: ref,
      needsClassRef: false,
      innerBinding: innerBindingRef
    };
    if (!path.isMethod()) {
      path.traverse(thisContextVisitor, state);
    }
    if (innerBindingRef != null && (_state$thisRef = state.thisRef) != null && _state$thisRef.name && state.thisRef.name !== innerBindingRef.name) {
      path.traverse(innerReferencesVisitor, state);
    }
    return state.needsClassRef;
  }
  function isNameOrLength$1(_ref6) {
    var key = _ref6.key,
      computed = _ref6.computed;
    if (key.type === "Identifier") {
      return !computed && (key.name === "name" || key.name === "length");
    }
    if (key.type === "StringLiteral") {
      return key.value === "name" || key.value === "length";
    }
    return false;
  }
  function inheritPropComments(node, prop) {
    inheritLeadingComments$1(node, prop.node);
    inheritInnerComments(node, prop.node);
    return node;
  }
  function inheritLoc(node, original) {
    node.start = original.start;
    node.end = original.end;
    node.loc = original.loc;
    return node;
  }
  function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPublicClassFields, privateFieldsAsSymbolsOrProperties, noUninitializedPrivateFieldAccess, constantSuper, innerBindingRef) {
    var _ref7, _ref8;
    var classRefFlags = 0;
    var injectSuperRef;
    var staticNodes = [];
    var instanceNodes = [];
    var lastInstanceNodeReturnsThis = false;
    var pureStaticNodes = [];
    var classBindingNode = null;
    var getSuperRef = isIdentifier$e(superRef) ? function () {
      return superRef;
    } : function () {
      var _injectSuperRef;
      (_injectSuperRef = injectSuperRef) != null ? _injectSuperRef : injectSuperRef = props[0].scope.generateUidIdentifierBasedOnNode(superRef);
      return injectSuperRef;
    };
    var classRefForInnerBinding = (_ref7 = ref) != null ? _ref7 : props[0].scope.generateUidIdentifier((innerBindingRef == null ? void 0 : innerBindingRef.name) || "Class");
    (_ref8 = ref) != null ? _ref8 : ref = cloneNode$e(innerBindingRef);
    var _loop = function _loop() {
      var prop = _step5.value;
      if (prop.isClassProperty()) {
        assertFieldTransformed(prop);
      }
      var isStatic = !(isStaticBlock != null && isStaticBlock(prop.node)) && prop.node["static"];
      var isInstance = !isStatic;
      var isPrivate = prop.isPrivate();
      var isPublic = !isPrivate;
      var isField = prop.isProperty();
      var isMethod = !isField;
      var isStaticBlock$1 = prop.isStaticBlock == null ? void 0 : prop.isStaticBlock();
      if (isStatic) classRefFlags |= 1;
      if (isStatic || isMethod && isPrivate || isStaticBlock$1) {
        new ReplaceSupers({
          methodPath: prop,
          constantSuper: constantSuper,
          file: file,
          refToPreserve: innerBindingRef,
          getSuperRef: getSuperRef,
          getObjectRef: function getObjectRef() {
            classRefFlags |= 2;
            if (isStatic || isStaticBlock$1) {
              return classRefForInnerBinding;
            } else {
              return memberExpression$9(classRefForInnerBinding, identifier$d("prototype"));
            }
          }
        }).replace();
        var replaced = replaceThisContext(prop, classRefForInnerBinding, innerBindingRef);
        if (replaced) {
          classRefFlags |= 2;
        }
      }
      lastInstanceNodeReturnsThis = false;
      switch (true) {
        case isStaticBlock$1:
          {
            var blockBody = prop.node.body;
            if (blockBody.length === 1 && isExpressionStatement$2(blockBody[0])) {
              staticNodes.push(inheritPropComments(blockBody[0], prop));
            } else {
              staticNodes.push(inheritsComments$1(template$1.statement.ast(_templateObject22 || (_templateObject22 = _taggedTemplateLiteralLoose(["(() => { ", " })()"])), blockBody), prop.node));
            }
            break;
          }
        case isStatic && isPrivate && isField && privateFieldsAsSymbolsOrProperties:
          staticNodes.push(buildPrivateFieldInitLoose(cloneNode$e(ref), prop, privateNamesMap));
          break;
        case isStatic && isPrivate && isField && !privateFieldsAsSymbolsOrProperties:
          if (!newHelpers(file)) {
            staticNodes.push(buildPrivateStaticFieldInitSpecOld(prop, privateNamesMap));
          } else {
            staticNodes.push(buildPrivateStaticFieldInitSpec(prop, privateNamesMap, noUninitializedPrivateFieldAccess));
          }
          break;
        case isStatic && isPublic && isField && setPublicClassFields:
          if (!isNameOrLength$1(prop.node)) {
            staticNodes.push(buildPublicFieldInitLoose(cloneNode$e(ref), prop));
            break;
          }
        case isStatic && isPublic && isField && !setPublicClassFields:
          staticNodes.push(buildPublicFieldInitSpec(cloneNode$e(ref), prop, file));
          break;
        case isInstance && isPrivate && isField && privateFieldsAsSymbolsOrProperties:
          instanceNodes.push(buildPrivateFieldInitLoose(thisExpression$4(), prop, privateNamesMap));
          break;
        case isInstance && isPrivate && isField && !privateFieldsAsSymbolsOrProperties:
          instanceNodes.push(buildPrivateInstanceFieldInitSpec(thisExpression$4(), prop, privateNamesMap, file));
          break;
        case isInstance && isPrivate && isMethod && privateFieldsAsSymbolsOrProperties:
          instanceNodes.unshift(buildPrivateMethodInitLoose(thisExpression$4(), prop, privateNamesMap));
          pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
          break;
        case isInstance && isPrivate && isMethod && !privateFieldsAsSymbolsOrProperties:
          instanceNodes.unshift(buildPrivateInstanceMethodInitSpec(thisExpression$4(), prop, privateNamesMap, file));
          pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
          break;
        case isStatic && isPrivate && isMethod && !privateFieldsAsSymbolsOrProperties:
          if (!newHelpers(file)) {
            staticNodes.unshift(buildPrivateStaticFieldInitSpecOld(prop, privateNamesMap));
          }
          pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
          break;
        case isStatic && isPrivate && isMethod && privateFieldsAsSymbolsOrProperties:
          staticNodes.unshift(buildPrivateStaticMethodInitLoose(cloneNode$e(ref), prop, file, privateNamesMap));
          pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
          break;
        case isInstance && isPublic && isField && setPublicClassFields:
          instanceNodes.push(buildPublicFieldInitLoose(thisExpression$4(), prop));
          break;
        case isInstance && isPublic && isField && !setPublicClassFields:
          lastInstanceNodeReturnsThis = true;
          instanceNodes.push(buildPublicFieldInitSpec(thisExpression$4(), prop, file));
          break;
        default:
          throw new Error("Unreachable.");
      }
    };
    for (var _iterator5 = _createForOfIteratorHelperLoose(props), _step5; !(_step5 = _iterator5()).done;) {
      _loop();
    }
    if (classRefFlags & 2 && innerBindingRef != null) {
      classBindingNode = expressionStatement$7(assignmentExpression$8("=", cloneNode$e(classRefForInnerBinding), cloneNode$e(innerBindingRef)));
    }
    return {
      staticNodes: staticNodes.filter(Boolean),
      instanceNodes: instanceNodes.filter(Boolean),
      lastInstanceNodeReturnsThis: lastInstanceNodeReturnsThis,
      pureStaticNodes: pureStaticNodes.filter(Boolean),
      classBindingNode: classBindingNode,
      wrapClass: function wrapClass(path) {
        for (var _iterator6 = _createForOfIteratorHelperLoose(props), _step6; !(_step6 = _iterator6()).done;) {
          var prop = _step6.value;
          prop.node.leadingComments = null;
          prop.remove();
        }
        if (injectSuperRef) {
          path.scope.push({
            id: cloneNode$e(injectSuperRef)
          });
          path.set("superClass", assignmentExpression$8("=", injectSuperRef, path.node.superClass));
        }
        if (classRefFlags !== 0) {
          if (path.isClassExpression()) {
            path.scope.push({
              id: ref
            });
            path.replaceWith(assignmentExpression$8("=", cloneNode$e(ref), path.node));
          } else {
            if (innerBindingRef == null) {
              path.node.id = ref;
            }
            if (classBindingNode != null) {
              path.scope.push({
                id: classRefForInnerBinding
              });
            }
          }
        }
        return path;
      }
    };
  }

var _templateObject$y;
  var findBareSupers = environmentVisitor({
    Super: function Super(path) {
      var node = path.node,
        parentPath = path.parentPath;
      if (parentPath.isCallExpression({
        callee: node
      })) {
        this.push(parentPath);
      }
    }
  });
  var referenceVisitor = {
    "TSTypeAnnotation|TypeAnnotation": function TSTypeAnnotationTypeAnnotation(path) {
      path.skip();
    },
    ReferencedIdentifier: function ReferencedIdentifier(path, _ref) {
      var scope = _ref.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)) {
      var classNameTDZError = state.file.addHelper("classNameTDZError");
      var throwNode = callExpression$c(classNameTDZError, [stringLiteral$6(path.node.name)]);
      path.replaceWith(sequenceExpression$6([throwNode, path.node]));
      path.skip();
    }
  }
  var classFieldDefinitionEvaluationTDZVisitor = {
    ReferencedIdentifier: handleClassTDZ
  };
  function injectInitialization(path, constructor, nodes, renamer, lastReturnsThis) {
    if (!nodes.length) return;
    var isDerived = !!path.node.superClass;
    if (!constructor) {
      var newConstructor = classMethod("constructor", identifier$d("constructor"), [], blockStatement$6([]));
      if (isDerived) {
        newConstructor.params = [restElement$2(identifier$d("args"))];
        newConstructor.body.body.push(template$1.statement.ast(_templateObject$y || (_templateObject$y = _taggedTemplateLiteralLoose(["super(...args)"]))));
      }
      var _ref2 = path.get("body").unshiftContainer("body", newConstructor);
      var _ref3 = _slicedToArray(_ref2, 1);
      constructor = _ref3[0];
    }
    if (renamer) {
      renamer(referenceVisitor, {
        scope: constructor.scope
      });
    }
    if (isDerived) {
      var bareSupers = [];
      constructor.traverse(findBareSupers, bareSupers);
      var isFirst = true;
      for (var _i = 0, _bareSupers = bareSupers; _i < _bareSupers.length; _i++) {
        var bareSuper = _bareSupers[_i];
        if (isFirst) {
          isFirst = false;
        } else {
          nodes = nodes.map(function (n) {
            return cloneNode$e(n);
          });
        }
        if (!bareSuper.parentPath.isExpressionStatement()) {
          var allNodes = [bareSuper.node].concat(_toConsumableArray(nodes.map(function (n) {
            return toExpression$1(n);
          })));
          if (!lastReturnsThis) allNodes.push(thisExpression$4());
          bareSuper.replaceWith(sequenceExpression$6(allNodes));
        } else {
          bareSuper.insertAfter(nodes);
        }
      }
    } else {
      constructor.get("body").unshiftContainer("body", nodes);
    }
  }
  function memoiseComputedKey(keyNode, scope, hint) {
    var isUidReference = isIdentifier$e(keyNode) && scope.hasUid(keyNode.name);
    if (isUidReference) {
      return;
    }
    var isMemoiseAssignment = isAssignmentExpression$2(keyNode, {
      operator: "="
    }) && isIdentifier$e(keyNode.left) && scope.hasUid(keyNode.left.name);
    if (isMemoiseAssignment) {
      return cloneNode$e(keyNode);
    } else {
      var ident = identifier$d(hint);
      scope.push({
        id: ident,
        kind: "let"
      });
      return assignmentExpression$8("=", cloneNode$e(ident), keyNode);
    }
  }
  function extractComputedKeys(path, computedPaths, file) {
    var scope = path.scope;
    var declarations = [];
    var state = {
      classBinding: path.node.id && scope.getBinding(path.node.id.name),
      file: file
    };
    for (var _iterator = _createForOfIteratorHelperLoose(computedPaths), _step; !(_step = _iterator()).done;) {
      var computedPath = _step.value;
      var computedKey = computedPath.get("key");
      if (computedKey.isReferencedIdentifier()) {
        handleClassTDZ(computedKey, state);
      } else {
        computedKey.traverse(classFieldDefinitionEvaluationTDZVisitor, state);
      }
      var computedNode = computedPath.node;
      if (!computedKey.isConstantExpression()) {
        var assignment = memoiseComputedKey(computedKey.node, scope, scope.generateUidBasedOnNode(computedKey.node));
        if (assignment) {
          declarations.push(expressionStatement$7(assignment));
          computedNode.key = cloneNode$e(assignment.left);
        }
      }
    }
    return declarations;
  }

var _templateObject$x, _templateObject2$f, _templateObject3$b, _templateObject4$6, _templateObject5$3;
  function incrementId(id, idx) {
    if (idx === void 0) {
      idx = id.length - 1;
    }
    if (idx === -1) {
      id.unshift(65);
      return;
    }
    var current = id[idx];
    if (current === 90) {
      id[idx] = 97;
    } else if (current === 122) {
      id[idx] = 65;
      incrementId(id, idx - 1);
    } else {
      id[idx] = current + 1;
    }
  }
  function createPrivateUidGeneratorForClass(classPath) {
    var currentPrivateId = [];
    var privateNames = new Set();
    classPath.traverse({
      PrivateName: function PrivateName(path) {
        privateNames.add(path.node.id.name);
      }
    });
    return function () {
      var reifiedId;
      do {
        incrementId(currentPrivateId);
        reifiedId = String.fromCharCode.apply(String, currentPrivateId);
      } while (privateNames.has(reifiedId));
      return privateName(identifier$d(reifiedId));
    };
  }
  function createLazyPrivateUidGeneratorForClass(classPath) {
    var generator;
    return function () {
      if (!generator) {
        generator = createPrivateUidGeneratorForClass(classPath);
      }
      return generator();
    };
  }
  function replaceClassWithVar(path, className) {
    var id = path.node.id;
    var scope = path.scope;
    if (path.type === "ClassDeclaration") {
      var _className = id.name;
      var varId = scope.generateUidIdentifierBasedOnNode(id);
      var classId = identifier$d(_className);
      scope.rename(_className, varId.name);
      path.get("id").replaceWith(classId);
      return {
        id: cloneNode$e(varId),
        path: path
      };
    } else {
      var _varId;
      if (id) {
        className = id.name;
        _varId = generateLetUidIdentifier(scope.parent, className);
        scope.rename(className, _varId.name);
      } else {
        _varId = generateLetUidIdentifier(scope.parent, typeof className === "string" ? className : "decorated_class");
      }
      var newClassExpr = classExpression(typeof className === "string" ? identifier$d(className) : null, path.node.superClass, path.node.body);
      var _path$replaceWith = path.replaceWith(sequenceExpression$6([newClassExpr, _varId])),
        _path$replaceWith2 = _slicedToArray(_path$replaceWith, 1),
        newPath = _path$replaceWith2[0];
      return {
        id: cloneNode$e(_varId),
        path: newPath.get("expressions.0")
      };
    }
  }
  function generateClassProperty(key, value, isStatic) {
    if (key.type === "PrivateName") {
      return classPrivateProperty(key, value, undefined, isStatic);
    } else {
      return classProperty(key, value, undefined, undefined, isStatic);
    }
  }
  function assignIdForAnonymousClass(path, className) {
    if (!path.node.id) {
      path.node.id = typeof className === "string" ? identifier$d(className) : path.scope.generateUidIdentifier("Class");
    }
  }
  function addProxyAccessorsFor(className, element, getterKey, setterKey, targetKey, isComputed, isStatic, version) {
    var thisArg = (version === "2023-11" || version === "2023-05") && isStatic ? className : thisExpression$4();
    var getterBody = blockStatement$6([returnStatement$3(memberExpression$9(cloneNode$e(thisArg), cloneNode$e(targetKey)))]);
    var setterBody = blockStatement$6([expressionStatement$7(assignmentExpression$8("=", memberExpression$9(cloneNode$e(thisArg), cloneNode$e(targetKey)), identifier$d("v")))]);
    var getter, setter;
    if (getterKey.type === "PrivateName") {
      getter = classPrivateMethod("get", getterKey, [], getterBody, isStatic);
      setter = classPrivateMethod("set", setterKey, [identifier$d("v")], setterBody, isStatic);
    } else {
      getter = classMethod("get", getterKey, [], getterBody, isComputed, isStatic);
      setter = classMethod("set", setterKey, [identifier$d("v")], setterBody, isComputed, isStatic);
    }
    element.insertAfter(setter);
    element.insertAfter(getter);
  }
  function extractProxyAccessorsFor(targetKey, version) {
    if (version !== "2023-11" && version !== "2023-05" && version !== "2023-01") {
      return [template$1.expression.ast(_templateObject$x || (_templateObject$x = _taggedTemplateLiteralLoose(["\n        function () {\n          return this.", ";\n        }\n      "])), cloneNode$e(targetKey)), template$1.expression.ast(_templateObject2$f || (_templateObject2$f = _taggedTemplateLiteralLoose(["\n        function (value) {\n          this.", " = value;\n        }\n      "])), cloneNode$e(targetKey))];
    }
    return [template$1.expression.ast(_templateObject3$b || (_templateObject3$b = _taggedTemplateLiteralLoose(["\n      o => o.", "\n    "])), cloneNode$e(targetKey)), template$1.expression.ast(_templateObject4$6 || (_templateObject4$6 = _taggedTemplateLiteralLoose(["\n      (o, v) => o.", " = v\n    "])), cloneNode$e(targetKey))];
  }
  function getComputedKeyLastElement(path) {
    path = skipTransparentExprWrappers(path);
    if (path.isSequenceExpression()) {
      var expressions = path.get("expressions");
      return getComputedKeyLastElement(expressions[expressions.length - 1]);
    }
    return path;
  }
  function getComputedKeyMemoiser(path) {
    var element = getComputedKeyLastElement(path);
    if (element.isConstantExpression()) {
      return cloneNode$e(path.node);
    } else if (element.isIdentifier() && path.scope.hasUid(element.node.name)) {
      return cloneNode$e(path.node);
    } else if (element.isAssignmentExpression() && element.get("left").isIdentifier()) {
      return cloneNode$e(element.node.left);
    } else {
      throw new Error("Internal Error: the computed key " + path.toString() + " has not yet been memoised.");
    }
  }
  function prependExpressionsToComputedKey(expressions, fieldPath) {
    var key = fieldPath.get("key");
    if (key.isSequenceExpression()) {
      expressions.push.apply(expressions, _toConsumableArray(key.node.expressions));
    } else {
      expressions.push(key.node);
    }
    key.replaceWith(maybeSequenceExpression(expressions));
  }
  function appendExpressionsToComputedKey(expressions, fieldPath) {
    var key = fieldPath.get("key");
    var completion = getComputedKeyLastElement(key);
    if (completion.isConstantExpression()) {
      prependExpressionsToComputedKey(expressions, fieldPath);
    } else {
      var scopeParent = key.scope.parent;
      var maybeAssignment = memoiseComputedKey(completion.node, scopeParent, scopeParent.generateUid("computedKey"));
      if (!maybeAssignment) {
        prependExpressionsToComputedKey(expressions, fieldPath);
      } else {
        var expressionSequence = [].concat(_toConsumableArray(expressions), [cloneNode$e(maybeAssignment.left)]);
        var completionParent = completion.parentPath;
        if (completionParent.isSequenceExpression()) {
          completionParent.pushContainer("expressions", expressionSequence);
        } else {
          completion.replaceWith(maybeSequenceExpression([cloneNode$e(maybeAssignment)].concat(_toConsumableArray(expressionSequence))));
        }
      }
    }
  }
  function prependExpressionsToFieldInitializer(expressions, fieldPath) {
    var initializer = fieldPath.get("value");
    if (initializer.node) {
      expressions.push(initializer.node);
    } else if (expressions.length > 0) {
      expressions[expressions.length - 1] = unaryExpression$4("void", expressions[expressions.length - 1]);
    }
    initializer.replaceWith(maybeSequenceExpression(expressions));
  }
  function prependExpressionsToStaticBlock(expressions, blockPath) {
    blockPath.unshiftContainer("body", expressionStatement$7(maybeSequenceExpression(expressions)));
  }
  function prependExpressionsToConstructor(expressions, constructorPath) {
    constructorPath.node.body.body.unshift(expressionStatement$7(maybeSequenceExpression(expressions)));
  }
  function isProtoInitCallExpression(expression, protoInitCall) {
    return isCallExpression$8(expression) && isIdentifier$e(expression.callee, {
      name: protoInitCall.name
    });
  }
  function optimizeSuperCallAndExpressions(expressions, protoInitLocal) {
    if (protoInitLocal) {
      if (expressions.length >= 2 && isProtoInitCallExpression(expressions[1], protoInitLocal)) {
        var mergedSuperCall = callExpression$c(cloneNode$e(protoInitLocal), [expressions[0]]);
        expressions.splice(0, 2, mergedSuperCall);
      }
      if (expressions.length >= 2 && isThisExpression$2(expressions[expressions.length - 1]) && isProtoInitCallExpression(expressions[expressions.length - 2], protoInitLocal)) {
        expressions.splice(expressions.length - 1, 1);
      }
    }
    return maybeSequenceExpression(expressions);
  }
  function insertExpressionsAfterSuperCallAndOptimize(expressions, constructorPath, protoInitLocal) {
    constructorPath.traverse({
      CallExpression: {
        exit: function exit(path) {
          if (!path.get("callee").isSuper()) return;
          var newNodes = [path.node].concat(_toConsumableArray(expressions.map(function (expr) {
            return cloneNode$e(expr);
          })));
          if (path.isCompletionRecord()) {
            newNodes.push(thisExpression$4());
          }
          path.replaceWith(optimizeSuperCallAndExpressions(newNodes, protoInitLocal));
          path.skip();
        }
      },
      ClassMethod: function ClassMethod(path) {
        if (path.node.kind === "constructor") {
          path.skip();
        }
      }
    });
  }
  function createConstructorFromExpressions(expressions, isDerivedClass) {
    var body = [expressionStatement$7(maybeSequenceExpression(expressions))];
    if (isDerivedClass) {
      body.unshift(expressionStatement$7(callExpression$c(_super$1(), [spreadElement$2(identifier$d("args"))])));
    }
    return classMethod("constructor", identifier$d("constructor"), isDerivedClass ? [restElement$2(identifier$d("args"))] : [], blockStatement$6(body));
  }
  function createStaticBlockFromExpressions(expressions) {
    return staticBlock([expressionStatement$7(maybeSequenceExpression(expressions))]);
  }
  var FIELD = 0;
  var ACCESSOR = 1;
  var METHOD = 2;
  var GETTER = 3;
  var SETTER = 4;
  var STATIC_OLD_VERSION = 5;
  var STATIC = 8;
  var DECORATORS_HAVE_THIS = 16;
  function getElementKind(element) {
    switch (element.node.type) {
      case "ClassProperty":
      case "ClassPrivateProperty":
        return FIELD;
      case "ClassAccessorProperty":
        return ACCESSOR;
      case "ClassMethod":
      case "ClassPrivateMethod":
        if (element.node.kind === "get") {
          return GETTER;
        } else if (element.node.kind === "set") {
          return SETTER;
        } else {
          return METHOD;
        }
    }
  }
  function toSortedDecoratorInfo(info) {
    return [].concat(_toConsumableArray(info.filter(function (el) {
      return el.isStatic && el.kind >= ACCESSOR && el.kind <= SETTER;
    })), _toConsumableArray(info.filter(function (el) {
      return !el.isStatic && el.kind >= ACCESSOR && el.kind <= SETTER;
    })), _toConsumableArray(info.filter(function (el) {
      return el.isStatic && el.kind === FIELD;
    })), _toConsumableArray(info.filter(function (el) {
      return !el.isStatic && el.kind === FIELD;
    })));
  }
  function generateDecorationList(decorators, decoratorsThis, version) {
    var decsCount = decorators.length;
    var haveOneThis = decoratorsThis.some(Boolean);
    var decs = [];
    for (var i = 0; i < decsCount; i++) {
      if ((version === "2023-11" || version === "2023-05") && haveOneThis) {
        decs.push(decoratorsThis[i] || unaryExpression$4("void", numericLiteral$5(0)));
      }
      decs.push(decorators[i].expression);
    }
    return {
      haveThis: haveOneThis,
      decs: decs
    };
  }
  function generateDecorationExprs(decorationInfo, version) {
    return arrayExpression$1(decorationInfo.map(function (el) {
      var flag = el.kind;
      if (el.isStatic) {
        flag += version === "2023-11" || version === "2023-05" ? STATIC : STATIC_OLD_VERSION;
      }
      if (el.decoratorsHaveThis) flag += DECORATORS_HAVE_THIS;
      return arrayExpression$1([el.decoratorsArray, numericLiteral$5(flag), el.name].concat(_toConsumableArray(el.privateMethods || [])));
    }));
  }
  function extractElementLocalAssignments(decorationInfo) {
    var localIds = [];
    for (var _iterator = _createForOfIteratorHelperLoose(decorationInfo), _step; !(_step = _iterator()).done;) {
      var el = _step.value;
      var locals = el.locals;
      if (Array.isArray(locals)) {
        localIds.push.apply(localIds, _toConsumableArray(locals));
      } else if (locals !== undefined) {
        localIds.push(locals);
      }
    }
    return localIds;
  }
  function addCallAccessorsFor(version, element, key, getId, setId, isStatic) {
    element.insertAfter(classPrivateMethod("get", cloneNode$e(key), [], blockStatement$6([returnStatement$3(callExpression$c(cloneNode$e(getId), version === "2023-11" && isStatic ? [] : [thisExpression$4()]))]), isStatic));
    element.insertAfter(classPrivateMethod("set", cloneNode$e(key), [identifier$d("v")], blockStatement$6([expressionStatement$7(callExpression$c(cloneNode$e(setId), version === "2023-11" && isStatic ? [identifier$d("v")] : [thisExpression$4(), identifier$d("v")]))]), isStatic));
  }
  function movePrivateAccessor(element, key, methodLocalVar, isStatic) {
    var params;
    var block;
    if (element.node.kind === "set") {
      params = [identifier$d("v")];
      block = [expressionStatement$7(callExpression$c(methodLocalVar, [thisExpression$4(), identifier$d("v")]))];
    } else {
      params = [];
      block = [returnStatement$3(callExpression$c(methodLocalVar, [thisExpression$4()]))];
    }
    element.replaceWith(classPrivateMethod(element.node.kind, cloneNode$e(key), params, blockStatement$6(block), isStatic));
  }
  function isClassDecoratableElementPath(path) {
    var type = path.type;
    return type !== "TSDeclareMethod" && type !== "TSIndexSignature" && type !== "StaticBlock";
  }
  function staticBlockToIIFE(block) {
    return callExpression$c(arrowFunctionExpression$4([], blockStatement$6(block.body)), []);
  }
  function staticBlockToFunctionClosure(block) {
    return functionExpression$2(null, [], blockStatement$6(block.body));
  }
  function fieldInitializerToClosure(value) {
    return functionExpression$2(null, [], blockStatement$6([returnStatement$3(value)]));
  }
  function maybeSequenceExpression(exprs) {
    if (exprs.length === 0) return unaryExpression$4("void", numericLiteral$5(0));
    if (exprs.length === 1) return exprs[0];
    return sequenceExpression$6(exprs);
  }
  function createFunctionExpressionFromPrivateMethod(node) {
    var params = node.params,
      body = node.body,
      isGenerator = node.generator,
      isAsync = node.async;
    return functionExpression$2(undefined, params, body, isGenerator, isAsync);
  }
  function createSetFunctionNameCall(state, className) {
    return callExpression$c(state.addHelper("setFunctionName"), [thisExpression$4(), className]);
  }
  function createToPropertyKeyCall(state, propertyKey) {
    return callExpression$c(state.addHelper("toPropertyKey"), [propertyKey]);
  }
  function createPrivateBrandCheckClosure(brandName) {
    return arrowFunctionExpression$4([identifier$d("_")], binaryExpression$4("in", cloneNode$e(brandName), identifier$d("_")));
  }
  function usesPrivateField(expression) {
    try {
      traverseFast$3(expression, function (node) {
        if (isPrivateName$2(node)) {
          throw null;
        }
      });
      return false;
    } catch (_unused) {
      return true;
    }
  }
  function convertToComputedKey(path) {
    var node = path.node;
    node.computed = true;
    if (isIdentifier$e(node.key)) {
      node.key = stringLiteral$6(node.key.name);
    }
  }
  function hasInstancePrivateAccess(path, privateNames) {
    var containsInstancePrivateAccess = false;
    if (privateNames.length > 0) {
      var privateNameVisitor = privateNameVisitorFactory({
        PrivateName: function PrivateName(path, state) {
          if (state.privateNamesMap.has(path.node.id.name)) {
            containsInstancePrivateAccess = true;
            path.stop();
          }
        }
      });
      var privateNamesMap = new Map();
      for (var _iterator2 = _createForOfIteratorHelperLoose(privateNames), _step2; !(_step2 = _iterator2()).done;) {
        var name = _step2.value;
        privateNamesMap.set(name, null);
      }
      path.traverse(privateNameVisitor, {
        privateNamesMap: privateNamesMap
      });
    }
    return containsInstancePrivateAccess;
  }
  function checkPrivateMethodUpdateError(path, decoratedPrivateMethods) {
    var privateNameVisitor = privateNameVisitorFactory({
      PrivateName: function PrivateName(path, state) {
        if (!state.privateNamesMap.has(path.node.id.name)) return;
        var parentPath = path.parentPath;
        var parentParentPath = parentPath.parentPath;
        if (parentParentPath.node.type === "AssignmentExpression" && parentParentPath.node.left === parentPath.node || parentParentPath.node.type === "UpdateExpression" || parentParentPath.node.type === "RestElement" || parentParentPath.node.type === "ArrayPattern" || parentParentPath.node.type === "ObjectProperty" && parentParentPath.node.value === parentPath.node && parentParentPath.parentPath.type === "ObjectPattern" || parentParentPath.node.type === "ForOfStatement" && parentParentPath.node.left === parentPath.node) {
          throw path.buildCodeFrameError("Decorated private methods are read-only, but \"#" + path.node.id.name + "\" is updated via this expression.");
        }
      }
    });
    var privateNamesMap = new Map();
    for (var _iterator3 = _createForOfIteratorHelperLoose(decoratedPrivateMethods), _step3; !(_step3 = _iterator3()).done;) {
      var name = _step3.value;
      privateNamesMap.set(name, null);
    }
    path.traverse(privateNameVisitor, {
      privateNamesMap: privateNamesMap
    });
  }
  function transformClass$1(path, state, constantSuper, ignoreFunctionLength, className, propertyVisitor, version) {
    var _path$node$id, _classDecorationsId;
    var body = path.get("body.body");
    var classDecorators = path.node.decorators;
    var hasElementDecorators = false;
    var hasComputedKeysSideEffects = false;
    var elemDecsUseFnContext = false;
    var generateClassPrivateUid = createLazyPrivateUidGeneratorForClass(path);
    var classAssignments = [];
    var scopeParent = path.scope.parent;
    var memoiseExpression = function memoiseExpression(expression, hint, assignments) {
      var localEvaluatedId = generateLetUidIdentifier(scopeParent, hint);
      assignments.push(assignmentExpression$8("=", localEvaluatedId, expression));
      return cloneNode$e(localEvaluatedId);
    };
    var protoInitLocal;
    var staticInitLocal;
    var classIdName = (_path$node$id = path.node.id) == null ? void 0 : _path$node$id.name;
    var setClassName = typeof className === "object" ? className : undefined;
    var usesFunctionContextOrYieldAwait = function usesFunctionContextOrYieldAwait(decorator) {
      try {
        traverseFast$3(decorator, function (node) {
          if (isThisExpression$2(node) || isSuper$2(node) || isYieldExpression$1(node) || isAwaitExpression(node) || isIdentifier$e(node, {
            name: "arguments"
          }) || classIdName && isIdentifier$e(node, {
            name: classIdName
          }) || isMetaProperty$1(node) && node.meta.name !== "import") {
            throw null;
          }
        });
        return false;
      } catch (_unused2) {
        return true;
      }
    };
    var instancePrivateNames = [];
    for (var _iterator4 = _createForOfIteratorHelperLoose(body), _step4; !(_step4 = _iterator4()).done;) {
      var _element2 = _step4.value;
      if (!isClassDecoratableElementPath(_element2)) {
        continue;
      }
      var elementNode = _element2.node;
      if (!elementNode["static"] && isPrivateName$2(elementNode.key)) {
        instancePrivateNames.push(elementNode.key.id.name);
      }
      if (isDecorated(elementNode)) {
        switch (elementNode.type) {
          case "ClassProperty":
            propertyVisitor.ClassProperty(_element2, state);
            break;
          case "ClassPrivateProperty":
            propertyVisitor.ClassPrivateProperty(_element2, state);
            break;
          case "ClassAccessorProperty":
            propertyVisitor.ClassAccessorProperty(_element2, state);
            if (version === "2023-11") {
              break;
            }
          default:
            if (elementNode["static"]) {
              var _staticInitLocal;
              (_staticInitLocal = staticInitLocal) != null ? _staticInitLocal : staticInitLocal = generateLetUidIdentifier(scopeParent, "initStatic");
            } else {
              var _protoInitLocal;
              (_protoInitLocal = protoInitLocal) != null ? _protoInitLocal : protoInitLocal = generateLetUidIdentifier(scopeParent, "initProto");
            }
            break;
        }
        hasElementDecorators = true;
        elemDecsUseFnContext || (elemDecsUseFnContext = elementNode.decorators.some(usesFunctionContextOrYieldAwait));
      } else if (elementNode.type === "ClassAccessorProperty") {
        propertyVisitor.ClassAccessorProperty(_element2, state);
        var _key3 = elementNode.key,
          _value = elementNode.value,
          _isStatic = elementNode["static"],
          computed = elementNode.computed;
        var _newId = generateClassPrivateUid();
        var _newField = generateClassProperty(_newId, _value, _isStatic);
        var keyPath = _element2.get("key");
        var _element2$replaceWith = _element2.replaceWith(_newField),
          _element2$replaceWith2 = _slicedToArray(_element2$replaceWith, 1),
          _newPath2 = _element2$replaceWith2[0];
        var getterKey = void 0,
          setterKey = void 0;
        if (computed && !keyPath.isConstantExpression()) {
          getterKey = memoiseComputedKey(createToPropertyKeyCall(state, _key3), scopeParent, scopeParent.generateUid("computedKey"));
          setterKey = cloneNode$e(getterKey.left);
        } else {
          getterKey = cloneNode$e(_key3);
          setterKey = cloneNode$e(_key3);
        }
        assignIdForAnonymousClass(path, className);
        addProxyAccessorsFor(path.node.id, _newPath2, getterKey, setterKey, _newId, computed, _isStatic, version);
      }
      if ("computed" in _element2.node && _element2.node.computed) {
        hasComputedKeysSideEffects || (hasComputedKeysSideEffects = !scopeParent.isStatic(_element2.node.key));
      }
    }
    if (!classDecorators && !hasElementDecorators) {
      if (!path.node.id && typeof className === "string") {
        path.node.id = identifier$d(className);
      }
      if (setClassName) {
        path.node.body.body.unshift(createStaticBlockFromExpressions([createSetFunctionNameCall(state, setClassName)]));
      }
      return;
    }
    var elementDecoratorInfo = [];
    var constructorPath;
    var decoratedPrivateMethods = new Set();
    var classInitLocal, classIdLocal;
    var decoratorReceiverId = null;
    function handleDecorators(decorators) {
      var hasSideEffects = false;
      var usesFnContext = false;
      var decoratorsThis = [];
      for (var _iterator5 = _createForOfIteratorHelperLoose(decorators), _step5; !(_step5 = _iterator5()).done;) {
        var decorator = _step5.value;
        var expression = decorator.expression;
        var object = void 0;
        if ((version === "2023-11" || version === "2023-05") && isMemberExpression$7(expression)) {
          if (isSuper$2(expression.object)) {
            object = thisExpression$4();
          } else if (scopeParent.isStatic(expression.object)) {
            object = cloneNode$e(expression.object);
          } else {
            var _decoratorReceiverId;
            (_decoratorReceiverId = decoratorReceiverId) != null ? _decoratorReceiverId : decoratorReceiverId = generateLetUidIdentifier(scopeParent, "obj");
            object = assignmentExpression$8("=", cloneNode$e(decoratorReceiverId), expression.object);
            expression.object = cloneNode$e(decoratorReceiverId);
          }
        }
        decoratorsThis.push(object);
        hasSideEffects || (hasSideEffects = !scopeParent.isStatic(expression));
        usesFnContext || (usesFnContext = usesFunctionContextOrYieldAwait(decorator));
      }
      return {
        hasSideEffects: hasSideEffects,
        usesFnContext: usesFnContext,
        decoratorsThis: decoratorsThis
      };
    }
    var willExtractSomeElemDecs = hasComputedKeysSideEffects || elemDecsUseFnContext || version !== "2023-11";
    var needsDeclaraionForClassBinding = false;
    var classDecorationsFlag = 0;
    var classDecorations = [];
    var classDecorationsId;
    var computedKeyAssignments = [];
    if (classDecorators) {
      classInitLocal = generateLetUidIdentifier(scopeParent, "initClass");
      needsDeclaraionForClassBinding = path.isClassDeclaration();
      var _replaceClassWithVar = replaceClassWithVar(path, className);
      classIdLocal = _replaceClassWithVar.id;
      path = _replaceClassWithVar.path;
      path.node.decorators = null;
      var classDecsUsePrivateName = classDecorators.some(usesPrivateField);
      var _handleDecorators = handleDecorators(classDecorators),
        hasSideEffects = _handleDecorators.hasSideEffects,
        usesFnContext = _handleDecorators.usesFnContext,
        decoratorsThis = _handleDecorators.decoratorsThis;
      var _generateDecorationLi = generateDecorationList(classDecorators, decoratorsThis, version),
        haveThis = _generateDecorationLi.haveThis,
        decs = _generateDecorationLi.decs;
      classDecorationsFlag = haveThis ? 1 : 0;
      classDecorations = decs;
      if (usesFnContext || hasSideEffects && willExtractSomeElemDecs || classDecsUsePrivateName) {
        classDecorationsId = memoiseExpression(arrayExpression$1(classDecorations), "classDecs", classAssignments);
      }
      if (!hasElementDecorators) {
        for (var _iterator6 = _createForOfIteratorHelperLoose(path.get("body.body")), _step6; !(_step6 = _iterator6()).done;) {
          var element = _step6.value;
          var node = element.node;
          var isComputed = "computed" in node && node.computed;
          if (isComputed) {
            if (element.isClassProperty({
              "static": true
            })) {
              if (!element.get("key").isConstantExpression()) {
                var key = node.key;
                var maybeAssignment = memoiseComputedKey(key, scopeParent, scopeParent.generateUid("computedKey"));
                if (maybeAssignment != null) {
                  node.key = cloneNode$e(maybeAssignment.left);
                  computedKeyAssignments.push(maybeAssignment);
                }
              }
            } else if (computedKeyAssignments.length > 0) {
              prependExpressionsToComputedKey(computedKeyAssignments, element);
              computedKeyAssignments = [];
            }
          }
        }
      }
    } else {
      assignIdForAnonymousClass(path, className);
      classIdLocal = cloneNode$e(path.node.id);
    }
    var lastInstancePrivateName;
    var needsInstancePrivateBrandCheck = false;
    var fieldInitializerExpressions = [];
    var staticFieldInitializerExpressions = [];
    if (hasElementDecorators) {
      if (protoInitLocal) {
        var protoInitCall = callExpression$c(cloneNode$e(protoInitLocal), [thisExpression$4()]);
        fieldInitializerExpressions.push(protoInitCall);
      }
      for (var _iterator7 = _createForOfIteratorHelperLoose(body), _step7; !(_step7 = _iterator7()).done;) {
        var _element = _step7.value;
        if (!isClassDecoratableElementPath(_element)) {
          if (staticFieldInitializerExpressions.length > 0 && _element.isStaticBlock()) {
            prependExpressionsToStaticBlock(staticFieldInitializerExpressions, _element);
            staticFieldInitializerExpressions = [];
          }
          continue;
        }
        var _node = _element.node;
        var decorators = _node.decorators;
        var hasDecorators = !!(decorators != null && decorators.length);
        var _isComputed = "computed" in _node && _node.computed;
        var name = "computedKey";
        if (_node.key.type === "PrivateName") {
          name = _node.key.id.name;
        } else if (!_isComputed && _node.key.type === "Identifier") {
          name = _node.key.name;
        }
        var decoratorsArray = void 0;
        var decoratorsHaveThis = void 0;
        if (hasDecorators) {
          var _handleDecorators2 = handleDecorators(decorators),
            _hasSideEffects = _handleDecorators2.hasSideEffects,
            _usesFnContext = _handleDecorators2.usesFnContext,
            _decoratorsThis = _handleDecorators2.decoratorsThis;
          var _generateDecorationLi2 = generateDecorationList(decorators, _decoratorsThis, version),
            _decs = _generateDecorationLi2.decs,
            _haveThis = _generateDecorationLi2.haveThis;
          decoratorsHaveThis = _haveThis;
          decoratorsArray = _decs.length === 1 ? _decs[0] : arrayExpression$1(_decs);
          if (_usesFnContext || _hasSideEffects && willExtractSomeElemDecs) {
            decoratorsArray = memoiseExpression(decoratorsArray, name + "Decs", computedKeyAssignments);
          }
        }
        if (_isComputed) {
          if (!_element.get("key").isConstantExpression()) {
            var _key = _node.key;
            var _maybeAssignment = memoiseComputedKey(hasDecorators ? createToPropertyKeyCall(state, _key) : _key, scopeParent, scopeParent.generateUid("computedKey"));
            if (_maybeAssignment != null) {
              if (classDecorators && _element.isClassProperty({
                "static": true
              })) {
                _node.key = cloneNode$e(_maybeAssignment.left);
                computedKeyAssignments.push(_maybeAssignment);
              } else {
                _node.key = _maybeAssignment;
              }
            }
          }
        }
        var _key2 = _node.key,
          isStatic = _node["static"];
        var isPrivate = _key2.type === "PrivateName";
        var kind = getElementKind(_element);
        if (isPrivate && !isStatic) {
          if (hasDecorators) {
            needsInstancePrivateBrandCheck = true;
          }
          if (isClassPrivateProperty(_node) || !lastInstancePrivateName) {
            lastInstancePrivateName = _key2;
          }
        }
        if (_element.isClassMethod({
          kind: "constructor"
        })) {
          constructorPath = _element;
        }
        var locals = void 0;
        if (hasDecorators) {
          var privateMethods = void 0;
          var nameExpr = void 0;
          if (_isComputed) {
            nameExpr = getComputedKeyMemoiser(_element.get("key"));
          } else if (_key2.type === "PrivateName") {
            nameExpr = stringLiteral$6(_key2.id.name);
          } else if (_key2.type === "Identifier") {
            nameExpr = stringLiteral$6(_key2.name);
          } else {
            nameExpr = cloneNode$e(_key2);
          }
          if (kind === ACCESSOR) {
            var _ref = _element.node,
              value = _ref.value;
            var params = version === "2023-11" && isStatic ? [] : [thisExpression$4()];
            if (value) {
              params.push(cloneNode$e(value));
            }
            var newId = generateClassPrivateUid();
            var newFieldInitId = generateLetUidIdentifier(scopeParent, "init_" + name);
            var newValue = callExpression$c(cloneNode$e(newFieldInitId), params);
            var newField = generateClassProperty(newId, newValue, isStatic);
            var _element$replaceWith = _element.replaceWith(newField),
              _element$replaceWith2 = _slicedToArray(_element$replaceWith, 1),
              newPath = _element$replaceWith2[0];
            if (isPrivate) {
              privateMethods = extractProxyAccessorsFor(newId, version);
              var getId = generateLetUidIdentifier(scopeParent, "get_" + name);
              var setId = generateLetUidIdentifier(scopeParent, "set_" + name);
              addCallAccessorsFor(version, newPath, _key2, getId, setId, isStatic);
              locals = [newFieldInitId, getId, setId];
            } else {
              assignIdForAnonymousClass(path, className);
              addProxyAccessorsFor(path.node.id, newPath, cloneNode$e(_key2), isAssignmentExpression$2(_key2) ? cloneNode$e(_key2.left) : cloneNode$e(_key2), newId, _isComputed, isStatic, version);
              locals = [newFieldInitId];
            }
          } else if (kind === FIELD) {
            var initId = generateLetUidIdentifier(scopeParent, "init_" + name);
            var valuePath = _element.get("value");
            var args = version === "2023-11" && isStatic ? [] : [thisExpression$4()];
            if (valuePath.node) args.push(valuePath.node);
            valuePath.replaceWith(callExpression$c(cloneNode$e(initId), args));
            locals = [initId];
            if (isPrivate) {
              privateMethods = extractProxyAccessorsFor(_key2, version);
            }
          } else if (isPrivate) {
            var callId = generateLetUidIdentifier(scopeParent, "call_" + name);
            locals = [callId];
            var replaceSupers = new ReplaceSupers({
              constantSuper: constantSuper,
              methodPath: _element,
              objectRef: classIdLocal,
              superRef: path.node.superClass,
              file: state.file,
              refToPreserve: classIdLocal
            });
            replaceSupers.replace();
            privateMethods = [createFunctionExpressionFromPrivateMethod(_element.node)];
            if (kind === GETTER || kind === SETTER) {
              movePrivateAccessor(_element, cloneNode$e(_key2), cloneNode$e(callId), isStatic);
            } else {
              var _node2 = _element.node;
              path.node.body.body.unshift(classPrivateProperty(_key2, cloneNode$e(callId), [], _node2["static"]));
              decoratedPrivateMethods.add(_key2.id.name);
              _element.remove();
            }
          }
          elementDecoratorInfo.push({
            kind: kind,
            decoratorsArray: decoratorsArray,
            decoratorsHaveThis: decoratorsHaveThis,
            name: nameExpr,
            isStatic: isStatic,
            privateMethods: privateMethods,
            locals: locals
          });
          if (_element.node) {
            _element.node.decorators = null;
          }
        }
        if (_isComputed && computedKeyAssignments.length > 0) {
          if (classDecorators && _element.isClassProperty({
            "static": true
          })) ; else {
            prependExpressionsToComputedKey(computedKeyAssignments, kind === ACCESSOR ? _element.getNextSibling() : _element);
            computedKeyAssignments = [];
          }
        }
        if (fieldInitializerExpressions.length > 0 && !isStatic && (kind === FIELD || kind === ACCESSOR)) {
          prependExpressionsToFieldInitializer(fieldInitializerExpressions, _element);
          fieldInitializerExpressions = [];
        }
        if (staticFieldInitializerExpressions.length > 0 && isStatic && (kind === FIELD || kind === ACCESSOR)) {
          prependExpressionsToFieldInitializer(staticFieldInitializerExpressions, _element);
          staticFieldInitializerExpressions = [];
        }
        if (hasDecorators && version === "2023-11") {
          if (kind === FIELD || kind === ACCESSOR) {
            var initExtraId = generateLetUidIdentifier(scopeParent, "init_extra_" + name);
            locals.push(initExtraId);
            var initExtraCall = callExpression$c(cloneNode$e(initExtraId), isStatic ? [] : [thisExpression$4()]);
            if (!isStatic) {
              fieldInitializerExpressions.push(initExtraCall);
            } else {
              staticFieldInitializerExpressions.push(initExtraCall);
            }
          }
        }
      }
    }
    if (computedKeyAssignments.length > 0) {
      var elements = path.get("body.body");
      var lastComputedElement;
      for (var i = elements.length - 1; i >= 0; i--) {
        var _path = elements[i];
        var _node3 = _path.node;
        if (_node3.computed) {
          if (classDecorators && isClassProperty(_node3, {
            "static": true
          })) {
            continue;
          }
          lastComputedElement = _path;
          break;
        }
      }
      if (lastComputedElement != null) {
        appendExpressionsToComputedKey(computedKeyAssignments, lastComputedElement);
        computedKeyAssignments = [];
      }
    }
    if (fieldInitializerExpressions.length > 0) {
      var isDerivedClass = !!path.node.superClass;
      if (constructorPath) {
        if (isDerivedClass) {
          insertExpressionsAfterSuperCallAndOptimize(fieldInitializerExpressions, constructorPath, protoInitLocal);
        } else {
          prependExpressionsToConstructor(fieldInitializerExpressions, constructorPath);
        }
      } else {
        path.node.body.body.unshift(createConstructorFromExpressions(fieldInitializerExpressions, isDerivedClass));
      }
      fieldInitializerExpressions = [];
    }
    if (staticFieldInitializerExpressions.length > 0) {
      path.node.body.body.push(createStaticBlockFromExpressions(staticFieldInitializerExpressions));
      staticFieldInitializerExpressions = [];
    }
    var sortedElementDecoratorInfo = toSortedDecoratorInfo(elementDecoratorInfo);
    var elementDecorations = generateDecorationExprs(version === "2023-11" ? elementDecoratorInfo : sortedElementDecoratorInfo, version);
    var elementLocals = extractElementLocalAssignments(sortedElementDecoratorInfo);
    if (protoInitLocal) {
      elementLocals.push(protoInitLocal);
    }
    if (staticInitLocal) {
      elementLocals.push(staticInitLocal);
    }
    var classLocals = [];
    var classInitInjected = false;
    var classInitCall = classInitLocal && callExpression$c(cloneNode$e(classInitLocal), []);
    var originalClassPath = path;
    var originalClass = path.node;
    var staticClosures = [];
    if (classDecorators) {
      classLocals.push(classIdLocal, classInitLocal);
      var statics = [];
      path.get("body.body").forEach(function (element) {
        if (element.isStaticBlock()) {
          if (hasInstancePrivateAccess(element, instancePrivateNames)) {
            var staticBlockClosureId = memoiseExpression(staticBlockToFunctionClosure(element.node), "staticBlock", staticClosures);
            staticFieldInitializerExpressions.push(callExpression$c(memberExpression$9(staticBlockClosureId, identifier$d("call")), [thisExpression$4()]));
          } else {
            staticFieldInitializerExpressions.push(staticBlockToIIFE(element.node));
          }
          element.remove();
          return;
        }
        if ((element.isClassProperty() || element.isClassPrivateProperty()) && element.node["static"]) {
          var _valuePath = element.get("value");
          if (hasInstancePrivateAccess(_valuePath, instancePrivateNames)) {
            var fieldValueClosureId = memoiseExpression(fieldInitializerToClosure(_valuePath.node), "fieldValue", staticClosures);
            _valuePath.replaceWith(callExpression$c(memberExpression$9(fieldValueClosureId, identifier$d("call")), [thisExpression$4()]));
          }
          if (staticFieldInitializerExpressions.length > 0) {
            prependExpressionsToFieldInitializer(staticFieldInitializerExpressions, element);
            staticFieldInitializerExpressions = [];
          }
          element.node["static"] = false;
          statics.push(element.node);
          element.remove();
        } else if (element.isClassPrivateMethod({
          "static": true
        })) {
          if (hasInstancePrivateAccess(element, instancePrivateNames)) {
            var _replaceSupers = new ReplaceSupers({
              constantSuper: constantSuper,
              methodPath: element,
              objectRef: classIdLocal,
              superRef: path.node.superClass,
              file: state.file,
              refToPreserve: classIdLocal
            });
            _replaceSupers.replace();
            var privateMethodDelegateId = memoiseExpression(createFunctionExpressionFromPrivateMethod(element.node), element.get("key.id").node.name, staticClosures);
            if (ignoreFunctionLength) {
              element.node.params = [restElement$2(identifier$d("arg"))];
              element.node.body = blockStatement$6([returnStatement$3(callExpression$c(memberExpression$9(privateMethodDelegateId, identifier$d("apply")), [thisExpression$4(), identifier$d("arg")]))]);
            } else {
              element.node.params = element.node.params.map(function (p, i) {
                if (isRestElement$2(p)) {
                  return restElement$2(identifier$d("arg"));
                } else {
                  return identifier$d("_" + i);
                }
              });
              element.node.body = blockStatement$6([returnStatement$3(callExpression$c(memberExpression$9(privateMethodDelegateId, identifier$d("apply")), [thisExpression$4(), identifier$d("arguments")]))]);
            }
          }
          element.node["static"] = false;
          statics.push(element.node);
          element.remove();
        }
      });
      if (statics.length > 0 || staticFieldInitializerExpressions.length > 0) {
        var staticsClass = template$1.expression.ast(_templateObject5$3 || (_templateObject5$3 = _taggedTemplateLiteralLoose(["\n        class extends ", " {}\n      "])), state.addHelper("identity"));
        staticsClass.body.body = [classProperty(toExpression$1(originalClass), undefined, undefined, undefined, true, true)].concat(statics);
        var constructorBody = [];
        var newExpr = newExpression(staticsClass, []);
        if (staticFieldInitializerExpressions.length > 0) {
          constructorBody.push.apply(constructorBody, _toConsumableArray(staticFieldInitializerExpressions));
        }
        if (classInitCall) {
          classInitInjected = true;
          constructorBody.push(classInitCall);
        }
        if (constructorBody.length > 0) {
          constructorBody.unshift(callExpression$c(_super$1(), [cloneNode$e(classIdLocal)]));
          staticsClass.body.body.push(createConstructorFromExpressions(constructorBody, false));
        } else {
          newExpr.arguments.push(cloneNode$e(classIdLocal));
        }
        var _path$replaceWith3 = path.replaceWith(newExpr),
          _path$replaceWith4 = _slicedToArray(_path$replaceWith3, 1),
          _newPath = _path$replaceWith4[0];
        originalClassPath = _newPath.get("callee").get("body").get("body.0.key");
      }
    }
    if (!classInitInjected && classInitCall) {
      path.node.body.body.push(staticBlock([expressionStatement$7(classInitCall)]));
    }
    var superClass = originalClass.superClass;
    if (superClass && (version === "2023-11" || version === "2023-05")) {
      var id = path.scope.maybeGenerateMemoised(superClass);
      if (id) {
        originalClass.superClass = assignmentExpression$8("=", id, superClass);
        superClass = id;
      }
    }
    var applyDecoratorWrapper = staticBlock([]);
    originalClass.body.body.unshift(applyDecoratorWrapper);
    var applyDecsBody = applyDecoratorWrapper.body;
    if (computedKeyAssignments.length > 0) {
      var _elements = originalClassPath.get("body.body");
      var firstPublicElement;
      for (var _iterator8 = _createForOfIteratorHelperLoose(_elements), _step8; !(_step8 = _iterator8()).done;) {
        var _path2 = _step8.value;
        if ((_path2.isClassProperty() || _path2.isClassMethod()) && _path2.node.kind !== "constructor") {
          firstPublicElement = _path2;
          break;
        }
      }
      if (firstPublicElement != null) {
        convertToComputedKey(firstPublicElement);
        prependExpressionsToComputedKey(computedKeyAssignments, firstPublicElement);
      } else {
        originalClass.body.body.unshift(classProperty(sequenceExpression$6([].concat(_toConsumableArray(computedKeyAssignments), [stringLiteral$6("_")])), undefined, undefined, undefined, true, true));
        applyDecsBody.push(expressionStatement$7(unaryExpression$4("delete", memberExpression$9(thisExpression$4(), identifier$d("_")))));
      }
      computedKeyAssignments = [];
    }
    applyDecsBody.push(expressionStatement$7(createLocalsAssignment(elementLocals, classLocals, elementDecorations, (_classDecorationsId = classDecorationsId) != null ? _classDecorationsId : arrayExpression$1(classDecorations), numericLiteral$5(classDecorationsFlag), needsInstancePrivateBrandCheck ? lastInstancePrivateName : null, setClassName, cloneNode$e(superClass), state, version)));
    if (staticInitLocal) {
      applyDecsBody.push(expressionStatement$7(callExpression$c(cloneNode$e(staticInitLocal), [thisExpression$4()])));
    }
    if (staticClosures.length > 0) {
      applyDecsBody.push.apply(applyDecsBody, _toConsumableArray(staticClosures.map(function (expr) {
        return expressionStatement$7(expr);
      })));
    }
    path.insertBefore(classAssignments.map(function (expr) {
      return expressionStatement$7(expr);
    }));
    if (needsDeclaraionForClassBinding) {
      var classBindingInfo = scopeParent.getBinding(classIdLocal.name);
      if (!classBindingInfo.constantViolations.length) {
        path.insertBefore(variableDeclaration$6("let", [variableDeclarator$6(cloneNode$e(classIdLocal))]));
      } else {
        var classOuterBindingDelegateLocal = scopeParent.generateUidIdentifier("t" + classIdLocal.name);
        var classOuterBindingLocal = classIdLocal;
        path.replaceWithMultiple([variableDeclaration$6("let", [variableDeclarator$6(cloneNode$e(classOuterBindingLocal)), variableDeclarator$6(classOuterBindingDelegateLocal)]), blockStatement$6([variableDeclaration$6("let", [variableDeclarator$6(cloneNode$e(classIdLocal))]), path.node, expressionStatement$7(assignmentExpression$8("=", cloneNode$e(classOuterBindingDelegateLocal), cloneNode$e(classIdLocal)))]), expressionStatement$7(assignmentExpression$8("=", cloneNode$e(classOuterBindingLocal), cloneNode$e(classOuterBindingDelegateLocal)))]);
      }
    }
    if (decoratedPrivateMethods.size > 0) {
      checkPrivateMethodUpdateError(path, decoratedPrivateMethods);
    }
    path.scope.crawl();
    return path;
  }
  function createLocalsAssignment(elementLocals, classLocals, elementDecorations, classDecorations, classDecorationsFlag, maybePrivateBrandName, setClassName, superClass, state, version) {
    var lhs, rhs;
    var args = [setClassName ? createSetFunctionNameCall(state, setClassName) : thisExpression$4(), classDecorations, elementDecorations];
    {
      if (version !== "2023-11") {
        args.splice(1, 2, elementDecorations, classDecorations);
      }
      if (version === "2021-12" || version === "2022-03" && !state.availableHelper("applyDecs2203R")) {
        lhs = arrayPattern([].concat(_toConsumableArray(elementLocals), _toConsumableArray(classLocals)));
        rhs = callExpression$c(state.addHelper(version === "2021-12" ? "applyDecs" : "applyDecs2203"), args);
        return assignmentExpression$8("=", lhs, rhs);
      } else if (version === "2022-03") {
        rhs = callExpression$c(state.addHelper("applyDecs2203R"), args);
      } else if (version === "2023-01") {
        if (maybePrivateBrandName) {
          args.push(createPrivateBrandCheckClosure(maybePrivateBrandName));
        }
        rhs = callExpression$c(state.addHelper("applyDecs2301"), args);
      } else if (version === "2023-05") {
        if (maybePrivateBrandName || superClass || classDecorationsFlag.value !== 0) {
          args.push(classDecorationsFlag);
        }
        if (maybePrivateBrandName) {
          args.push(createPrivateBrandCheckClosure(maybePrivateBrandName));
        } else if (superClass) {
          args.push(unaryExpression$4("void", numericLiteral$5(0)));
        }
        if (superClass) args.push(superClass);
        rhs = callExpression$c(state.addHelper("applyDecs2305"), args);
      }
    }
    if (version === "2023-11") {
      if (maybePrivateBrandName || superClass || classDecorationsFlag.value !== 0) {
        args.push(classDecorationsFlag);
      }
      if (maybePrivateBrandName) {
        args.push(createPrivateBrandCheckClosure(maybePrivateBrandName));
      } else if (superClass) {
        args.push(unaryExpression$4("void", numericLiteral$5(0)));
      }
      if (superClass) args.push(superClass);
      rhs = callExpression$c(state.addHelper("applyDecs2311"), args);
    }
    if (elementLocals.length > 0) {
      if (classLocals.length > 0) {
        lhs = objectPattern$1([objectProperty$1(identifier$d("e"), arrayPattern(elementLocals)), objectProperty$1(identifier$d("c"), arrayPattern(classLocals))]);
      } else {
        lhs = arrayPattern(elementLocals);
        rhs = memberExpression$9(rhs, identifier$d("e"), false, false);
      }
    } else {
      lhs = arrayPattern(classLocals);
      rhs = memberExpression$9(rhs, identifier$d("c"), false, false);
    }
    return assignmentExpression$8("=", lhs, rhs);
  }
  function isProtoKey(node) {
    return node.type === "Identifier" ? node.name === "__proto__" : node.value === "__proto__";
  }
  function isDecorated(node) {
    return node.decorators && node.decorators.length > 0;
  }
  function shouldTransformElement(node) {
    switch (node.type) {
      case "ClassAccessorProperty":
        return true;
      case "ClassMethod":
      case "ClassProperty":
      case "ClassPrivateMethod":
      case "ClassPrivateProperty":
        return isDecorated(node);
      default:
        return false;
    }
  }
  function shouldTransformClass(node) {
    return isDecorated(node) || node.body.body.some(shouldTransformElement);
  }
  function NamedEvaluationVisitoryFactory(isAnonymous, visitor) {
    function handleComputedProperty(propertyPath, key, state) {
      switch (key.type) {
        case "StringLiteral":
          return stringLiteral$6(key.value);
        case "NumericLiteral":
        case "BigIntLiteral":
          {
            var keyValue = key.value + "";
            propertyPath.get("key").replaceWith(stringLiteral$6(keyValue));
            return stringLiteral$6(keyValue);
          }
        default:
          {
            var ref = propertyPath.scope.maybeGenerateMemoised(key);
            propertyPath.get("key").replaceWith(assignmentExpression$8("=", ref, createToPropertyKeyCall(state, key)));
            return cloneNode$e(ref);
          }
      }
    }
    return {
      VariableDeclarator: function VariableDeclarator(path, state) {
        var id = path.node.id;
        if (id.type === "Identifier") {
          var initializer = skipTransparentExprWrappers(path.get("init"));
          if (isAnonymous(initializer)) {
            var name = id.name;
            visitor(initializer, state, name);
          }
        }
      },
      AssignmentExpression: function AssignmentExpression(path, state) {
        var id = path.node.left;
        if (id.type === "Identifier") {
          var initializer = skipTransparentExprWrappers(path.get("right"));
          if (isAnonymous(initializer)) {
            switch (path.node.operator) {
              case "=":
              case "&&=":
              case "||=":
              case "??=":
                visitor(initializer, state, id.name);
            }
          }
        }
      },
      AssignmentPattern: function AssignmentPattern(path, state) {
        var id = path.node.left;
        if (id.type === "Identifier") {
          var initializer = skipTransparentExprWrappers(path.get("right"));
          if (isAnonymous(initializer)) {
            var name = id.name;
            visitor(initializer, state, name);
          }
        }
      },
      ObjectExpression: function ObjectExpression(path, state) {
        for (var _iterator9 = _createForOfIteratorHelperLoose(path.get("properties")), _step9; !(_step9 = _iterator9()).done;) {
          var propertyPath = _step9.value;
          if (!propertyPath.isObjectProperty()) continue;
          var node = propertyPath.node;
          var id = node.key;
          var initializer = skipTransparentExprWrappers(propertyPath.get("value"));
          if (isAnonymous(initializer)) {
            if (!node.computed) {
              if (!isProtoKey(id)) {
                if (id.type === "Identifier") {
                  visitor(initializer, state, id.name);
                } else {
                  var className = stringLiteral$6(id.value + "");
                  visitor(initializer, state, className);
                }
              }
            } else {
              var ref = handleComputedProperty(propertyPath, id, state);
              visitor(initializer, state, ref);
            }
          }
        }
      },
      ClassPrivateProperty: function ClassPrivateProperty(path, state) {
        var node = path.node;
        var initializer = skipTransparentExprWrappers(path.get("value"));
        if (isAnonymous(initializer)) {
          var className = stringLiteral$6("#" + node.key.id.name);
          visitor(initializer, state, className);
        }
      },
      ClassAccessorProperty: function ClassAccessorProperty(path, state) {
        var node = path.node;
        var id = node.key;
        var initializer = skipTransparentExprWrappers(path.get("value"));
        if (isAnonymous(initializer)) {
          if (!node.computed) {
            if (id.type === "Identifier") {
              visitor(initializer, state, id.name);
            } else if (id.type === "PrivateName") {
              var className = stringLiteral$6("#" + id.id.name);
              visitor(initializer, state, className);
            } else {
              var _className2 = stringLiteral$6(id.value + "");
              visitor(initializer, state, _className2);
            }
          } else {
            var ref = handleComputedProperty(path, id, state);
            visitor(initializer, state, ref);
          }
        }
      },
      ClassProperty: function ClassProperty(path, state) {
        var node = path.node;
        var id = node.key;
        var initializer = skipTransparentExprWrappers(path.get("value"));
        if (isAnonymous(initializer)) {
          if (!node.computed) {
            if (id.type === "Identifier") {
              visitor(initializer, state, id.name);
            } else {
              var className = stringLiteral$6(id.value + "");
              visitor(initializer, state, className);
            }
          } else {
            var ref = handleComputedProperty(path, id, state);
            visitor(initializer, state, ref);
          }
        }
      }
    };
  }
  function isDecoratedAnonymousClassExpression(path) {
    return path.isClassExpression({
      id: null
    }) && shouldTransformClass(path.node);
  }
  function generateLetUidIdentifier(scope, name) {
    var id = scope.generateUidIdentifier(name);
    scope.push({
      id: id,
      kind: "let"
    });
    return cloneNode$e(id);
  }
  function createDecoratorTransform (_ref2, _ref3, version, inherits) {
    var _assumption, _assumption2;
    var assertVersion = _ref2.assertVersion,
      assumption = _ref2.assumption;
    var loose = _ref3.loose;
    {
      if (version === "2023-11" || version === "2023-05" || version === "2023-01") {
        assertVersion("*");
      } else if (version === "2021-12") {
        assertVersion("*");
      } else {
        assertVersion("*");
      }
    }
    var VISITED = new WeakSet();
    var constantSuper = (_assumption = assumption("constantSuper")) != null ? _assumption : loose;
    var ignoreFunctionLength = (_assumption2 = assumption("ignoreFunctionLength")) != null ? _assumption2 : loose;
    var namedEvaluationVisitor = NamedEvaluationVisitoryFactory(isDecoratedAnonymousClassExpression, visitClass);
    function visitClass(path, state, className) {
      var _className3, _node$id;
      if (VISITED.has(path)) return;
      var node = path.node;
      (_className3 = className) != null ? _className3 : className = (_node$id = node.id) == null ? void 0 : _node$id.name;
      var newPath = transformClass$1(path, state, constantSuper, ignoreFunctionLength, className, namedEvaluationVisitor, version);
      if (newPath) {
        VISITED.add(newPath);
        return;
      }
      VISITED.add(path);
    }
    return {
      name: "proposal-decorators",
      inherits: inherits,
      visitor: Object.assign({
        ExportDefaultDeclaration: function ExportDefaultDeclaration(path, state) {
          var declaration = path.node.declaration;
          if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && isDecorated(declaration)) {
            var isAnonymous = !declaration.id;
            var updatedVarDeclarationPath = path.splitExportDeclaration();
            if (isAnonymous) {
              visitClass(updatedVarDeclarationPath, state, stringLiteral$6("default"));
            }
          }
        },
        ExportNamedDeclaration: function ExportNamedDeclaration(path) {
          var declaration = path.node.declaration;
          if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && isDecorated(declaration)) {
            path.splitExportDeclaration();
          }
        },
        Class: function Class(path, state) {
          visitClass(path, state, undefined);
        }
      }, namedEvaluationVisitor)
    };
  }

function bool$4(value) {
    if (value == null) return false;
    return value && value !== "false" && value !== "0";
  }
  var semver$7 = bool$4(browser$1$1.env["BABEL_8_BREAKING"]) ? requireSemver$2() : requireSemver$2();

var _templateObject$w, _templateObject2$e, _templateObject3$a, _templateObject4$5;
  function hasOwnDecorators(node) {
    var _node$decorators;
    return !!((_node$decorators = node.decorators) != null && _node$decorators.length);
  }
  function hasDecorators(node) {
    return hasOwnDecorators(node) || node.body.body.some(hasOwnDecorators);
  }
  function prop(key, value) {
    if (!value) return null;
    return objectProperty$1(identifier$d(key), value);
  }
  function method(key, body) {
    return objectMethod("method", identifier$d(key), [], blockStatement$6(body));
  }
  function takeDecorators(node) {
    var result;
    if (node.decorators && node.decorators.length > 0) {
      result = arrayExpression$1(node.decorators.map(function (decorator) {
        return decorator.expression;
      }));
    }
    node.decorators = undefined;
    return result;
  }
  function getKey(node) {
    if (node.computed) {
      return node.key;
    } else if (isIdentifier$e(node.key)) {
      return stringLiteral$6(node.key.name);
    } else {
      return stringLiteral$6(String(node.key.value));
    }
  }
  function extractElementDescriptor(file, classRef, superRef, path) {
    var 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.");
    }
    var _ref = path,
      node = _ref.node,
      scope = _ref.scope;
    if (!path.isTSDeclareMethod()) {
      new ReplaceSupers({
        methodPath: path,
        objectRef: classRef,
        superRef: superRef,
        file: file,
        refToPreserve: classRef
      }).replace();
    }
    var properties = [prop("kind", stringLiteral$6(isClassMethod(node) ? node.kind : "field")), prop("decorators", takeDecorators(node)), prop("static", node["static"] && booleanLiteral$2(true)), prop("key", getKey(node))].filter(Boolean);
    if (isMethod) {
      path.ensureFunctionName(false);
      properties.push(prop("value", toExpression$1(path.node)));
    } else if (isClassProperty(node) && node.value) {
      properties.push(method("value", template$1.statements.ast(_templateObject$w || (_templateObject$w = _taggedTemplateLiteralLoose(["return ", ""])), node.value)));
    } else {
      properties.push(prop("value", scope.buildUndefinedNode()));
    }
    path.remove();
    return objectExpression$3(properties);
  }
  function addDecorateHelper(file) {
    return file.addHelper("decorate");
  }
  function buildDecoratedClass(ref, path, elements, file) {
    var node = path.node,
      scope = path.scope;
    var initializeId = scope.generateUidIdentifier("initialize");
    var isDeclaration = node.id && path.isDeclaration();
    var isStrict = path.isInStrictMode();
    var superClass = node.superClass;
    node.type = "ClassDeclaration";
    if (!node.id) node.id = cloneNode$e(ref);
    var superId;
    if (superClass) {
      superId = scope.generateUidIdentifierBasedOnNode(node.superClass, "super");
      node.superClass = superId;
    }
    var classDecorators = takeDecorators(node);
    var definitions = arrayExpression$1(elements.filter(function (element) {
      return (!element.node["abstract"] && element.node.type !== "TSIndexSignature"
      );
    }).map(function (path) {
      return extractElementDescriptor(file, node.id, superId, path);
    }));
    var wrapperCall = template$1.expression.ast(_templateObject2$e || (_templateObject2$e = _taggedTemplateLiteralLoose(["\n    ", "(\n      ", ",\n      function (", ", ", ") {\n        ", "\n        return { F: ", ", d: ", " };\n      },\n      ", "\n    )\n  "])), addDecorateHelper(file), classDecorators || nullLiteral$2(), initializeId, superClass ? cloneNode$e(superId) : null, node, cloneNode$e(node.id), definitions, superClass);
    if (!isStrict) {
      wrapperCall.arguments[1].body.directives.push(directive(directiveLiteral("use strict")));
    }
    var replacement = wrapperCall;
    var classPathDesc = "arguments.1.body.body.0";
    if (isDeclaration) {
      replacement = template$1.statement.ast(_templateObject3$a || (_templateObject3$a = _taggedTemplateLiteralLoose(["let ", " = ", ""])), ref, wrapperCall);
      classPathDesc = "declarations.0.init." + classPathDesc;
    }
    return {
      instanceNodes: [template$1.statement.ast(_templateObject4$5 || (_templateObject4$5 = _taggedTemplateLiteralLoose(["\n        ", "(this)\n      "])), cloneNode$e(initializeId))],
      wrapClass: function wrapClass(path) {
        path.replaceWith(replacement);
        return path.get(classPathDesc);
      }
    };
  }

var _templateObject$v;
  function generateUid(scope, denyList) {
    var name = "";
    var uid;
    var i = 1;
    do {
      uid = "_" + name;
      if (i > 1) uid += i;
      i++;
    } while (denyList.has(uid));
    return uid;
  }
  var _transformClassStaticBlock = declare(function (_ref) {
    var t = _ref.types,
      template = _ref.template,
      assertVersion = _ref.assertVersion;
    assertVersion("*");
    return {
      name: "transform-class-static-block",
      manipulateOptions: function (_, parser) {
        return parser.plugins.push("classStaticBlock");
      },
      pre: function pre() {
        enableFeature$1(this.file, FEATURES$1.staticBlocks, false);
      },
      visitor: {
        ClassBody: function ClassBody(classBody) {
          var scope = classBody.scope;
          var privateNames = new Set();
          var body = classBody.get("body");
          for (var _iterator = _createForOfIteratorHelperLoose(body), _step; !(_step = _iterator()).done;) {
            var path = _step.value;
            if (path.isPrivate()) {
              privateNames.add(path.get("key.id").node.name);
            }
          }
          for (var _iterator2 = _createForOfIteratorHelperLoose(body), _step2; !(_step2 = _iterator2()).done;) {
            var _path = _step2.value;
            if (!_path.isStaticBlock()) continue;
            var staticBlockPrivateId = generateUid(scope, privateNames);
            privateNames.add(staticBlockPrivateId);
            var staticBlockRef = t.privateName(t.identifier(staticBlockPrivateId));
            var replacement = void 0;
            var blockBody = _path.node.body;
            if (blockBody.length === 1 && t.isExpressionStatement(blockBody[0])) {
              replacement = t.inheritsComments(blockBody[0].expression, blockBody[0]);
            } else {
              replacement = template.expression.ast(_templateObject$v || (_templateObject$v = _taggedTemplateLiteralLoose(["(() => { ", " })()"])), blockBody);
            }
            _path.replaceWith(t.classPrivateProperty(staticBlockRef, replacement, [], true));
          }
        }
      }
    };
  });

var _templateObject$u;
  function isPureVoid(node) {
    return isUnaryExpression$1(node) && node.operator === "void" && isPureish$1(node.argument);
  }
  function unshiftForXStatementBody(statementPath, newStatements) {
    statementPath.ensureBlock();
    var scope = statementPath.scope,
      node = statementPath.node;
    var bodyScopeBindings = statementPath.get("body").scope.bindings;
    var hasShadowedBlockScopedBindings = Object.keys(bodyScopeBindings).some(function (name) {
      return scope.hasBinding(name);
    });
    if (hasShadowedBlockScopedBindings) {
      node.body = blockStatement$6([].concat(_toConsumableArray(newStatements), [node.body]));
    } else {
      var _body;
      (_body = node.body.body).unshift.apply(_body, _toConsumableArray(newStatements));
    }
  }
  function hasArrayRest(pattern) {
    return pattern.elements.some(function (elem) {
      return isRestElement$2(elem);
    });
  }
  function hasObjectRest(pattern) {
    return pattern.properties.some(function (prop) {
      return isRestElement$2(prop);
    });
  }
  var STOP_TRAVERSAL = {};
  var arrayUnpackVisitor = function arrayUnpackVisitor(node, ancestors, state) {
    if (!ancestors.length) {
      return;
    }
    if (isIdentifier$e(node) && isReferenced$2(node, ancestors[ancestors.length - 1].node) && state.bindings[node.name]) {
      state.deopt = true;
      throw STOP_TRAVERSAL;
    }
  };
  var DestructuringTransformer = function () {
    function DestructuringTransformer(opts) {
      this.blockHoist = void 0;
      this.operator = void 0;
      this.arrayRefSet = void 0;
      this.nodes = void 0;
      this.scope = void 0;
      this.kind = void 0;
      this.iterableIsArray = void 0;
      this.arrayLikeIsIterable = void 0;
      this.objectRestNoSymbols = void 0;
      this.useBuiltIns = void 0;
      this.addHelper = void 0;
      this.blockHoist = opts.blockHoist;
      this.operator = opts.operator;
      this.arrayRefSet = new Set();
      this.nodes = opts.nodes || [];
      this.scope = opts.scope;
      this.kind = opts.kind;
      this.iterableIsArray = opts.iterableIsArray;
      this.arrayLikeIsIterable = opts.arrayLikeIsIterable;
      this.objectRestNoSymbols = opts.objectRestNoSymbols;
      this.useBuiltIns = opts.useBuiltIns;
      this.addHelper = opts.addHelper;
    }
    var _proto = DestructuringTransformer.prototype;
    _proto.getExtendsHelper = function getExtendsHelper() {
      return this.useBuiltIns ? memberExpression$9(identifier$d("Object"), identifier$d("assign")) : this.addHelper("extends");
    };
    _proto.buildVariableAssignment = function buildVariableAssignment(id, init) {
      var op = this.operator;
      if (isMemberExpression$7(id) || isOptionalMemberExpression$3(id)) op = "=";
      var node;
      if (op) {
        node = expressionStatement$7(assignmentExpression$8(op, id, cloneNode$e(init) || this.scope.buildUndefinedNode()));
      } else {
        var nodeInit;
        if ((this.kind === "const" || this.kind === "using") && init === null) {
          nodeInit = this.scope.buildUndefinedNode();
        } else {
          nodeInit = cloneNode$e(init);
        }
        node = variableDeclaration$6(this.kind, [variableDeclarator$6(id, nodeInit)]);
      }
      node._blockHoist = this.blockHoist;
      return node;
    };
    _proto.buildVariableDeclaration = function buildVariableDeclaration(id, init) {
      var declar = variableDeclaration$6("var", [variableDeclarator$6(cloneNode$e(id), cloneNode$e(init))]);
      declar._blockHoist = this.blockHoist;
      return declar;
    };
    _proto.push = function push(id, _init) {
      var init = cloneNode$e(_init);
      if (isObjectPattern$1(id)) {
        this.pushObjectPattern(id, init);
      } else if (isArrayPattern(id)) {
        this.pushArrayPattern(id, init);
      } else if (isAssignmentPattern$4(id)) {
        this.pushAssignmentPattern(id, init);
      } else {
        this.nodes.push(this.buildVariableAssignment(id, init));
      }
    };
    _proto.toArray = function toArray(node, count) {
      if (this.iterableIsArray || isIdentifier$e(node) && this.arrayRefSet.has(node.name)) {
        return node;
      } else {
        var scope = this.scope,
          arrayLikeIsIterable = this.arrayLikeIsIterable;
        if (isIdentifier$e(node)) {
          var binding = scope.getBinding(node.name);
          if (binding != null && binding.constant && binding.path.isGenericType("Array")) {
            return node;
          }
        }
        if (isArrayExpression$2(node)) {
          return node;
        }
        if (isIdentifier$e(node, {
          name: "arguments"
        })) {
          return template$1.expression.ast(_templateObject$u || (_templateObject$u = _taggedTemplateLiteralLoose(["\n          Array.prototype.slice.call(", ")\n        "])), node);
        }
        var helperName;
        var args = [node];
        if (typeof count === "number") {
          args.push(numericLiteral$5(count));
          helperName = "slicedToArray";
        } else {
          helperName = "toArray";
        }
        if (arrayLikeIsIterable) {
          args.unshift(scope.path.hub.addHelper(helperName));
          helperName = "maybeArrayLike";
        }
        return callExpression$c(scope.path.hub.addHelper(helperName), args);
      }
    };
    _proto.pushAssignmentPattern = function pushAssignmentPattern(_ref, valueRef) {
      var left = _ref.left,
        right = _ref.right;
      if (isPureVoid(valueRef)) {
        this.push(left, right);
        return;
      }
      var tempId = this.scope.generateUidIdentifierBasedOnNode(valueRef);
      this.nodes.push(this.buildVariableDeclaration(tempId, valueRef));
      var tempConditional = conditionalExpression$5(binaryExpression$4("===", cloneNode$e(tempId), this.scope.buildUndefinedNode()), right, cloneNode$e(tempId));
      if (isPattern$1(left)) {
        var patternId;
        var node;
        if (this.kind === "const" || this.kind === "let" || this.kind === "using") {
          patternId = this.scope.generateUidIdentifier(tempId.name);
          node = this.buildVariableDeclaration(patternId, tempConditional);
        } else {
          patternId = tempId;
          node = expressionStatement$7(assignmentExpression$8("=", cloneNode$e(tempId), tempConditional));
        }
        this.nodes.push(node);
        this.push(left, patternId);
      } else {
        this.nodes.push(this.buildVariableAssignment(left, tempConditional));
      }
    };
    _proto.pushObjectRest = function pushObjectRest(pattern, objRef, spreadProp, spreadPropIndex) {
      var _this = this;
      var value = buildObjectExcludingKeys(pattern.properties.slice(0, spreadPropIndex), objRef, this.scope, function (name) {
        return _this.addHelper(name);
      }, this.objectRestNoSymbols, this.useBuiltIns);
      this.nodes.push(this.buildVariableAssignment(spreadProp.argument, value));
    };
    _proto.pushObjectProperty = function pushObjectProperty(prop, propRef) {
      if (isLiteral$4(prop.key)) prop.computed = true;
      var pattern = prop.value;
      var objRef = memberExpression$9(cloneNode$e(propRef), prop.key, prop.computed);
      if (isPattern$1(pattern)) {
        this.push(pattern, objRef);
      } else {
        this.nodes.push(this.buildVariableAssignment(pattern, objRef));
      }
    };
    _proto.pushObjectPattern = function pushObjectPattern(pattern, objRef) {
      if (!pattern.properties.length) {
        this.nodes.push(expressionStatement$7(callExpression$c(this.addHelper("objectDestructuringEmpty"), isPureVoid(objRef) ? [] : [objRef])));
        return;
      }
      if (pattern.properties.length > 1 && !this.scope.isStatic(objRef)) {
        var temp = this.scope.generateUidIdentifierBasedOnNode(objRef);
        this.nodes.push(this.buildVariableDeclaration(temp, objRef));
        objRef = temp;
      }
      if (hasObjectRest(pattern)) {
        var copiedPattern;
        for (var i = 0; i < pattern.properties.length; i++) {
          var prop = pattern.properties[i];
          if (isRestElement$2(prop)) {
            break;
          }
          var key = prop.key;
          if (prop.computed && !this.scope.isPure(key)) {
            var name = this.scope.generateUidIdentifierBasedOnNode(key);
            this.nodes.push(this.buildVariableDeclaration(name, key));
            if (!copiedPattern) {
              copiedPattern = pattern = Object.assign({}, pattern, {
                properties: pattern.properties.slice()
              });
            }
            copiedPattern.properties[i] = Object.assign({}, prop, {
              key: name
            });
          }
        }
      }
      for (var _i = 0; _i < pattern.properties.length; _i++) {
        var _prop = pattern.properties[_i];
        if (isRestElement$2(_prop)) {
          this.pushObjectRest(pattern, objRef, _prop, _i);
        } else {
          this.pushObjectProperty(_prop, objRef);
        }
      }
    };
    _proto.canUnpackArrayPattern = function canUnpackArrayPattern(pattern, arr) {
      if (!isArrayExpression$2(arr)) return false;
      if (pattern.elements.length > arr.elements.length) return;
      if (pattern.elements.length < arr.elements.length && !hasArrayRest(pattern)) {
        return false;
      }
      for (var _iterator = _createForOfIteratorHelperLoose(pattern.elements), _step; !(_step = _iterator()).done;) {
        var elem = _step.value;
        if (!elem) return false;
        if (isMemberExpression$7(elem)) return false;
      }
      for (var _iterator2 = _createForOfIteratorHelperLoose(arr.elements), _step2; !(_step2 = _iterator2()).done;) {
        var _elem = _step2.value;
        if (isSpreadElement$1(_elem)) return false;
        if (isCallExpression$8(_elem)) return false;
        if (isMemberExpression$7(_elem)) return false;
      }
      var bindings = getBindingIdentifiers$4(pattern);
      var state = {
        deopt: false,
        bindings: bindings
      };
      try {
        traverse$2(arr, arrayUnpackVisitor, state);
      } catch (e) {
        if (e !== STOP_TRAVERSAL) throw e;
      }
      return !state.deopt;
    };
    _proto.pushUnpackedArrayPattern = function pushUnpackedArrayPattern(pattern, arr) {
      var _this2 = this;
      var holeToUndefined = function holeToUndefined(el) {
        return el != null ? el : _this2.scope.buildUndefinedNode();
      };
      for (var i = 0; i < pattern.elements.length; i++) {
        var elem = pattern.elements[i];
        if (isRestElement$2(elem)) {
          this.push(elem.argument, arrayExpression$1(arr.elements.slice(i).map(holeToUndefined)));
        } else {
          this.push(elem, holeToUndefined(arr.elements[i]));
        }
      }
    };
    _proto.pushArrayPattern = function pushArrayPattern(pattern, arrayRef) {
      if (arrayRef === null) {
        this.nodes.push(expressionStatement$7(callExpression$c(this.addHelper("objectDestructuringEmpty"), [])));
        return;
      }
      if (!pattern.elements) return;
      if (this.canUnpackArrayPattern(pattern, arrayRef)) {
        this.pushUnpackedArrayPattern(pattern, arrayRef);
        return;
      }
      var count = !hasArrayRest(pattern) && pattern.elements.length;
      var toArray = this.toArray(arrayRef, count);
      if (isIdentifier$e(toArray)) {
        arrayRef = toArray;
      } else {
        arrayRef = this.scope.generateUidIdentifierBasedOnNode(arrayRef);
        this.arrayRefSet.add(arrayRef.name);
        this.nodes.push(this.buildVariableDeclaration(arrayRef, toArray));
      }
      for (var i = 0; i < pattern.elements.length; i++) {
        var elem = pattern.elements[i];
        if (!elem) continue;
        var elemRef = void 0;
        if (isRestElement$2(elem)) {
          elemRef = this.toArray(arrayRef);
          elemRef = callExpression$c(memberExpression$9(elemRef, identifier$d("slice")), [numericLiteral$5(i)]);
          this.push(elem.argument, elemRef);
        } else {
          elemRef = memberExpression$9(arrayRef, numericLiteral$5(i), true);
          this.push(elem, elemRef);
        }
      }
    };
    _proto.init = function init(pattern, ref) {
      if (!isArrayExpression$2(ref) && !isMemberExpression$7(ref)) {
        var memo = this.scope.maybeGenerateMemoised(ref, true);
        if (memo) {
          this.nodes.push(this.buildVariableDeclaration(memo, cloneNode$e(ref)));
          ref = memo;
        }
      }
      this.push(pattern, ref);
      return this.nodes;
    };
    return _createClass(DestructuringTransformer);
  }();
  function buildObjectExcludingKeys(excludedKeys, objRef, scope, addHelper, objectRestNoSymbols, useBuiltIns) {
    var keys = [];
    var allLiteral = true;
    var hasTemplateLiteral = false;
    for (var i = 0; i < excludedKeys.length; i++) {
      var prop = excludedKeys[i];
      var key = prop.key;
      if (isIdentifier$e(key) && !prop.computed) {
        keys.push(stringLiteral$6(key.name));
      } else if (isTemplateLiteral$1(key)) {
        keys.push(cloneNode$e(key));
        hasTemplateLiteral = true;
      } else if (isLiteral$4(key)) {
        keys.push(stringLiteral$6(String(key.value)));
      } else if (isPrivateName$2(key)) ; else {
        keys.push(cloneNode$e(key));
        allLiteral = false;
      }
    }
    var value;
    if (keys.length === 0) {
      var extendsHelper = useBuiltIns ? memberExpression$9(identifier$d("Object"), identifier$d("assign")) : addHelper("extends");
      value = callExpression$c(extendsHelper, [objectExpression$3([]), sequenceExpression$6([callExpression$c(addHelper("objectDestructuringEmpty"), [cloneNode$e(objRef)]), cloneNode$e(objRef)])]);
    } else {
      var keyExpression = arrayExpression$1(keys);
      if (!allLiteral) {
        keyExpression = callExpression$c(memberExpression$9(keyExpression, identifier$d("map")), [addHelper("toPropertyKey")]);
      } else if (!hasTemplateLiteral && !isProgram$1(scope.block)) {
        var programScope = scope.getProgramParent();
        var id = programScope.generateUidIdentifier("excluded");
        programScope.push({
          id: id,
          init: keyExpression,
          kind: "const"
        });
        keyExpression = cloneNode$e(id);
      }
      value = callExpression$c(addHelper("objectWithoutProperties" + (objectRestNoSymbols ? "Loose" : "")), [cloneNode$e(objRef), keyExpression]);
    }
    return value;
  }
  function convertVariableDeclaration(path, addHelper, arrayLikeIsIterable, iterableIsArray, objectRestNoSymbols, useBuiltIns) {
    var node = path.node,
      scope = path.scope;
    var nodeKind = node.kind;
    var nodeLoc = node.loc;
    var nodes = [];
    for (var i = 0; i < node.declarations.length; i++) {
      var declar = node.declarations[i];
      var patternId = declar.init;
      var pattern = declar.id;
      var destructuring = new DestructuringTransformer({
        blockHoist: node._blockHoist,
        nodes: nodes,
        scope: scope,
        kind: node.kind,
        iterableIsArray: iterableIsArray,
        arrayLikeIsIterable: arrayLikeIsIterable,
        useBuiltIns: useBuiltIns,
        objectRestNoSymbols: objectRestNoSymbols,
        addHelper: addHelper
      });
      if (isPattern$1(pattern)) {
        destructuring.init(pattern, patternId);
        if (+i !== node.declarations.length - 1) {
          inherits$3(nodes[nodes.length - 1], declar);
        }
      } else {
        nodes.push(inherits$3(destructuring.buildVariableAssignment(pattern, patternId), declar));
      }
    }
    var tail = null;
    var nodesOut = [];
    for (var _i2 = 0, _nodes = nodes; _i2 < _nodes.length; _i2++) {
      var _node = _nodes[_i2];
      if (isVariableDeclaration$3(_node)) {
        if (tail !== null) {
          var _tail$declarations;
          (_tail$declarations = tail.declarations).push.apply(_tail$declarations, _toConsumableArray(_node.declarations));
          continue;
        } else {
          _node.kind = nodeKind;
          tail = _node;
        }
      } else {
        tail = null;
      }
      if (!_node.loc) {
        _node.loc = nodeLoc;
      }
      nodesOut.push(_node);
    }
    if (nodesOut.length === 2 && isVariableDeclaration$3(nodesOut[0]) && isExpressionStatement$2(nodesOut[1]) && isCallExpression$8(nodesOut[1].expression) && nodesOut[0].declarations.length === 1) {
      var expr = nodesOut[1].expression;
      expr.arguments = [nodesOut[0].declarations[0].init];
      nodesOut = [expr];
    } else {
      if (isForStatement$2(path.parent, {
        init: node
      }) && !nodesOut.some(function (v) {
        return isVariableDeclaration$3(v);
      })) {
        for (var _i3 = 0; _i3 < nodesOut.length; _i3++) {
          var _node2 = nodesOut[_i3];
          if (isExpressionStatement$2(_node2)) {
            nodesOut[_i3] = _node2.expression;
          }
        }
      }
    }
    if (nodesOut.length === 1) {
      path.replaceWith(nodesOut[0]);
    } else {
      path.replaceWithMultiple(nodesOut);
    }
    scope.crawl();
  }
  function convertAssignmentExpression(path, addHelper, arrayLikeIsIterable, iterableIsArray, objectRestNoSymbols, useBuiltIns) {
    var node = path.node,
      scope = path.scope,
      parentPath = path.parentPath;
    var nodes = [];
    var destructuring = new DestructuringTransformer({
      operator: node.operator,
      scope: scope,
      nodes: nodes,
      arrayLikeIsIterable: arrayLikeIsIterable,
      iterableIsArray: iterableIsArray,
      objectRestNoSymbols: objectRestNoSymbols,
      useBuiltIns: useBuiltIns,
      addHelper: addHelper
    });
    var ref;
    if (!parentPath.isExpressionStatement() && !parentPath.isSequenceExpression() || path.isCompletionRecord()) {
      ref = scope.generateUidIdentifierBasedOnNode(node.right, "ref");
      nodes.push(variableDeclaration$6("var", [variableDeclarator$6(ref, node.right)]));
      if (isArrayExpression$2(node.right)) {
        destructuring.arrayRefSet.add(ref.name);
      }
    }
    destructuring.init(node.left, ref || node.right);
    if (ref) {
      if (parentPath.isArrowFunctionExpression()) {
        path.replaceWith(blockStatement$6([]));
        nodes.push(returnStatement$3(cloneNode$e(ref)));
      } else {
        nodes.push(expressionStatement$7(cloneNode$e(ref)));
      }
    }
    path.replaceWithMultiple(nodes);
    scope.crawl();
  }

var _templateObject$t;
  var buildDefaultParam = template$1.statement("\n  let VARIABLE_NAME =\n    arguments.length > ARGUMENT_KEY && arguments[ARGUMENT_KEY] !== undefined ?\n      arguments[ARGUMENT_KEY]\n    :\n      DEFAULT_VALUE;\n");
  var buildLooseDefaultParam = template$1.statement("\n  if (ASSIGNMENT_IDENTIFIER === UNDEFINED) {\n    ASSIGNMENT_IDENTIFIER = DEFAULT_VALUE;\n  }\n");
  var buildLooseDestructuredDefaultParam = template$1.statement("\n  let ASSIGNMENT_IDENTIFIER = PARAMETER_NAME === UNDEFINED ? DEFAULT_VALUE : PARAMETER_NAME ;\n");
  var buildSafeArgumentsAccess = template$1.statement("\n  let $0 = arguments.length > $1 ? arguments[$1] : undefined;\n");
  function convertFunctionParams(path, ignoreFunctionLength, shouldTransformParam, replaceRestElement) {
    var params = path.get("params");
    var isSimpleParameterList = params.every(function (param) {
      return param.isIdentifier();
    });
    if (isSimpleParameterList) return false;
    var node = path.node,
      scope = path.scope;
    var body = [];
    var shadowedParams = new Set();
    for (var _iterator = _createForOfIteratorHelperLoose(params), _step; !(_step = _iterator()).done;) {
      var _param2 = _step.value;
      collectShadowedParamsNames(_param2, scope, shadowedParams);
    }
    var state = {
      needsOuterBinding: false,
      scope: scope
    };
    if (shadowedParams.size === 0) {
      for (var _iterator2 = _createForOfIteratorHelperLoose(params), _step2; !(_step2 = _iterator2()).done;) {
        var param = _step2.value;
        if (!param.isIdentifier()) param.traverse(iifeVisitor, state);
        if (state.needsOuterBinding) break;
      }
    }
    var firstOptionalIndex = null;
    for (var i = 0; i < params.length; i++) {
      var _param = params[i];
      if (shouldTransformParam && !shouldTransformParam(i)) {
        continue;
      }
      var transformedRestNodes = [];
      if (replaceRestElement) {
        replaceRestElement(path, _param, transformedRestNodes);
      }
      var paramIsAssignmentPattern = _param.isAssignmentPattern();
      if (paramIsAssignmentPattern && (ignoreFunctionLength || isMethod$1(node, {
        kind: "set"
      }))) {
        var left = _param.get("left");
        var right = _param.get("right");
        var undefinedNode = scope.buildUndefinedNode();
        if (left.isIdentifier()) {
          body.push(buildLooseDefaultParam({
            ASSIGNMENT_IDENTIFIER: cloneNode$e(left.node),
            DEFAULT_VALUE: right.node,
            UNDEFINED: undefinedNode
          }));
          _param.replaceWith(left.node);
        } else if (left.isObjectPattern() || left.isArrayPattern()) {
          var paramName = scope.generateUidIdentifier();
          body.push(buildLooseDestructuredDefaultParam({
            ASSIGNMENT_IDENTIFIER: left.node,
            DEFAULT_VALUE: right.node,
            PARAMETER_NAME: cloneNode$e(paramName),
            UNDEFINED: undefinedNode
          }));
          _param.replaceWith(paramName);
        }
      } else if (paramIsAssignmentPattern) {
        if (firstOptionalIndex === null) firstOptionalIndex = i;
        var _left = _param.get("left");
        var _right = _param.get("right");
        var defNode = buildDefaultParam({
          VARIABLE_NAME: _left.node,
          DEFAULT_VALUE: _right.node,
          ARGUMENT_KEY: numericLiteral$5(i)
        });
        body.push(defNode);
      } else if (firstOptionalIndex !== null) {
        var _defNode = buildSafeArgumentsAccess([_param.node, numericLiteral$5(i)]);
        body.push(_defNode);
      } else if (_param.isObjectPattern() || _param.isArrayPattern()) {
        var uid = path.scope.generateUidIdentifier("ref");
        uid.typeAnnotation = _param.node.typeAnnotation;
        var _defNode2 = variableDeclaration$6("let", [variableDeclarator$6(_param.node, uid)]);
        body.push(_defNode2);
        _param.replaceWith(cloneNode$e(uid));
      }
      if (transformedRestNodes) {
        for (var _iterator3 = _createForOfIteratorHelperLoose(transformedRestNodes), _step3; !(_step3 = _iterator3()).done;) {
          var transformedNode = _step3.value;
          body.push(transformedNode);
        }
      }
    }
    if (firstOptionalIndex !== null) {
      node.params = node.params.slice(0, firstOptionalIndex);
    }
    path.ensureBlock();
    var path2 = path;
    var async = node.async,
      generator = node.generator;
    if (generator || state.needsOuterBinding || shadowedParams.size > 0) {
      body.push(buildScopeIIFE(shadowedParams, path2.node.body));
      path.set("body", blockStatement$6(body));
      var bodyPath = path2.get("body.body");
      var arrowPath = bodyPath[bodyPath.length - 1].get("argument.callee");
      arrowPath.arrowFunctionToExpression();
      arrowPath.node.generator = generator;
      arrowPath.node.async = async;
      node.generator = false;
      node.async = false;
      if (async) {
        path2.node.body = template$1.statement.ast(_templateObject$t || (_templateObject$t = _taggedTemplateLiteralLoose(["{\n        try {\n          ", "\n        } catch (e) {\n          return Promise.reject(e);\n        }\n      }"])), path2.node.body.body);
      }
    } else {
      path2.get("body").unshiftContainer("body", body);
    }
    return true;
  }

var Alphabetic = {};

var regenerate$3 = {exports: {}};

regenerate$3.exports;
  (function (module, exports) {
    (function (root) {
      var freeExports = exports;
      var freeModule = module && module.exports == freeExports && module;
      var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
      if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
        root = freeGlobal;
      }
      var ERRORS = {
        'rangeOrder': "A range\u2019s `stop` value must be greater than or equal " + 'to the `start` value.',
        'codePointRange': 'Invalid code point value. Code points range from ' + 'U+000000 to U+10FFFF.'
      };
      var HIGH_SURROGATE_MIN = 0xD800;
      var HIGH_SURROGATE_MAX = 0xDBFF;
      var LOW_SURROGATE_MIN = 0xDC00;
      var LOW_SURROGATE_MAX = 0xDFFF;
      var regexNull = /\\x00([^0123456789]|$)/g;
      var object = {};
      var hasOwnProperty = object.hasOwnProperty;
      var extend = function extend(destination, source) {
        var key;
        for (key in source) {
          if (hasOwnProperty.call(source, key)) {
            destination[key] = source[key];
          }
        }
        return destination;
      };
      var forEach = function forEach(array, callback) {
        var index = -1;
        var length = array.length;
        while (++index < length) {
          callback(array[index], index);
        }
      };
      var toString = object.toString;
      var isArray = function isArray(value) {
        return toString.call(value) == '[object Array]';
      };
      var isNumber = function isNumber(value) {
        return typeof value == 'number' || toString.call(value) == '[object Number]';
      };
      var zeroes = '0000';
      var pad = function pad(number, totalCharacters) {
        var string = String(number);
        return string.length < totalCharacters ? (zeroes + string).slice(-totalCharacters) : string;
      };
      var hex = function hex(number) {
        return Number(number).toString(16).toUpperCase();
      };
      var slice = [].slice;
      var dataFromCodePoints = function dataFromCodePoints(codePoints) {
        var index = -1;
        var length = codePoints.length;
        var max = length - 1;
        var result = [];
        var isStart = true;
        var tmp;
        var previous = 0;
        while (++index < length) {
          tmp = codePoints[index];
          if (isStart) {
            result.push(tmp);
            previous = tmp;
            isStart = false;
          } else {
            if (tmp == previous + 1) {
              if (index != max) {
                previous = tmp;
                continue;
              } else {
                isStart = true;
                result.push(tmp + 1);
              }
            } else {
              result.push(previous + 1, tmp);
              previous = tmp;
            }
          }
        }
        if (!isStart) {
          result.push(tmp + 1);
        }
        return result;
      };
      var dataRemove = function dataRemove(data, codePoint) {
        var index = 0;
        var start;
        var end;
        var length = data.length;
        while (index < length) {
          start = data[index];
          end = data[index + 1];
          if (codePoint >= start && codePoint < end) {
            if (codePoint == start) {
              if (end == start + 1) {
                data.splice(index, 2);
                return data;
              } else {
                data[index] = codePoint + 1;
                return data;
              }
            } else if (codePoint == end - 1) {
              data[index + 1] = codePoint;
              return data;
            } else {
              data.splice(index, 2, start, codePoint, codePoint + 1, end);
              return data;
            }
          }
          index += 2;
        }
        return data;
      };
      var dataRemoveRange = function dataRemoveRange(data, rangeStart, rangeEnd) {
        if (rangeEnd < rangeStart) {
          throw Error(ERRORS.rangeOrder);
        }
        var index = 0;
        var start;
        var end;
        while (index < data.length) {
          start = data[index];
          end = data[index + 1] - 1;
          if (start > rangeEnd) {
            return data;
          }
          if (rangeStart <= start && rangeEnd >= end) {
            data.splice(index, 2);
            continue;
          }
          if (rangeStart >= start && rangeEnd < end) {
            if (rangeStart == start) {
              data[index] = rangeEnd + 1;
              data[index + 1] = end + 1;
              return data;
            }
            data.splice(index, 2, start, rangeStart, rangeEnd + 1, end + 1);
            return data;
          }
          if (rangeStart >= start && rangeStart <= end) {
            data[index + 1] = rangeStart;
          } else if (rangeEnd >= start && rangeEnd <= end) {
            data[index] = rangeEnd + 1;
            return data;
          }
          index += 2;
        }
        return data;
      };
      var dataAdd = function dataAdd(data, codePoint) {
        var index = 0;
        var start;
        var end;
        var lastIndex = null;
        var length = data.length;
        if (codePoint < 0x0 || codePoint > 0x10FFFF) {
          throw RangeError(ERRORS.codePointRange);
        }
        while (index < length) {
          start = data[index];
          end = data[index + 1];
          if (codePoint >= start && codePoint < end) {
            return data;
          }
          if (codePoint == start - 1) {
            data[index] = codePoint;
            return data;
          }
          if (start > codePoint) {
            data.splice(lastIndex != null ? lastIndex + 2 : 0, 0, codePoint, codePoint + 1);
            return data;
          }
          if (codePoint == end) {
            if (codePoint + 1 == data[index + 2]) {
              data.splice(index, 4, start, data[index + 3]);
              return data;
            }
            data[index + 1] = codePoint + 1;
            return data;
          }
          lastIndex = index;
          index += 2;
        }
        data.push(codePoint, codePoint + 1);
        return data;
      };
      var dataAddData = function dataAddData(dataA, dataB) {
        var index = 0;
        var start;
        var end;
        var data = dataA.slice();
        var length = dataB.length;
        while (index < length) {
          start = dataB[index];
          end = dataB[index + 1] - 1;
          if (start == end) {
            data = dataAdd(data, start);
          } else {
            data = dataAddRange(data, start, end);
          }
          index += 2;
        }
        return data;
      };
      var dataRemoveData = function dataRemoveData(dataA, dataB) {
        var index = 0;
        var start;
        var end;
        var data = dataA.slice();
        var length = dataB.length;
        while (index < length) {
          start = dataB[index];
          end = dataB[index + 1] - 1;
          if (start == end) {
            data = dataRemove(data, start);
          } else {
            data = dataRemoveRange(data, start, end);
          }
          index += 2;
        }
        return data;
      };
      var dataAddRange = function dataAddRange(data, rangeStart, rangeEnd) {
        if (rangeEnd < rangeStart) {
          throw Error(ERRORS.rangeOrder);
        }
        if (rangeStart < 0x0 || rangeStart > 0x10FFFF || rangeEnd < 0x0 || rangeEnd > 0x10FFFF) {
          throw RangeError(ERRORS.codePointRange);
        }
        var index = 0;
        var start;
        var end;
        var added = false;
        var length = data.length;
        while (index < length) {
          start = data[index];
          end = data[index + 1];
          if (added) {
            if (start == rangeEnd + 1) {
              data.splice(index - 1, 2);
              return data;
            }
            if (start > rangeEnd) {
              return data;
            }
            if (start >= rangeStart && start <= rangeEnd) {
              if (end > rangeStart && end - 1 <= rangeEnd) {
                data.splice(index, 2);
                index -= 2;
              } else {
                data.splice(index - 1, 2);
                index -= 2;
              }
            }
          } else if (start == rangeEnd + 1 || start == rangeEnd) {
            data[index] = rangeStart;
            return data;
          } else if (start > rangeEnd) {
            data.splice(index, 0, rangeStart, rangeEnd + 1);
            return data;
          } else if (rangeStart >= start && rangeStart < end && rangeEnd + 1 <= end) {
            return data;
          } else if (rangeStart >= start && rangeStart < end || end == rangeStart) {
            data[index + 1] = rangeEnd + 1;
            added = true;
          } else if (rangeStart <= start && rangeEnd + 1 >= end) {
            data[index] = rangeStart;
            data[index + 1] = rangeEnd + 1;
            added = true;
          }
          index += 2;
        }
        if (!added) {
          data.push(rangeStart, rangeEnd + 1);
        }
        return data;
      };
      var dataContains = function dataContains(data, codePoint) {
        var index = 0;
        var length = data.length;
        var start = data[index];
        var end = data[length - 1];
        if (length >= 2) {
          if (codePoint < start || codePoint > end) {
            return false;
          }
        }
        while (index < length) {
          start = data[index];
          end = data[index + 1];
          if (codePoint >= start && codePoint < end) {
            return true;
          }
          index += 2;
        }
        return false;
      };
      var dataIntersection = function dataIntersection(data, codePoints) {
        var index = 0;
        var length = codePoints.length;
        var codePoint;
        var result = [];
        while (index < length) {
          codePoint = codePoints[index];
          if (dataContains(data, codePoint)) {
            result.push(codePoint);
          }
          ++index;
        }
        return dataFromCodePoints(result);
      };
      var dataIsEmpty = function dataIsEmpty(data) {
        return !data.length;
      };
      var dataIsSingleton = function dataIsSingleton(data) {
        return data.length == 2 && data[0] + 1 == data[1];
      };
      var dataToArray = function dataToArray(data) {
        var index = 0;
        var start;
        var end;
        var result = [];
        var length = data.length;
        while (index < length) {
          start = data[index];
          end = data[index + 1];
          while (start < end) {
            result.push(start);
            ++start;
          }
          index += 2;
        }
        return result;
      };
      var floor = Math.floor;
      var highSurrogate = function highSurrogate(codePoint) {
        return parseInt(floor((codePoint - 0x10000) / 0x400) + HIGH_SURROGATE_MIN, 10);
      };
      var lowSurrogate = function lowSurrogate(codePoint) {
        return parseInt((codePoint - 0x10000) % 0x400 + LOW_SURROGATE_MIN, 10);
      };
      var stringFromCharCode = String.fromCharCode;
      var codePointToString = function codePointToString(codePoint) {
        var string;
        if (codePoint == 0x09) {
          string = '\\t';
        } else if (codePoint == 0x0A) {
          string = '\\n';
        } else if (codePoint == 0x0C) {
          string = '\\f';
        } else if (codePoint == 0x0D) {
          string = '\\r';
        } else if (codePoint == 0x2D) {
          string = '\\x2D';
        } else if (codePoint == 0x5C) {
          string = '\\\\';
        } else if (codePoint == 0x24 || codePoint >= 0x28 && codePoint <= 0x2B || codePoint == 0x2E || codePoint == 0x2F || codePoint == 0x3F || codePoint >= 0x5B && codePoint <= 0x5E || codePoint >= 0x7B && codePoint <= 0x7D) {
          string = '\\' + stringFromCharCode(codePoint);
        } else if (codePoint >= 0x20 && codePoint <= 0x7E) {
          string = stringFromCharCode(codePoint);
        } else if (codePoint <= 0xFF) {
          string = '\\x' + pad(hex(codePoint), 2);
        } else {
          string = "\\u" + pad(hex(codePoint), 4);
        }
        return string;
      };
      var codePointToStringUnicode = function codePointToStringUnicode(codePoint) {
        if (codePoint <= 0xFFFF) {
          return codePointToString(codePoint);
        }
        return "\\u{" + codePoint.toString(16).toUpperCase() + '}';
      };
      var symbolToCodePoint = function symbolToCodePoint(symbol) {
        var length = symbol.length;
        var first = symbol.charCodeAt(0);
        var second;
        if (first >= HIGH_SURROGATE_MIN && first <= HIGH_SURROGATE_MAX && length > 1) {
          second = symbol.charCodeAt(1);
          return (first - HIGH_SURROGATE_MIN) * 0x400 + second - LOW_SURROGATE_MIN + 0x10000;
        }
        return first;
      };
      var createBMPCharacterClasses = function createBMPCharacterClasses(data) {
        var result = '';
        var index = 0;
        var start;
        var end;
        var length = data.length;
        if (dataIsSingleton(data)) {
          return codePointToString(data[0]);
        }
        while (index < length) {
          start = data[index];
          end = data[index + 1] - 1;
          if (start == end) {
            result += codePointToString(start);
          } else if (start + 1 == end) {
            result += codePointToString(start) + codePointToString(end);
          } else {
            result += codePointToString(start) + '-' + codePointToString(end);
          }
          index += 2;
        }
        return '[' + result + ']';
      };
      var createUnicodeCharacterClasses = function createUnicodeCharacterClasses(data) {
        var result = '';
        var index = 0;
        var start;
        var end;
        var length = data.length;
        if (dataIsSingleton(data)) {
          return codePointToStringUnicode(data[0]);
        }
        while (index < length) {
          start = data[index];
          end = data[index + 1] - 1;
          if (start == end) {
            result += codePointToStringUnicode(start);
          } else if (start + 1 == end) {
            result += codePointToStringUnicode(start) + codePointToStringUnicode(end);
          } else {
            result += codePointToStringUnicode(start) + '-' + codePointToStringUnicode(end);
          }
          index += 2;
        }
        return '[' + result + ']';
      };
      var splitAtBMP = function splitAtBMP(data) {
        var loneHighSurrogates = [];
        var loneLowSurrogates = [];
        var bmp = [];
        var astral = [];
        var index = 0;
        var start;
        var end;
        var length = data.length;
        while (index < length) {
          start = data[index];
          end = data[index + 1] - 1;
          if (start < HIGH_SURROGATE_MIN) {
            if (end < HIGH_SURROGATE_MIN) {
              bmp.push(start, end + 1);
            }
            if (end >= HIGH_SURROGATE_MIN && end <= HIGH_SURROGATE_MAX) {
              bmp.push(start, HIGH_SURROGATE_MIN);
              loneHighSurrogates.push(HIGH_SURROGATE_MIN, end + 1);
            }
            if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {
              bmp.push(start, HIGH_SURROGATE_MIN);
              loneHighSurrogates.push(HIGH_SURROGATE_MIN, HIGH_SURROGATE_MAX + 1);
              loneLowSurrogates.push(LOW_SURROGATE_MIN, end + 1);
            }
            if (end > LOW_SURROGATE_MAX) {
              bmp.push(start, HIGH_SURROGATE_MIN);
              loneHighSurrogates.push(HIGH_SURROGATE_MIN, HIGH_SURROGATE_MAX + 1);
              loneLowSurrogates.push(LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1);
              if (end <= 0xFFFF) {
                bmp.push(LOW_SURROGATE_MAX + 1, end + 1);
              } else {
                bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);
                astral.push(0xFFFF + 1, end + 1);
              }
            }
          } else if (start >= HIGH_SURROGATE_MIN && start <= HIGH_SURROGATE_MAX) {
            if (end >= HIGH_SURROGATE_MIN && end <= HIGH_SURROGATE_MAX) {
              loneHighSurrogates.push(start, end + 1);
            }
            if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {
              loneHighSurrogates.push(start, HIGH_SURROGATE_MAX + 1);
              loneLowSurrogates.push(LOW_SURROGATE_MIN, end + 1);
            }
            if (end > LOW_SURROGATE_MAX) {
              loneHighSurrogates.push(start, HIGH_SURROGATE_MAX + 1);
              loneLowSurrogates.push(LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1);
              if (end <= 0xFFFF) {
                bmp.push(LOW_SURROGATE_MAX + 1, end + 1);
              } else {
                bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);
                astral.push(0xFFFF + 1, end + 1);
              }
            }
          } else if (start >= LOW_SURROGATE_MIN && start <= LOW_SURROGATE_MAX) {
            if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {
              loneLowSurrogates.push(start, end + 1);
            }
            if (end > LOW_SURROGATE_MAX) {
              loneLowSurrogates.push(start, LOW_SURROGATE_MAX + 1);
              if (end <= 0xFFFF) {
                bmp.push(LOW_SURROGATE_MAX + 1, end + 1);
              } else {
                bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);
                astral.push(0xFFFF + 1, end + 1);
              }
            }
          } else if (start > LOW_SURROGATE_MAX && start <= 0xFFFF) {
            if (end <= 0xFFFF) {
              bmp.push(start, end + 1);
            } else {
              bmp.push(start, 0xFFFF + 1);
              astral.push(0xFFFF + 1, end + 1);
            }
          } else {
            astral.push(start, end + 1);
          }
          index += 2;
        }
        return {
          'loneHighSurrogates': loneHighSurrogates,
          'loneLowSurrogates': loneLowSurrogates,
          'bmp': bmp,
          'astral': astral
        };
      };
      var optimizeSurrogateMappings = function optimizeSurrogateMappings(surrogateMappings) {
        var result = [];
        var tmpLow = [];
        var addLow = false;
        var mapping;
        var nextMapping;
        var highSurrogates;
        var lowSurrogates;
        var nextHighSurrogates;
        var nextLowSurrogates;
        var index = -1;
        var length = surrogateMappings.length;
        while (++index < length) {
          mapping = surrogateMappings[index];
          nextMapping = surrogateMappings[index + 1];
          if (!nextMapping) {
            result.push(mapping);
            continue;
          }
          highSurrogates = mapping[0];
          lowSurrogates = mapping[1];
          nextHighSurrogates = nextMapping[0];
          nextLowSurrogates = nextMapping[1];
          tmpLow = lowSurrogates;
          while (nextHighSurrogates && highSurrogates[0] == nextHighSurrogates[0] && highSurrogates[1] == nextHighSurrogates[1]) {
            if (dataIsSingleton(nextLowSurrogates)) {
              tmpLow = dataAdd(tmpLow, nextLowSurrogates[0]);
            } else {
              tmpLow = dataAddRange(tmpLow, nextLowSurrogates[0], nextLowSurrogates[1] - 1);
            }
            ++index;
            mapping = surrogateMappings[index];
            highSurrogates = mapping[0];
            lowSurrogates = mapping[1];
            nextMapping = surrogateMappings[index + 1];
            nextHighSurrogates = nextMapping && nextMapping[0];
            nextLowSurrogates = nextMapping && nextMapping[1];
            addLow = true;
          }
          result.push([highSurrogates, addLow ? tmpLow : lowSurrogates]);
          addLow = false;
        }
        return optimizeByLowSurrogates(result);
      };
      var optimizeByLowSurrogates = function optimizeByLowSurrogates(surrogateMappings) {
        if (surrogateMappings.length == 1) {
          return surrogateMappings;
        }
        var index = -1;
        var innerIndex = -1;
        while (++index < surrogateMappings.length) {
          var mapping = surrogateMappings[index];
          var lowSurrogates = mapping[1];
          var lowSurrogateStart = lowSurrogates[0];
          var lowSurrogateEnd = lowSurrogates[1];
          innerIndex = index;
          while (++innerIndex < surrogateMappings.length) {
            var otherMapping = surrogateMappings[innerIndex];
            var otherLowSurrogates = otherMapping[1];
            var otherLowSurrogateStart = otherLowSurrogates[0];
            var otherLowSurrogateEnd = otherLowSurrogates[1];
            if (lowSurrogateStart == otherLowSurrogateStart && lowSurrogateEnd == otherLowSurrogateEnd && otherLowSurrogates.length === 2) {
              if (dataIsSingleton(otherMapping[0])) {
                mapping[0] = dataAdd(mapping[0], otherMapping[0][0]);
              } else {
                mapping[0] = dataAddRange(mapping[0], otherMapping[0][0], otherMapping[0][1] - 1);
              }
              surrogateMappings.splice(innerIndex, 1);
              --innerIndex;
            }
          }
        }
        return surrogateMappings;
      };
      var surrogateSet = function surrogateSet(data) {
        if (!data.length) {
          return [];
        }
        var index = 0;
        var start;
        var end;
        var startHigh;
        var startLow;
        var endHigh;
        var endLow;
        var surrogateMappings = [];
        var length = data.length;
        while (index < length) {
          start = data[index];
          end = data[index + 1] - 1;
          startHigh = highSurrogate(start);
          startLow = lowSurrogate(start);
          endHigh = highSurrogate(end);
          endLow = lowSurrogate(end);
          var startsWithLowestLowSurrogate = startLow == LOW_SURROGATE_MIN;
          var endsWithHighestLowSurrogate = endLow == LOW_SURROGATE_MAX;
          var complete = false;
          if (startHigh == endHigh || startsWithLowestLowSurrogate && endsWithHighestLowSurrogate) {
            surrogateMappings.push([[startHigh, endHigh + 1], [startLow, endLow + 1]]);
            complete = true;
          } else {
            surrogateMappings.push([[startHigh, startHigh + 1], [startLow, LOW_SURROGATE_MAX + 1]]);
          }
          if (!complete && startHigh + 1 < endHigh) {
            if (endsWithHighestLowSurrogate) {
              surrogateMappings.push([[startHigh + 1, endHigh + 1], [LOW_SURROGATE_MIN, endLow + 1]]);
              complete = true;
            } else {
              surrogateMappings.push([[startHigh + 1, endHigh], [LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1]]);
            }
          }
          if (!complete) {
            surrogateMappings.push([[endHigh, endHigh + 1], [LOW_SURROGATE_MIN, endLow + 1]]);
          }
          index += 2;
        }
        return optimizeSurrogateMappings(surrogateMappings);
      };
      var createSurrogateCharacterClasses = function createSurrogateCharacterClasses(surrogateMappings) {
        var result = [];
        forEach(surrogateMappings, function (surrogateMapping) {
          var highSurrogates = surrogateMapping[0];
          var lowSurrogates = surrogateMapping[1];
          result.push(createBMPCharacterClasses(highSurrogates) + createBMPCharacterClasses(lowSurrogates));
        });
        return result.join('|');
      };
      var createCharacterClassesFromData = function createCharacterClassesFromData(data, bmpOnly, hasUnicodeFlag) {
        if (hasUnicodeFlag) {
          return createUnicodeCharacterClasses(data);
        }
        var result = [];
        var parts = splitAtBMP(data);
        var loneHighSurrogates = parts.loneHighSurrogates;
        var loneLowSurrogates = parts.loneLowSurrogates;
        var bmp = parts.bmp;
        var astral = parts.astral;
        var hasLoneHighSurrogates = !dataIsEmpty(loneHighSurrogates);
        var hasLoneLowSurrogates = !dataIsEmpty(loneLowSurrogates);
        var surrogateMappings = surrogateSet(astral);
        if (bmpOnly) {
          bmp = dataAddData(bmp, loneHighSurrogates);
          hasLoneHighSurrogates = false;
          bmp = dataAddData(bmp, loneLowSurrogates);
          hasLoneLowSurrogates = false;
        }
        if (!dataIsEmpty(bmp)) {
          result.push(createBMPCharacterClasses(bmp));
        }
        if (surrogateMappings.length) {
          result.push(createSurrogateCharacterClasses(surrogateMappings));
        }
        if (hasLoneHighSurrogates) {
          result.push(createBMPCharacterClasses(loneHighSurrogates) + "(?![\\uDC00-\\uDFFF])");
        }
        if (hasLoneLowSurrogates) {
          result.push("(?:[^\\uD800-\\uDBFF]|^)" + createBMPCharacterClasses(loneLowSurrogates));
        }
        return result.join('|');
      };
      var _regenerate = function regenerate(value) {
        if (arguments.length > 1) {
          value = slice.call(arguments);
        }
        if (this instanceof _regenerate) {
          this.data = [];
          return value ? this.add(value) : this;
        }
        return new _regenerate().add(value);
      };
      _regenerate.version = '1.4.2';
      var proto = _regenerate.prototype;
      extend(proto, {
        'add': function add(value) {
          var $this = this;
          if (value == null) {
            return $this;
          }
          if (value instanceof _regenerate) {
            $this.data = dataAddData($this.data, value.data);
            return $this;
          }
          if (arguments.length > 1) {
            value = slice.call(arguments);
          }
          if (isArray(value)) {
            forEach(value, function (item) {
              $this.add(item);
            });
            return $this;
          }
          $this.data = dataAdd($this.data, isNumber(value) ? value : symbolToCodePoint(value));
          return $this;
        },
        'remove': function remove(value) {
          var $this = this;
          if (value == null) {
            return $this;
          }
          if (value instanceof _regenerate) {
            $this.data = dataRemoveData($this.data, value.data);
            return $this;
          }
          if (arguments.length > 1) {
            value = slice.call(arguments);
          }
          if (isArray(value)) {
            forEach(value, function (item) {
              $this.remove(item);
            });
            return $this;
          }
          $this.data = dataRemove($this.data, isNumber(value) ? value : symbolToCodePoint(value));
          return $this;
        },
        'addRange': function addRange(start, end) {
          var $this = this;
          $this.data = dataAddRange($this.data, isNumber(start) ? start : symbolToCodePoint(start), isNumber(end) ? end : symbolToCodePoint(end));
          return $this;
        },
        'removeRange': function removeRange(start, end) {
          var $this = this;
          var startCodePoint = isNumber(start) ? start : symbolToCodePoint(start);
          var endCodePoint = isNumber(end) ? end : symbolToCodePoint(end);
          $this.data = dataRemoveRange($this.data, startCodePoint, endCodePoint);
          return $this;
        },
        'intersection': function intersection(argument) {
          var $this = this;
          var array = argument instanceof _regenerate ? dataToArray(argument.data) : argument;
          $this.data = dataIntersection($this.data, array);
          return $this;
        },
        'contains': function contains(codePoint) {
          return dataContains(this.data, isNumber(codePoint) ? codePoint : symbolToCodePoint(codePoint));
        },
        'clone': function clone() {
          var set = new _regenerate();
          set.data = this.data.slice(0);
          return set;
        },
        'toString': function toString(options) {
          var result = createCharacterClassesFromData(this.data, options ? options.bmpOnly : false, options ? options.hasUnicodeFlag : false);
          if (!result) {
            return '[]';
          }
          return result.replace(regexNull, '\\0$1');
        },
        'toRegExp': function toRegExp(flags) {
          var pattern = this.toString(flags && flags.indexOf('u') != -1 ? {
            'hasUnicodeFlag': true
          } : null);
          return RegExp(pattern, flags || '');
        },
        'valueOf': function valueOf() {
          return dataToArray(this.data);
        }
      });
      proto.toArray = proto.valueOf;
      if (freeExports && !freeExports.nodeType) {
        if (freeModule) {
          freeModule.exports = _regenerate;
        } else {
          freeExports.regenerate = _regenerate;
        }
      } else {
        root.regenerate = _regenerate;
      }
    })(commonjsGlobal);
  })(regenerate$3, regenerate$3.exports);
  var regenerateExports = regenerate$3.exports;

var hasRequiredAlphabetic;
  function requireAlphabetic() {
    if (hasRequiredAlphabetic) return Alphabetic;
    hasRequiredAlphabetic = 1;
    var set = regenerateExports(0xAA, 0xB5, 0xBA, 0x2EC, 0x2EE, 0x345, 0x37F, 0x386, 0x38C, 0x559, 0x5BF, 0x5C7, 0x6FF, 0x7FA, 0x897, 0x9B2, 0x9CE, 0x9D7, 0x9FC, 0xA51, 0xA5E, 0xAD0, 0xB71, 0xB9C, 0xBD0, 0xBD7, 0xC5D, 0xD4E, 0xDBD, 0xDD6, 0xE4D, 0xE84, 0xEA5, 0xEC6, 0xECD, 0xF00, 0x1038, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x17DC, 0x1AA7, 0x1CFA, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0x2E2F, 0xA7D3, 0xA8C5, 0xA8FB, 0xA9CF, 0xAAC0, 0xAAC2, 0xFB3E, 0x10808, 0x1083C, 0x10D69, 0x10EFC, 0x10F27, 0x110C2, 0x11176, 0x111DA, 0x111DC, 0x11237, 0x11288, 0x11350, 0x11357, 0x1138B, 0x1138E, 0x113C2, 0x113C5, 0x113D1, 0x113D3, 0x114C7, 0x11640, 0x11644, 0x116B8, 0x11909, 0x119E1, 0x11A9D, 0x11C40, 0x11D3A, 0x11D43, 0x11D98, 0x11FB0, 0x16FE3, 0x1B132, 0x1B155, 0x1BC9E, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E08F, 0x1E14E, 0x1E5F0, 0x1E947, 0x1E94B, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E);
    set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x363, 0x374).addRange(0x376, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x5B0, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x610, 0x61A).addRange(0x620, 0x657).addRange(0x659, 0x65F).addRange(0x66E, 0x6D3).addRange(0x6D5, 0x6DC).addRange(0x6E1, 0x6E8).addRange(0x6ED, 0x6EF).addRange(0x6FA, 0x6FC).addRange(0x710, 0x73F).addRange(0x74D, 0x7B1).addRange(0x7CA, 0x7EA).addRange(0x7F4, 0x7F5).addRange(0x800, 0x817).addRange(0x81A, 0x82C).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88E).addRange(0x8A0, 0x8C9).addRange(0x8D4, 0x8DF).addRange(0x8E3, 0x8E9).addRange(0x8F0, 0x93B).addRange(0x93D, 0x94C).addRange(0x94E, 0x950).addRange(0x955, 0x963).addRange(0x971, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8);
    set.addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BD, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CC).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E3).addRange(0x9F0, 0x9F1).addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4C).addRange(0xA59, 0xA5C).addRange(0xA70, 0xA75).addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABD, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACC).addRange(0xAE0, 0xAE3).addRange(0xAF9, 0xAFC).addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3D, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4C).addRange(0xB56, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A);
    set.addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCC).addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3D, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4C).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC60, 0xC63).addRange(0xC80, 0xC83).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBD, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCC).addRange(0xCD5, 0xCD6).addRange(0xCDD, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCF1, 0xCF3).addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD3D, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4C).addRange(0xD54, 0xD57).addRange(0xD5F, 0xD63).addRange(0xD7A, 0xD7F).addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDF2, 0xDF3).addRange(0xE01, 0xE3A).addRange(0xE40, 0xE46).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A);
    set.addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB9).addRange(0xEBB, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEDC, 0xEDF).addRange(0xF40, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF83).addRange(0xF88, 0xF97).addRange(0xF99, 0xFBC).addRange(0x1000, 0x1036).addRange(0x103B, 0x103F).addRange(0x1050, 0x108F).addRange(0x109A, 0x109D).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8).addRange(0x1700, 0x1713).addRange(0x171F, 0x1733).addRange(0x1740, 0x1753).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773).addRange(0x1780, 0x17B3).addRange(0x17B6, 0x17C8).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1920, 0x192B);
    set.addRange(0x1930, 0x1938).addRange(0x1950, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x1A00, 0x1A1B).addRange(0x1A20, 0x1A5E).addRange(0x1A61, 0x1A74).addRange(0x1ABF, 0x1AC0).addRange(0x1ACC, 0x1ACE).addRange(0x1B00, 0x1B33).addRange(0x1B35, 0x1B43).addRange(0x1B45, 0x1B4C).addRange(0x1B80, 0x1BA9).addRange(0x1BAC, 0x1BAF).addRange(0x1BBA, 0x1BE5).addRange(0x1BE7, 0x1BF1).addRange(0x1C00, 0x1C36).addRange(0x1C4D, 0x1C4F).addRange(0x1C5A, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF6).addRange(0x1D00, 0x1DBF).addRange(0x1DD3, 0x1DF4).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x2090, 0x209C).addRange(0x210A, 0x2113).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x212F, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2160, 0x2188);
    set.addRange(0x24B6, 0x24E9).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x2DE0, 0x2DFF).addRange(0x3005, 0x3007).addRange(0x3021, 0x3029).addRange(0x3031, 0x3035).addRange(0x3038, 0x303C).addRange(0x3041, 0x3096).addRange(0x309D, 0x309F).addRange(0x30A1, 0x30FA).addRange(0x30FC, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA61F).addRange(0xA62A, 0xA62B).addRange(0xA640, 0xA66E).addRange(0xA674, 0xA67B).addRange(0xA67F, 0xA6EF).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F2, 0xA805).addRange(0xA807, 0xA827).addRange(0xA840, 0xA873).addRange(0xA880, 0xA8C3).addRange(0xA8F2, 0xA8F7).addRange(0xA8FD, 0xA8FF).addRange(0xA90A, 0xA92A).addRange(0xA930, 0xA952).addRange(0xA960, 0xA97C);
    set.addRange(0xA980, 0xA9B2).addRange(0xA9B4, 0xA9BF).addRange(0xA9E0, 0xA9EF).addRange(0xA9FA, 0xA9FE).addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA60, 0xAA76).addRange(0xAA7A, 0xAABE).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEF).addRange(0xAAF2, 0xAAF5).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABEA).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1D, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFB).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF66, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D);
    set.addRange(0x10080, 0x100FA).addRange(0x10140, 0x10174).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x10300, 0x1031F).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x1037A).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x103D1, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A00, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7);
    set.addRange(0x10AC9, 0x10AE4).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91).addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D27).addRange(0x10D4A, 0x10D65).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAC).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC4).addRange(0x10F00, 0x10F1C).addRange(0x10F30, 0x10F45).addRange(0x10F70, 0x10F81).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11000, 0x11045).addRange(0x11071, 0x11075).addRange(0x11080, 0x110B8).addRange(0x110D0, 0x110E8).addRange(0x11100, 0x11132).addRange(0x11144, 0x11147).addRange(0x11150, 0x11172).addRange(0x11180, 0x111BF).addRange(0x111C1, 0x111C4).addRange(0x111CE, 0x111CF).addRange(0x11200, 0x11211).addRange(0x11213, 0x11234).addRange(0x1123E, 0x11241).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112E8).addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133D, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134C).addRange(0x1135D, 0x11363).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5);
    set.addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113CD).addRange(0x11400, 0x11441).addRange(0x11443, 0x11445).addRange(0x11447, 0x1144A).addRange(0x1145F, 0x11461).addRange(0x11480, 0x114C1).addRange(0x114C4, 0x114C5).addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115BE).addRange(0x115D8, 0x115DD).addRange(0x11600, 0x1163E).addRange(0x11680, 0x116B5).addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172A).addRange(0x11740, 0x11746).addRange(0x11800, 0x11838).addRange(0x118A0, 0x118DF).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x1193C).addRange(0x1193F, 0x11942).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D7).addRange(0x119DA, 0x119DF).addRange(0x119E3, 0x119E4).addRange(0x11A00, 0x11A32).addRange(0x11A35, 0x11A3E).addRange(0x11A50, 0x11A97).addRange(0x11AB0, 0x11AF8).addRange(0x11BC0, 0x11BE0).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C3E).addRange(0x11C72, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D41).addRange(0x11D46, 0x11D47).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91);
    set.addRange(0x11D93, 0x11D96).addRange(0x11EE0, 0x11EF6).addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F40).addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1612E).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A70, 0x16ABE).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B40, 0x16B43).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D6C).addRange(0x16E40, 0x16E7F).addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FF0, 0x16FF1).addRange(0x17000, 0x187F7).addRange(0x18800, 0x18CD5).addRange(0x18CFF, 0x18D08).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505);
    set.addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E137, 0x1E13D).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E4D0, 0x1E4EB).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E900, 0x1E943).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C);
    set.addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1F130, 0x1F149).addRange(0x1F150, 0x1F169).addRange(0x1F170, 0x1F189).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF);
    Alphabetic.characters = set;
    return Alphabetic;
  }

var Any = {};

var hasRequiredAny;
  function requireAny() {
    if (hasRequiredAny) return Any;
    hasRequiredAny = 1;
    var set = regenerateExports();
    set.addRange(0x0, 0x10FFFF);
    Any.characters = set;
    return Any;
  }

var ASCII_Hex_Digit = {};

var hasRequiredASCII_Hex_Digit;
  function requireASCII_Hex_Digit() {
    if (hasRequiredASCII_Hex_Digit) return ASCII_Hex_Digit;
    hasRequiredASCII_Hex_Digit = 1;
    var set = regenerateExports();
    set.addRange(0x30, 0x39).addRange(0x41, 0x46).addRange(0x61, 0x66);
    ASCII_Hex_Digit.characters = set;
    return ASCII_Hex_Digit;
  }

var ASCII = {};

var hasRequiredASCII;
  function requireASCII() {
    if (hasRequiredASCII) return ASCII;
    hasRequiredASCII = 1;
    var set = regenerateExports();
    set.addRange(0x0, 0x7F);
    ASCII.characters = set;
    return ASCII;
  }

var Assigned = {};

var hasRequiredAssigned;
  function requireAssigned() {
    if (hasRequiredAssigned) return Assigned;
    hasRequiredAssigned = 1;
    var set = regenerateExports(0x38C, 0x85E, 0x9B2, 0x9D7, 0xA3C, 0xA51, 0xA5E, 0xAD0, 0xB9C, 0xBD0, 0xBD7, 0xC5D, 0xDBD, 0xDCA, 0xDD6, 0xE84, 0xEA5, 0xEC6, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x1940, 0x1F59, 0x1F5B, 0x1F5D, 0x2D27, 0x2D2D, 0xA7D3, 0xFB3E, 0xFDCF, 0xFEFF, 0x101A0, 0x10808, 0x1083C, 0x1093F, 0x110CD, 0x11288, 0x11350, 0x11357, 0x1138B, 0x1138E, 0x113C2, 0x113C5, 0x11909, 0x11D3A, 0x11FB0, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E08F, 0x1E2FF, 0x1E5FF, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E, 0x1F7F0, 0xE0001);
    set.addRange(0x0, 0x377).addRange(0x37A, 0x37F).addRange(0x384, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x52F).addRange(0x531, 0x556).addRange(0x559, 0x58A).addRange(0x58D, 0x58F).addRange(0x591, 0x5C7).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F4).addRange(0x600, 0x70D).addRange(0x70F, 0x74A).addRange(0x74D, 0x7B1).addRange(0x7C0, 0x7FA).addRange(0x7FD, 0x82D).addRange(0x830, 0x83E).addRange(0x840, 0x85B).addRange(0x860, 0x86A).addRange(0x870, 0x88E).addRange(0x890, 0x891).addRange(0x897, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BC, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CE).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E3).addRange(0x9E6, 0x9FE).addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA76).addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0);
    set.addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABC, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE0, 0xAE3).addRange(0xAE6, 0xAF1).addRange(0xAF9, 0xAFF).addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3C, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB66, 0xB77).addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD).addRange(0xBE6, 0xBFA).addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3C, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC60, 0xC63).addRange(0xC66, 0xC6F).addRange(0xC77, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9);
    set.addRange(0xCBC, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCDD, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3).addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4F).addRange(0xD54, 0xD63).addRange(0xD66, 0xD7F).addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF4).addRange(0xE01, 0xE3A).addRange(0xE3F, 0xE5B).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEC8, 0xECE).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF).addRange(0xF00, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF97).addRange(0xF99, 0xFBC).addRange(0xFBE, 0xFCC).addRange(0xFCE, 0xFDA).addRange(0x1000, 0x10C5).addRange(0x10D0, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5);
    set.addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x135D, 0x137C).addRange(0x1380, 0x1399).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1400, 0x169C).addRange(0x16A0, 0x16F8).addRange(0x1700, 0x1715).addRange(0x171F, 0x1736).addRange(0x1740, 0x1753).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773).addRange(0x1780, 0x17DD).addRange(0x17E0, 0x17E9).addRange(0x17F0, 0x17F9).addRange(0x1800, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1944, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x19DE, 0x1A1B).addRange(0x1A1E, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1A7F, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AA0, 0x1AAD).addRange(0x1AB0, 0x1ACE).addRange(0x1B00, 0x1B4C).addRange(0x1B4E, 0x1BF3).addRange(0x1BFC, 0x1C37).addRange(0x1C3B, 0x1C49).addRange(0x1C4D, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CC7).addRange(0x1CD0, 0x1CFA).addRange(0x1D00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57);
    set.addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FC4).addRange(0x1FC6, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FDD, 0x1FEF).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFE).addRange(0x2000, 0x2064).addRange(0x2066, 0x2071).addRange(0x2074, 0x208E).addRange(0x2090, 0x209C).addRange(0x20A0, 0x20C0).addRange(0x20D0, 0x20F0).addRange(0x2100, 0x218B).addRange(0x2190, 0x2429).addRange(0x2440, 0x244A).addRange(0x2460, 0x2B73).addRange(0x2B76, 0x2B95).addRange(0x2B97, 0x2CF3).addRange(0x2CF9, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D6F, 0x2D70).addRange(0x2D7F, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x2DE0, 0x2E5D).addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x2FF0, 0x303F).addRange(0x3041, 0x3096).addRange(0x3099, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x3190, 0x31E5).addRange(0x31EF, 0x321E).addRange(0x3220, 0xA48C).addRange(0xA490, 0xA4C6).addRange(0xA4D0, 0xA62B).addRange(0xA640, 0xA6F7).addRange(0xA700, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F2, 0xA82C);
    set.addRange(0xA830, 0xA839).addRange(0xA840, 0xA877).addRange(0xA880, 0xA8C5).addRange(0xA8CE, 0xA8D9).addRange(0xA8E0, 0xA953).addRange(0xA95F, 0xA97C).addRange(0xA980, 0xA9CD).addRange(0xA9CF, 0xA9D9).addRange(0xA9DE, 0xA9FE).addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA50, 0xAA59).addRange(0xAA5C, 0xAAC2).addRange(0xAADB, 0xAAF6).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB6B).addRange(0xAB70, 0xABED).addRange(0xABF0, 0xABF9).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xD800, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1D, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBC2).addRange(0xFBD3, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFE19).addRange(0xFE20, 0xFE52).addRange(0xFE54, 0xFE66).addRange(0xFE68, 0xFE6B).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF01, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFF9, 0xFFFD).addRange(0x10000, 0x1000B);
    set.addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10100, 0x10102).addRange(0x10107, 0x10133).addRange(0x10137, 0x1018E).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FD).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x102E0, 0x102FB).addRange(0x10300, 0x10323).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x1037A).addRange(0x10380, 0x1039D).addRange(0x1039F, 0x103C3).addRange(0x103C8, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104A0, 0x104A9).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x1056F, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10857, 0x1089E).addRange(0x108A7, 0x108AF).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x108FB, 0x1091B).addRange(0x1091F, 0x10939);
    set.addRange(0x10980, 0x109B7).addRange(0x109BC, 0x109CF).addRange(0x109D2, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A38, 0x10A3A).addRange(0x10A3F, 0x10A48).addRange(0x10A50, 0x10A58).addRange(0x10A60, 0x10A9F).addRange(0x10AC0, 0x10AE6).addRange(0x10AEB, 0x10AF6).addRange(0x10B00, 0x10B35).addRange(0x10B39, 0x10B55).addRange(0x10B58, 0x10B72).addRange(0x10B78, 0x10B91).addRange(0x10B99, 0x10B9C).addRange(0x10BA9, 0x10BAF).addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10CFA, 0x10D27).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D65).addRange(0x10D69, 0x10D85).addRange(0x10D8E, 0x10D8F).addRange(0x10E60, 0x10E7E).addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAD).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC4).addRange(0x10EFC, 0x10F27).addRange(0x10F30, 0x10F59).addRange(0x10F70, 0x10F89).addRange(0x10FB0, 0x10FCB).addRange(0x10FE0, 0x10FF6).addRange(0x11000, 0x1104D).addRange(0x11052, 0x11075).addRange(0x1107F, 0x110C2).addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9).addRange(0x11100, 0x11134).addRange(0x11136, 0x11147).addRange(0x11150, 0x11176).addRange(0x11180, 0x111DF).addRange(0x111E1, 0x111F4).addRange(0x11200, 0x11211).addRange(0x11213, 0x11241).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D);
    set.addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A9).addRange(0x112B0, 0x112EA).addRange(0x112F0, 0x112F9).addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133B, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x1135D, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x113E1, 0x113E2).addRange(0x11400, 0x1145B).addRange(0x1145D, 0x11461).addRange(0x11480, 0x114C7).addRange(0x114D0, 0x114D9).addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115DD).addRange(0x11600, 0x11644).addRange(0x11650, 0x11659).addRange(0x11660, 0x1166C).addRange(0x11680, 0x116B9).addRange(0x116C0, 0x116C9).addRange(0x116D0, 0x116E3).addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172B).addRange(0x11730, 0x11746).addRange(0x11800, 0x1183B).addRange(0x118A0, 0x118F2).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x11946).addRange(0x11950, 0x11959).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D7).addRange(0x119DA, 0x119E4);
    set.addRange(0x11A00, 0x11A47).addRange(0x11A50, 0x11AA2).addRange(0x11AB0, 0x11AF8).addRange(0x11B00, 0x11B09).addRange(0x11BC0, 0x11BE1).addRange(0x11BF0, 0x11BF9).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C45).addRange(0x11C50, 0x11C6C).addRange(0x11C70, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D47).addRange(0x11D50, 0x11D59).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D98).addRange(0x11DA0, 0x11DA9).addRange(0x11EE0, 0x11EF8).addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F5A).addRange(0x11FC0, 0x11FF1).addRange(0x11FFF, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12470, 0x12474).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF2).addRange(0x13000, 0x13455).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x16139).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A6E, 0x16ABE).addRange(0x16AC0, 0x16AC9).addRange(0x16AD0, 0x16AED).addRange(0x16AF0, 0x16AF5).addRange(0x16B00, 0x16B45).addRange(0x16B50, 0x16B59).addRange(0x16B5B, 0x16B61).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F);
    set.addRange(0x16D40, 0x16D79).addRange(0x16E40, 0x16E9A).addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F).addRange(0x16FE0, 0x16FE4).addRange(0x16FF0, 0x16FF1).addRange(0x17000, 0x187F7).addRange(0x18800, 0x18CD5).addRange(0x18CFF, 0x18D08).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1BC9C, 0x1BCA3).addRange(0x1CC00, 0x1CCF9).addRange(0x1CD00, 0x1CEB3).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D1EA).addRange(0x1D200, 0x1D245).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D300, 0x1D356).addRange(0x1D360, 0x1D378).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5);
    set.addRange(0x1D6A8, 0x1D7CB).addRange(0x1D7CE, 0x1DA8B).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E130, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E14E, 0x1E14F).addRange(0x1E290, 0x1E2AE).addRange(0x1E2C0, 0x1E2F9).addRange(0x1E4D0, 0x1E4F9).addRange(0x1E5D0, 0x1E5FA).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E8C7, 0x1E8D6).addRange(0x1E900, 0x1E94B).addRange(0x1E950, 0x1E959).addRange(0x1E95E, 0x1E95F).addRange(0x1EC71, 0x1ECB4).addRange(0x1ED01, 0x1ED3D).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1EEF0, 0x1EEF1).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093);
    set.addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF).addRange(0x1F0D1, 0x1F0F5).addRange(0x1F100, 0x1F1AD).addRange(0x1F1E6, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F250, 0x1F251).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F6D7).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F776).addRange(0x1F77B, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F900, 0x1FA53).addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA89).addRange(0x1FA8F, 0x1FAC6).addRange(0x1FACE, 0x1FADC).addRange(0x1FADF, 0x1FAE9).addRange(0x1FAF0, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBF9).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF).addRange(0xE0020, 0xE007F).addRange(0xE0100, 0xE01EF).addRange(0xF0000, 0xFFFFD).addRange(0x100000, 0x10FFFD);
    Assigned.characters = set;
    return Assigned;
  }

var Bidi_Control = {};

var hasRequiredBidi_Control;
  function requireBidi_Control() {
    if (hasRequiredBidi_Control) return Bidi_Control;
    hasRequiredBidi_Control = 1;
    var set = regenerateExports(0x61C);
    set.addRange(0x200E, 0x200F).addRange(0x202A, 0x202E).addRange(0x2066, 0x2069);
    Bidi_Control.characters = set;
    return Bidi_Control;
  }

var Bidi_Mirrored = {};

var hasRequiredBidi_Mirrored;
  function requireBidi_Mirrored() {
    if (hasRequiredBidi_Mirrored) return Bidi_Mirrored;
    hasRequiredBidi_Mirrored = 1;
    var set = regenerateExports(0x3C, 0x3E, 0x5B, 0x5D, 0x7B, 0x7D, 0xAB, 0xBB, 0x2140, 0x2211, 0x2224, 0x2226, 0x2239, 0x2262, 0x2298, 0x27C0, 0x29B8, 0x29C9, 0x29E1, 0x2A24, 0x2A26, 0x2A29, 0x2ADC, 0x2ADE, 0x2AF3, 0x2AFD, 0x2BFE, 0xFF1C, 0xFF1E, 0xFF3B, 0xFF3D, 0xFF5B, 0xFF5D, 0x1D6DB, 0x1D715, 0x1D74F, 0x1D789, 0x1D7C3);
    set.addRange(0x28, 0x29).addRange(0xF3A, 0xF3D).addRange(0x169B, 0x169C).addRange(0x2039, 0x203A).addRange(0x2045, 0x2046).addRange(0x207D, 0x207E).addRange(0x208D, 0x208E).addRange(0x2201, 0x2204).addRange(0x2208, 0x220D).addRange(0x2215, 0x2216).addRange(0x221A, 0x221D).addRange(0x221F, 0x2222).addRange(0x222B, 0x2233).addRange(0x223B, 0x224C).addRange(0x2252, 0x2255).addRange(0x225F, 0x2260).addRange(0x2264, 0x226B).addRange(0x226D, 0x228C).addRange(0x228F, 0x2292).addRange(0x22A2, 0x22A3).addRange(0x22A6, 0x22B8).addRange(0x22BE, 0x22BF).addRange(0x22C9, 0x22CD).addRange(0x22D0, 0x22D1).addRange(0x22D6, 0x22ED).addRange(0x22F0, 0x22FF).addRange(0x2308, 0x230B).addRange(0x2320, 0x2321).addRange(0x2329, 0x232A).addRange(0x2768, 0x2775).addRange(0x27C3, 0x27C6).addRange(0x27C8, 0x27C9).addRange(0x27CB, 0x27CD).addRange(0x27D3, 0x27D6).addRange(0x27DC, 0x27DE).addRange(0x27E2, 0x27EF).addRange(0x2983, 0x2998).addRange(0x299B, 0x29A0).addRange(0x29A2, 0x29AF).addRange(0x29C0, 0x29C5).addRange(0x29CE, 0x29D2).addRange(0x29D4, 0x29D5).addRange(0x29D8, 0x29DC).addRange(0x29E3, 0x29E5).addRange(0x29E8, 0x29E9).addRange(0x29F4, 0x29F9).addRange(0x29FC, 0x29FD).addRange(0x2A0A, 0x2A1C).addRange(0x2A1E, 0x2A21).addRange(0x2A2B, 0x2A2E).addRange(0x2A34, 0x2A35);
    set.addRange(0x2A3C, 0x2A3E).addRange(0x2A57, 0x2A58).addRange(0x2A64, 0x2A65).addRange(0x2A6A, 0x2A6D).addRange(0x2A6F, 0x2A70).addRange(0x2A73, 0x2A74).addRange(0x2A79, 0x2AA3).addRange(0x2AA6, 0x2AAD).addRange(0x2AAF, 0x2AD6).addRange(0x2AE2, 0x2AE6).addRange(0x2AEC, 0x2AEE).addRange(0x2AF7, 0x2AFB).addRange(0x2E02, 0x2E05).addRange(0x2E09, 0x2E0A).addRange(0x2E0C, 0x2E0D).addRange(0x2E1C, 0x2E1D).addRange(0x2E20, 0x2E29).addRange(0x2E55, 0x2E5C).addRange(0x3008, 0x3011).addRange(0x3014, 0x301B).addRange(0xFE59, 0xFE5E).addRange(0xFE64, 0xFE65).addRange(0xFF08, 0xFF09).addRange(0xFF5F, 0xFF60).addRange(0xFF62, 0xFF63);
    Bidi_Mirrored.characters = set;
    return Bidi_Mirrored;
  }

var Case_Ignorable = {};

var hasRequiredCase_Ignorable;
  function requireCase_Ignorable() {
    if (hasRequiredCase_Ignorable) return Case_Ignorable;
    hasRequiredCase_Ignorable = 1;
    var set = regenerateExports(0x27, 0x2E, 0x3A, 0x5E, 0x60, 0xA8, 0xAD, 0xAF, 0xB4, 0x37A, 0x387, 0x559, 0x55F, 0x5BF, 0x5C7, 0x5F4, 0x61C, 0x640, 0x670, 0x70F, 0x711, 0x7FA, 0x7FD, 0x888, 0x93A, 0x93C, 0x94D, 0x971, 0x981, 0x9BC, 0x9CD, 0x9FE, 0xA3C, 0xA51, 0xA75, 0xABC, 0xACD, 0xB01, 0xB3C, 0xB3F, 0xB4D, 0xB82, 0xBC0, 0xBCD, 0xC00, 0xC04, 0xC3C, 0xC81, 0xCBC, 0xCBF, 0xCC6, 0xD4D, 0xD81, 0xDCA, 0xDD6, 0xE31, 0xEB1, 0xEC6, 0xF35, 0xF37, 0xF39, 0xFC6, 0x1082, 0x108D, 0x109D, 0x10FC, 0x17C6, 0x17D7, 0x17DD, 0x1843, 0x18A9, 0x1932, 0x1A1B, 0x1A56, 0x1A60, 0x1A62, 0x1A7F, 0x1AA7, 0x1B34, 0x1B3C, 0x1B42, 0x1BE6, 0x1BED, 0x1CED, 0x1CF4, 0x1D78, 0x1FBD, 0x2024, 0x2027, 0x2071, 0x207F, 0x2D6F, 0x2D7F, 0x2E2F, 0x3005, 0x303B, 0xA015, 0xA60C, 0xA67F, 0xA770, 0xA802, 0xA806, 0xA80B, 0xA82C, 0xA8FF, 0xA9B3, 0xA9CF, 0xAA43, 0xAA4C, 0xAA70, 0xAA7C, 0xAAB0, 0xAAC1, 0xAADD, 0xAAF6, 0xABE5, 0xABE8, 0xABED, 0xFB1E, 0xFE13, 0xFE52, 0xFE55, 0xFEFF, 0xFF07, 0xFF0E, 0xFF1A, 0xFF3E, 0xFF40, 0xFF70, 0xFFE3, 0x101FD, 0x102E0, 0x10A3F, 0x10D4E, 0x10D6F, 0x11001, 0x11070, 0x110BD, 0x110C2, 0x110CD, 0x11173, 0x111CF, 0x11234, 0x1123E, 0x11241, 0x112DF, 0x11340, 0x113CE, 0x113D0, 0x113D2, 0x11446, 0x1145E, 0x114BA, 0x1163D, 0x116AB, 0x116AD, 0x116B7, 0x1171D, 0x1171F, 0x1193E, 0x11943, 0x119E0, 0x11A47, 0x11C3F, 0x11D3A, 0x11D47, 0x11D95, 0x11D97, 0x11F40, 0x11F42, 0x11F5A, 0x16F4F, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E2AE, 0xE0001);
    set.addRange(0xB7, 0xB8).addRange(0x2B0, 0x36F).addRange(0x374, 0x375).addRange(0x384, 0x385).addRange(0x483, 0x489).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x600, 0x605).addRange(0x610, 0x61A).addRange(0x64B, 0x65F).addRange(0x6D6, 0x6DD).addRange(0x6DF, 0x6E8).addRange(0x6EA, 0x6ED).addRange(0x730, 0x74A).addRange(0x7A6, 0x7B0).addRange(0x7EB, 0x7F5).addRange(0x816, 0x82D).addRange(0x859, 0x85B).addRange(0x890, 0x891).addRange(0x897, 0x89F).addRange(0x8C9, 0x902).addRange(0x941, 0x948).addRange(0x951, 0x957).addRange(0x962, 0x963).addRange(0x9C1, 0x9C4).addRange(0x9E2, 0x9E3).addRange(0xA01, 0xA02).addRange(0xA41, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA70, 0xA71).addRange(0xA81, 0xA82).addRange(0xAC1, 0xAC5).addRange(0xAC7, 0xAC8).addRange(0xAE2, 0xAE3).addRange(0xAFA, 0xAFF).addRange(0xB41, 0xB44).addRange(0xB55, 0xB56).addRange(0xB62, 0xB63).addRange(0xC3E, 0xC40).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC62, 0xC63).addRange(0xCCC, 0xCCD).addRange(0xCE2, 0xCE3).addRange(0xD00, 0xD01).addRange(0xD3B, 0xD3C).addRange(0xD41, 0xD44).addRange(0xD62, 0xD63);
    set.addRange(0xDD2, 0xDD4).addRange(0xE34, 0xE3A).addRange(0xE46, 0xE4E).addRange(0xEB4, 0xEBC).addRange(0xEC8, 0xECE).addRange(0xF18, 0xF19).addRange(0xF71, 0xF7E).addRange(0xF80, 0xF84).addRange(0xF86, 0xF87).addRange(0xF8D, 0xF97).addRange(0xF99, 0xFBC).addRange(0x102D, 0x1030).addRange(0x1032, 0x1037).addRange(0x1039, 0x103A).addRange(0x103D, 0x103E).addRange(0x1058, 0x1059).addRange(0x105E, 0x1060).addRange(0x1071, 0x1074).addRange(0x1085, 0x1086).addRange(0x135D, 0x135F).addRange(0x1712, 0x1714).addRange(0x1732, 0x1733).addRange(0x1752, 0x1753).addRange(0x1772, 0x1773).addRange(0x17B4, 0x17B5).addRange(0x17B7, 0x17BD).addRange(0x17C9, 0x17D3).addRange(0x180B, 0x180F).addRange(0x1885, 0x1886).addRange(0x1920, 0x1922).addRange(0x1927, 0x1928).addRange(0x1939, 0x193B).addRange(0x1A17, 0x1A18).addRange(0x1A58, 0x1A5E).addRange(0x1A65, 0x1A6C).addRange(0x1A73, 0x1A7C).addRange(0x1AB0, 0x1ACE).addRange(0x1B00, 0x1B03).addRange(0x1B36, 0x1B3A).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1B81).addRange(0x1BA2, 0x1BA5).addRange(0x1BA8, 0x1BA9).addRange(0x1BAB, 0x1BAD).addRange(0x1BE8, 0x1BE9).addRange(0x1BEF, 0x1BF1).addRange(0x1C2C, 0x1C33).addRange(0x1C36, 0x1C37).addRange(0x1C78, 0x1C7D).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CE0);
    set.addRange(0x1CE2, 0x1CE8).addRange(0x1CF8, 0x1CF9).addRange(0x1D2C, 0x1D6A).addRange(0x1D9B, 0x1DFF).addRange(0x1FBF, 0x1FC1).addRange(0x1FCD, 0x1FCF).addRange(0x1FDD, 0x1FDF).addRange(0x1FED, 0x1FEF).addRange(0x1FFD, 0x1FFE).addRange(0x200B, 0x200F).addRange(0x2018, 0x2019).addRange(0x202A, 0x202E).addRange(0x2060, 0x2064).addRange(0x2066, 0x206F).addRange(0x2090, 0x209C).addRange(0x20D0, 0x20F0).addRange(0x2C7C, 0x2C7D).addRange(0x2CEF, 0x2CF1).addRange(0x2DE0, 0x2DFF).addRange(0x302A, 0x302D).addRange(0x3031, 0x3035).addRange(0x3099, 0x309E).addRange(0x30FC, 0x30FE).addRange(0xA4F8, 0xA4FD).addRange(0xA66F, 0xA672).addRange(0xA674, 0xA67D).addRange(0xA69C, 0xA69F).addRange(0xA6F0, 0xA6F1).addRange(0xA700, 0xA721).addRange(0xA788, 0xA78A).addRange(0xA7F2, 0xA7F4).addRange(0xA7F8, 0xA7F9).addRange(0xA825, 0xA826).addRange(0xA8C4, 0xA8C5).addRange(0xA8E0, 0xA8F1).addRange(0xA926, 0xA92D).addRange(0xA947, 0xA951).addRange(0xA980, 0xA982).addRange(0xA9B6, 0xA9B9).addRange(0xA9BC, 0xA9BD).addRange(0xA9E5, 0xA9E6).addRange(0xAA29, 0xAA2E).addRange(0xAA31, 0xAA32).addRange(0xAA35, 0xAA36).addRange(0xAAB2, 0xAAB4).addRange(0xAAB7, 0xAAB8).addRange(0xAABE, 0xAABF).addRange(0xAAEC, 0xAAED).addRange(0xAAF3, 0xAAF4).addRange(0xAB5B, 0xAB5F).addRange(0xAB69, 0xAB6B);
    set.addRange(0xFBB2, 0xFBC2).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0xFF9E, 0xFF9F).addRange(0xFFF9, 0xFFFB).addRange(0x10376, 0x1037A).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10A01, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A0F).addRange(0x10A38, 0x10A3A).addRange(0x10AE5, 0x10AE6).addRange(0x10D24, 0x10D27).addRange(0x10D69, 0x10D6D).addRange(0x10EAB, 0x10EAC).addRange(0x10EFC, 0x10EFF).addRange(0x10F46, 0x10F50).addRange(0x10F82, 0x10F85).addRange(0x11038, 0x11046).addRange(0x11073, 0x11074).addRange(0x1107F, 0x11081).addRange(0x110B3, 0x110B6).addRange(0x110B9, 0x110BA).addRange(0x11100, 0x11102).addRange(0x11127, 0x1112B).addRange(0x1112D, 0x11134).addRange(0x11180, 0x11181).addRange(0x111B6, 0x111BE).addRange(0x111C9, 0x111CC).addRange(0x1122F, 0x11231).addRange(0x11236, 0x11237).addRange(0x112E3, 0x112EA).addRange(0x11300, 0x11301).addRange(0x1133B, 0x1133C).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x113BB, 0x113C0).addRange(0x113E1, 0x113E2).addRange(0x11438, 0x1143F).addRange(0x11442, 0x11444).addRange(0x114B3, 0x114B8).addRange(0x114BF, 0x114C0).addRange(0x114C2, 0x114C3).addRange(0x115B2, 0x115B5).addRange(0x115BC, 0x115BD).addRange(0x115BF, 0x115C0).addRange(0x115DC, 0x115DD).addRange(0x11633, 0x1163A).addRange(0x1163F, 0x11640);
    set.addRange(0x116B0, 0x116B5).addRange(0x11722, 0x11725).addRange(0x11727, 0x1172B).addRange(0x1182F, 0x11837).addRange(0x11839, 0x1183A).addRange(0x1193B, 0x1193C).addRange(0x119D4, 0x119D7).addRange(0x119DA, 0x119DB).addRange(0x11A01, 0x11A0A).addRange(0x11A33, 0x11A38).addRange(0x11A3B, 0x11A3E).addRange(0x11A51, 0x11A56).addRange(0x11A59, 0x11A5B).addRange(0x11A8A, 0x11A96).addRange(0x11A98, 0x11A99).addRange(0x11C30, 0x11C36).addRange(0x11C38, 0x11C3D).addRange(0x11C92, 0x11CA7).addRange(0x11CAA, 0x11CB0).addRange(0x11CB2, 0x11CB3).addRange(0x11CB5, 0x11CB6).addRange(0x11D31, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D45).addRange(0x11D90, 0x11D91).addRange(0x11EF3, 0x11EF4).addRange(0x11F00, 0x11F01).addRange(0x11F36, 0x11F3A).addRange(0x13430, 0x13440).addRange(0x13447, 0x13455).addRange(0x1611E, 0x16129).addRange(0x1612D, 0x1612F).addRange(0x16AF0, 0x16AF4).addRange(0x16B30, 0x16B36).addRange(0x16B40, 0x16B43).addRange(0x16D40, 0x16D42).addRange(0x16D6B, 0x16D6C).addRange(0x16F8F, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FE3, 0x16FE4).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1BC9D, 0x1BC9E).addRange(0x1BCA0, 0x1BCA3).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D167, 0x1D169).addRange(0x1D173, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD);
    set.addRange(0x1D242, 0x1D244).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E030, 0x1E06D).addRange(0x1E130, 0x1E13D).addRange(0x1E2EC, 0x1E2EF).addRange(0x1E4EB, 0x1E4EF).addRange(0x1E5EE, 0x1E5EF).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E944, 0x1E94B).addRange(0x1F3FB, 0x1F3FF).addRange(0xE0020, 0xE007F).addRange(0xE0100, 0xE01EF);
    Case_Ignorable.characters = set;
    return Case_Ignorable;
  }

var Cased = {};

var hasRequiredCased;
  function requireCased() {
    if (hasRequiredCased) return Cased;
    hasRequiredCased = 1;
    var set = regenerateExports(0xAA, 0xB5, 0xBA, 0x345, 0x37F, 0x386, 0x38C, 0x10C7, 0x10CD, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2139, 0x214E, 0x2D27, 0x2D2D, 0xA7D3, 0x10780, 0x1D4A2, 0x1D4BB, 0x1D546);
    set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x1BA).addRange(0x1BC, 0x1BF).addRange(0x1C4, 0x293).addRange(0x295, 0x2B8).addRange(0x2C0, 0x2C1).addRange(0x2E0, 0x2E4).addRange(0x370, 0x373).addRange(0x376, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x10FF).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1D00, 0x1DBF).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x2090, 0x209C).addRange(0x210A, 0x2113).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x212F, 0x2134).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149);
    set.addRange(0x2160, 0x217F).addRange(0x2183, 0x2184).addRange(0x24B6, 0x24E9).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0xA640, 0xA66D).addRange(0xA680, 0xA69D).addRange(0xA722, 0xA787).addRange(0xA78B, 0xA78E).addRange(0xA790, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F2, 0xA7F6).addRange(0xA7F8, 0xA7FA).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0x10400, 0x1044F).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10783, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D50, 0x10D65).addRange(0x10D70, 0x10D85).addRange(0x118A0, 0x118DF).addRange(0x16E40, 0x16E7F).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505);
    set.addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF09).addRange(0x1DF0B, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E030, 0x1E06D).addRange(0x1E900, 0x1E943).addRange(0x1F130, 0x1F149).addRange(0x1F150, 0x1F169).addRange(0x1F170, 0x1F189);
    Cased.characters = set;
    return Cased;
  }

var Changes_When_Casefolded = {};

var hasRequiredChanges_When_Casefolded;
  function requireChanges_When_Casefolded() {
    if (hasRequiredChanges_When_Casefolded) return Changes_When_Casefolded;
    hasRequiredChanges_When_Casefolded = 1;
    var set = regenerateExports(0xB5, 0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x17B, 0x17D, 0x17F, 0x184, 0x1A2, 0x1A4, 0x1A9, 0x1AC, 0x1B5, 0x1BC, 0x1CD, 0x1CF, 0x1D1, 0x1D3, 0x1D5, 0x1D7, 0x1D9, 0x1DB, 0x1DE, 0x1E0, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x1EA, 0x1EC, 0x1EE, 0x1F4, 0x1FA, 0x1FC, 0x1FE, 0x200, 0x202, 0x204, 0x206, 0x208, 0x20A, 0x20C, 0x20E, 0x210, 0x212, 0x214, 0x216, 0x218, 0x21A, 0x21C, 0x21E, 0x220, 0x222, 0x224, 0x226, 0x228, 0x22A, 0x22C, 0x22E, 0x230, 0x232, 0x241, 0x248, 0x24A, 0x24C, 0x24E, 0x345, 0x370, 0x372, 0x376, 0x37F, 0x386, 0x38C, 0x3C2, 0x3D8, 0x3DA, 0x3DC, 0x3DE, 0x3E0, 0x3E2, 0x3E4, 0x3E6, 0x3E8, 0x3EA, 0x3EC, 0x3EE, 0x3F7, 0x460, 0x462, 0x464, 0x466, 0x468, 0x46A, 0x46C, 0x46E, 0x470, 0x472, 0x474, 0x476, 0x478, 0x47A, 0x47C, 0x47E, 0x480, 0x48A, 0x48C, 0x48E, 0x490, 0x492, 0x494, 0x496, 0x498, 0x49A, 0x49C, 0x49E, 0x4A0, 0x4A2, 0x4A4, 0x4A6, 0x4A8, 0x4AA, 0x4AC, 0x4AE, 0x4B0, 0x4B2, 0x4B4, 0x4B6, 0x4B8, 0x4BA, 0x4BC, 0x4BE, 0x4C3, 0x4C5, 0x4C7, 0x4C9, 0x4CB, 0x4CD, 0x4D0, 0x4D2, 0x4D4, 0x4D6, 0x4D8, 0x4DA, 0x4DC, 0x4DE, 0x4E0, 0x4E2, 0x4E4, 0x4E6, 0x4E8, 0x4EA, 0x4EC, 0x4EE, 0x4F0, 0x4F2, 0x4F4, 0x4F6, 0x4F8, 0x4FA, 0x4FC, 0x4FE, 0x500, 0x502, 0x504, 0x506, 0x508, 0x50A, 0x50C, 0x50E, 0x510, 0x512, 0x514, 0x516, 0x518, 0x51A, 0x51C, 0x51E, 0x520, 0x522, 0x524, 0x526, 0x528, 0x52A, 0x52C, 0x52E, 0x587, 0x10C7, 0x10CD, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1E9E, 0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F59, 0x1F5B, 0x1F5D, 0x1F5F, 0x2126, 0x2132, 0x2183, 0x2C60, 0x2C67, 0x2C69, 0x2C6B, 0x2C72, 0x2C75, 0x2C82, 0x2C84, 0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98, 0x2C9A, 0x2C9C, 0x2C9E, 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC, 0x2CAE, 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, 0x2CC0, 0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, 0x2CD0, 0x2CD2, 0x2CD4, 0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2, 0xA640, 0xA642, 0xA644, 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652, 0xA654, 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, 0xA666, 0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, 0xA688, 0xA68A, 0xA68C, 0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726, 0xA728, 0xA72A, 0xA72C, 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C, 0xA73E, 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, 0xA750, 0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, 0xA760, 0xA762, 0xA764, 0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA779, 0xA77B, 0xA780, 0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A, 0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7B6, 0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C9, 0xA7D0, 0xA7D6, 0xA7D8, 0xA7DA, 0xA7DC, 0xA7F5);
    set.addRange(0x41, 0x5A).addRange(0xC0, 0xD6).addRange(0xD8, 0xDF).addRange(0x149, 0x14A).addRange(0x178, 0x179).addRange(0x181, 0x182).addRange(0x186, 0x187).addRange(0x189, 0x18B).addRange(0x18E, 0x191).addRange(0x193, 0x194).addRange(0x196, 0x198).addRange(0x19C, 0x19D).addRange(0x19F, 0x1A0).addRange(0x1A6, 0x1A7).addRange(0x1AE, 0x1AF).addRange(0x1B1, 0x1B3).addRange(0x1B7, 0x1B8).addRange(0x1C4, 0x1C5).addRange(0x1C7, 0x1C8).addRange(0x1CA, 0x1CB).addRange(0x1F1, 0x1F2).addRange(0x1F6, 0x1F8).addRange(0x23A, 0x23B).addRange(0x23D, 0x23E).addRange(0x243, 0x246).addRange(0x388, 0x38A).addRange(0x38E, 0x38F).addRange(0x391, 0x3A1).addRange(0x3A3, 0x3AB).addRange(0x3CF, 0x3D1).addRange(0x3D5, 0x3D6).addRange(0x3F0, 0x3F1).addRange(0x3F4, 0x3F5).addRange(0x3F9, 0x3FA).addRange(0x3FD, 0x42F).addRange(0x4C0, 0x4C1).addRange(0x531, 0x556).addRange(0x10A0, 0x10C5).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C89).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1E9A, 0x1E9B).addRange(0x1F08, 0x1F0F).addRange(0x1F18, 0x1F1D).addRange(0x1F28, 0x1F2F).addRange(0x1F38, 0x1F3F).addRange(0x1F48, 0x1F4D).addRange(0x1F68, 0x1F6F).addRange(0x1F80, 0x1FAF).addRange(0x1FB2, 0x1FB4);
    set.addRange(0x1FB7, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC7, 0x1FCC).addRange(0x1FD8, 0x1FDB).addRange(0x1FE8, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF7, 0x1FFC).addRange(0x212A, 0x212B).addRange(0x2160, 0x216F).addRange(0x24B6, 0x24CF).addRange(0x2C00, 0x2C2F).addRange(0x2C62, 0x2C64).addRange(0x2C6D, 0x2C70).addRange(0x2C7E, 0x2C80).addRange(0xA77D, 0xA77E).addRange(0xA7AA, 0xA7AE).addRange(0xA7B0, 0xA7B4).addRange(0xA7C4, 0xA7C7).addRange(0xA7CB, 0xA7CC).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF21, 0xFF3A).addRange(0x10400, 0x10427).addRange(0x104B0, 0x104D3).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10C80, 0x10CB2).addRange(0x10D50, 0x10D65).addRange(0x118A0, 0x118BF).addRange(0x16E40, 0x16E5F).addRange(0x1E900, 0x1E921);
    Changes_When_Casefolded.characters = set;
    return Changes_When_Casefolded;
  }

var Changes_When_Casemapped = {};

var hasRequiredChanges_When_Casemapped;
  function requireChanges_When_Casemapped() {
    if (hasRequiredChanges_When_Casemapped) return Changes_When_Casemapped;
    hasRequiredChanges_When_Casemapped = 1;
    var set = regenerateExports(0xB5, 0x1BF, 0x259, 0x26F, 0x275, 0x27D, 0x280, 0x292, 0x345, 0x37F, 0x386, 0x38C, 0x10C7, 0x10CD, 0x1D79, 0x1D7D, 0x1D8E, 0x1E9E, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2126, 0x2132, 0x214E, 0x2D27, 0x2D2D, 0xAB53);
    set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x137).addRange(0x139, 0x18C).addRange(0x18E, 0x1A9).addRange(0x1AC, 0x1B9).addRange(0x1BC, 0x1BD).addRange(0x1C4, 0x220).addRange(0x222, 0x233).addRange(0x23A, 0x254).addRange(0x256, 0x257).addRange(0x25B, 0x25C).addRange(0x260, 0x261).addRange(0x263, 0x266).addRange(0x268, 0x26C).addRange(0x271, 0x272).addRange(0x282, 0x283).addRange(0x287, 0x28C).addRange(0x29D, 0x29E).addRange(0x370, 0x373).addRange(0x376, 0x377).addRange(0x37B, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3D1).addRange(0x3D5, 0x3F5).addRange(0x3F7, 0x3FB).addRange(0x3FD, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x561, 0x587).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FD, 0x10FF).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1E00, 0x1E9B).addRange(0x1EA0, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4);
    set.addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x212A, 0x212B).addRange(0x2160, 0x217F).addRange(0x2183, 0x2184).addRange(0x24B6, 0x24E9).addRange(0x2C00, 0x2C70).addRange(0x2C72, 0x2C73).addRange(0x2C75, 0x2C76).addRange(0x2C7E, 0x2CE3).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0xA640, 0xA66D).addRange(0xA680, 0xA69B).addRange(0xA722, 0xA72F).addRange(0xA732, 0xA76F).addRange(0xA779, 0xA787).addRange(0xA78B, 0xA78D).addRange(0xA790, 0xA794).addRange(0xA796, 0xA7AE).addRange(0xA7B0, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D6, 0xA7DC).addRange(0xA7F5, 0xA7F6).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0x10400, 0x1044F).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D50, 0x10D65).addRange(0x10D70, 0x10D85).addRange(0x118A0, 0x118DF).addRange(0x16E40, 0x16E7F);
    set.addRange(0x1E900, 0x1E943);
    Changes_When_Casemapped.characters = set;
    return Changes_When_Casemapped;
  }

var Changes_When_Lowercased = {};

var hasRequiredChanges_When_Lowercased;
  function requireChanges_When_Lowercased() {
    if (hasRequiredChanges_When_Lowercased) return Changes_When_Lowercased;
    hasRequiredChanges_When_Lowercased = 1;
    var set = regenerateExports(0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14A, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x17B, 0x17D, 0x184, 0x1A2, 0x1A4, 0x1A9, 0x1AC, 0x1B5, 0x1BC, 0x1CD, 0x1CF, 0x1D1, 0x1D3, 0x1D5, 0x1D7, 0x1D9, 0x1DB, 0x1DE, 0x1E0, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x1EA, 0x1EC, 0x1EE, 0x1F4, 0x1FA, 0x1FC, 0x1FE, 0x200, 0x202, 0x204, 0x206, 0x208, 0x20A, 0x20C, 0x20E, 0x210, 0x212, 0x214, 0x216, 0x218, 0x21A, 0x21C, 0x21E, 0x220, 0x222, 0x224, 0x226, 0x228, 0x22A, 0x22C, 0x22E, 0x230, 0x232, 0x241, 0x248, 0x24A, 0x24C, 0x24E, 0x370, 0x372, 0x376, 0x37F, 0x386, 0x38C, 0x3CF, 0x3D8, 0x3DA, 0x3DC, 0x3DE, 0x3E0, 0x3E2, 0x3E4, 0x3E6, 0x3E8, 0x3EA, 0x3EC, 0x3EE, 0x3F4, 0x3F7, 0x460, 0x462, 0x464, 0x466, 0x468, 0x46A, 0x46C, 0x46E, 0x470, 0x472, 0x474, 0x476, 0x478, 0x47A, 0x47C, 0x47E, 0x480, 0x48A, 0x48C, 0x48E, 0x490, 0x492, 0x494, 0x496, 0x498, 0x49A, 0x49C, 0x49E, 0x4A0, 0x4A2, 0x4A4, 0x4A6, 0x4A8, 0x4AA, 0x4AC, 0x4AE, 0x4B0, 0x4B2, 0x4B4, 0x4B6, 0x4B8, 0x4BA, 0x4BC, 0x4BE, 0x4C3, 0x4C5, 0x4C7, 0x4C9, 0x4CB, 0x4CD, 0x4D0, 0x4D2, 0x4D4, 0x4D6, 0x4D8, 0x4DA, 0x4DC, 0x4DE, 0x4E0, 0x4E2, 0x4E4, 0x4E6, 0x4E8, 0x4EA, 0x4EC, 0x4EE, 0x4F0, 0x4F2, 0x4F4, 0x4F6, 0x4F8, 0x4FA, 0x4FC, 0x4FE, 0x500, 0x502, 0x504, 0x506, 0x508, 0x50A, 0x50C, 0x50E, 0x510, 0x512, 0x514, 0x516, 0x518, 0x51A, 0x51C, 0x51E, 0x520, 0x522, 0x524, 0x526, 0x528, 0x52A, 0x52C, 0x52E, 0x10C7, 0x10CD, 0x1C89, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1E9E, 0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F59, 0x1F5B, 0x1F5D, 0x1F5F, 0x2126, 0x2132, 0x2183, 0x2C60, 0x2C67, 0x2C69, 0x2C6B, 0x2C72, 0x2C75, 0x2C82, 0x2C84, 0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98, 0x2C9A, 0x2C9C, 0x2C9E, 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC, 0x2CAE, 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, 0x2CC0, 0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, 0x2CD0, 0x2CD2, 0x2CD4, 0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2, 0xA640, 0xA642, 0xA644, 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652, 0xA654, 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, 0xA666, 0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, 0xA688, 0xA68A, 0xA68C, 0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726, 0xA728, 0xA72A, 0xA72C, 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C, 0xA73E, 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, 0xA750, 0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, 0xA760, 0xA762, 0xA764, 0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA779, 0xA77B, 0xA780, 0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A, 0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7B6, 0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C9, 0xA7D0, 0xA7D6, 0xA7D8, 0xA7DA, 0xA7DC, 0xA7F5);
    set.addRange(0x41, 0x5A).addRange(0xC0, 0xD6).addRange(0xD8, 0xDE).addRange(0x178, 0x179).addRange(0x181, 0x182).addRange(0x186, 0x187).addRange(0x189, 0x18B).addRange(0x18E, 0x191).addRange(0x193, 0x194).addRange(0x196, 0x198).addRange(0x19C, 0x19D).addRange(0x19F, 0x1A0).addRange(0x1A6, 0x1A7).addRange(0x1AE, 0x1AF).addRange(0x1B1, 0x1B3).addRange(0x1B7, 0x1B8).addRange(0x1C4, 0x1C5).addRange(0x1C7, 0x1C8).addRange(0x1CA, 0x1CB).addRange(0x1F1, 0x1F2).addRange(0x1F6, 0x1F8).addRange(0x23A, 0x23B).addRange(0x23D, 0x23E).addRange(0x243, 0x246).addRange(0x388, 0x38A).addRange(0x38E, 0x38F).addRange(0x391, 0x3A1).addRange(0x3A3, 0x3AB).addRange(0x3F9, 0x3FA).addRange(0x3FD, 0x42F).addRange(0x4C0, 0x4C1).addRange(0x531, 0x556).addRange(0x10A0, 0x10C5).addRange(0x13A0, 0x13F5).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1F08, 0x1F0F).addRange(0x1F18, 0x1F1D).addRange(0x1F28, 0x1F2F).addRange(0x1F38, 0x1F3F).addRange(0x1F48, 0x1F4D).addRange(0x1F68, 0x1F6F).addRange(0x1F88, 0x1F8F).addRange(0x1F98, 0x1F9F).addRange(0x1FA8, 0x1FAF).addRange(0x1FB8, 0x1FBC).addRange(0x1FC8, 0x1FCC).addRange(0x1FD8, 0x1FDB).addRange(0x1FE8, 0x1FEC).addRange(0x1FF8, 0x1FFC).addRange(0x212A, 0x212B);
    set.addRange(0x2160, 0x216F).addRange(0x24B6, 0x24CF).addRange(0x2C00, 0x2C2F).addRange(0x2C62, 0x2C64).addRange(0x2C6D, 0x2C70).addRange(0x2C7E, 0x2C80).addRange(0xA77D, 0xA77E).addRange(0xA7AA, 0xA7AE).addRange(0xA7B0, 0xA7B4).addRange(0xA7C4, 0xA7C7).addRange(0xA7CB, 0xA7CC).addRange(0xFF21, 0xFF3A).addRange(0x10400, 0x10427).addRange(0x104B0, 0x104D3).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10C80, 0x10CB2).addRange(0x10D50, 0x10D65).addRange(0x118A0, 0x118BF).addRange(0x16E40, 0x16E5F).addRange(0x1E900, 0x1E921);
    Changes_When_Lowercased.characters = set;
    return Changes_When_Lowercased;
  }

var Changes_When_NFKC_Casefolded = {};

var hasRequiredChanges_When_NFKC_Casefolded;
  function requireChanges_When_NFKC_Casefolded() {
    if (hasRequiredChanges_When_NFKC_Casefolded) return Changes_When_NFKC_Casefolded;
    hasRequiredChanges_When_NFKC_Casefolded = 1;
    var set = regenerateExports(0xA0, 0xA8, 0xAA, 0xAD, 0xAF, 0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x136, 0x139, 0x13B, 0x13D, 0x143, 0x145, 0x147, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x17B, 0x17D, 0x17F, 0x184, 0x1A2, 0x1A4, 0x1A9, 0x1AC, 0x1B5, 0x1BC, 0x1CF, 0x1D1, 0x1D3, 0x1D5, 0x1D7, 0x1D9, 0x1DB, 0x1DE, 0x1E0, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x1EA, 0x1EC, 0x1EE, 0x1FA, 0x1FC, 0x1FE, 0x200, 0x202, 0x204, 0x206, 0x208, 0x20A, 0x20C, 0x20E, 0x210, 0x212, 0x214, 0x216, 0x218, 0x21A, 0x21C, 0x21E, 0x220, 0x222, 0x224, 0x226, 0x228, 0x22A, 0x22C, 0x22E, 0x230, 0x232, 0x241, 0x248, 0x24A, 0x24C, 0x24E, 0x34F, 0x370, 0x372, 0x374, 0x376, 0x37A, 0x38C, 0x3C2, 0x3D8, 0x3DA, 0x3DC, 0x3DE, 0x3E0, 0x3E2, 0x3E4, 0x3E6, 0x3E8, 0x3EA, 0x3EC, 0x3EE, 0x3F7, 0x460, 0x462, 0x464, 0x466, 0x468, 0x46A, 0x46C, 0x46E, 0x470, 0x472, 0x474, 0x476, 0x478, 0x47A, 0x47C, 0x47E, 0x480, 0x48A, 0x48C, 0x48E, 0x490, 0x492, 0x494, 0x496, 0x498, 0x49A, 0x49C, 0x49E, 0x4A0, 0x4A2, 0x4A4, 0x4A6, 0x4A8, 0x4AA, 0x4AC, 0x4AE, 0x4B0, 0x4B2, 0x4B4, 0x4B6, 0x4B8, 0x4BA, 0x4BC, 0x4BE, 0x4C3, 0x4C5, 0x4C7, 0x4C9, 0x4CB, 0x4CD, 0x4D0, 0x4D2, 0x4D4, 0x4D6, 0x4D8, 0x4DA, 0x4DC, 0x4DE, 0x4E0, 0x4E2, 0x4E4, 0x4E6, 0x4E8, 0x4EA, 0x4EC, 0x4EE, 0x4F0, 0x4F2, 0x4F4, 0x4F6, 0x4F8, 0x4FA, 0x4FC, 0x4FE, 0x500, 0x502, 0x504, 0x506, 0x508, 0x50A, 0x50C, 0x50E, 0x510, 0x512, 0x514, 0x516, 0x518, 0x51A, 0x51C, 0x51E, 0x520, 0x522, 0x524, 0x526, 0x528, 0x52A, 0x52C, 0x52E, 0x587, 0x61C, 0x9DF, 0xA33, 0xA36, 0xA5E, 0xE33, 0xEB3, 0xF0C, 0xF43, 0xF4D, 0xF52, 0xF57, 0xF5C, 0xF69, 0xF73, 0xF81, 0xF93, 0xF9D, 0xFA2, 0xFA7, 0xFAC, 0xFB9, 0x10C7, 0x10CD, 0x10FC, 0x1D78, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1E9E, 0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F59, 0x1F5B, 0x1F5D, 0x1F5F, 0x1F71, 0x1F73, 0x1F75, 0x1F77, 0x1F79, 0x1F7B, 0x1F7D, 0x1FD3, 0x1FE3, 0x2011, 0x2017, 0x203C, 0x203E, 0x2057, 0x20A8, 0x2124, 0x2126, 0x2128, 0x2183, 0x2189, 0x2A0C, 0x2ADC, 0x2C60, 0x2C67, 0x2C69, 0x2C6B, 0x2C72, 0x2C75, 0x2C82, 0x2C84, 0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98, 0x2C9A, 0x2C9C, 0x2C9E, 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC, 0x2CAE, 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, 0x2CC0, 0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, 0x2CD0, 0x2CD2, 0x2CD4, 0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2, 0x2D6F, 0x2E9F, 0x2EF3, 0x3000, 0x3036, 0x309F, 0x30FF, 0xA640, 0xA642, 0xA644, 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652, 0xA654, 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, 0xA666, 0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, 0xA688, 0xA68A, 0xA68C, 0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726, 0xA728, 0xA72A, 0xA72C, 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C, 0xA73E, 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, 0xA750, 0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, 0xA760, 0xA762, 0xA764, 0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA770, 0xA779, 0xA77B, 0xA780, 0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A, 0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7B6, 0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C9, 0xA7D0, 0xA7D6, 0xA7D8, 0xA7DA, 0xA7DC, 0xAB69, 0xFA10, 0xFA12, 0xFA20, 0xFA22, 0xFB1D, 0xFB3E, 0xFE74, 0xFEFF, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E, 0x1F190);
    set.addRange(0x41, 0x5A).addRange(0xB2, 0xB5).addRange(0xB8, 0xBA).addRange(0xBC, 0xBE).addRange(0xC0, 0xD6).addRange(0xD8, 0xDF).addRange(0x132, 0x134).addRange(0x13F, 0x141).addRange(0x149, 0x14A).addRange(0x178, 0x179).addRange(0x181, 0x182).addRange(0x186, 0x187).addRange(0x189, 0x18B).addRange(0x18E, 0x191).addRange(0x193, 0x194).addRange(0x196, 0x198).addRange(0x19C, 0x19D).addRange(0x19F, 0x1A0).addRange(0x1A6, 0x1A7).addRange(0x1AE, 0x1AF).addRange(0x1B1, 0x1B3).addRange(0x1B7, 0x1B8).addRange(0x1C4, 0x1CD).addRange(0x1F1, 0x1F4).addRange(0x1F6, 0x1F8).addRange(0x23A, 0x23B).addRange(0x23D, 0x23E).addRange(0x243, 0x246).addRange(0x2B0, 0x2B8).addRange(0x2D8, 0x2DD).addRange(0x2E0, 0x2E4).addRange(0x340, 0x341).addRange(0x343, 0x345).addRange(0x37E, 0x37F).addRange(0x384, 0x38A).addRange(0x38E, 0x38F).addRange(0x391, 0x3A1).addRange(0x3A3, 0x3AB).addRange(0x3CF, 0x3D6).addRange(0x3F0, 0x3F2).addRange(0x3F4, 0x3F5).addRange(0x3F9, 0x3FA).addRange(0x3FD, 0x42F).addRange(0x4C0, 0x4C1).addRange(0x531, 0x556).addRange(0x675, 0x678).addRange(0x958, 0x95F).addRange(0x9DC, 0x9DD).addRange(0xA59, 0xA5B).addRange(0xB5C, 0xB5D).addRange(0xEDC, 0xEDD);
    set.addRange(0xF75, 0xF79).addRange(0x10A0, 0x10C5).addRange(0x115F, 0x1160).addRange(0x13F8, 0x13FD).addRange(0x17B4, 0x17B5).addRange(0x180B, 0x180F).addRange(0x1C80, 0x1C89).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1D2C, 0x1D2E).addRange(0x1D30, 0x1D3A).addRange(0x1D3C, 0x1D4D).addRange(0x1D4F, 0x1D6A).addRange(0x1D9B, 0x1DBF).addRange(0x1E9A, 0x1E9B).addRange(0x1F08, 0x1F0F).addRange(0x1F18, 0x1F1D).addRange(0x1F28, 0x1F2F).addRange(0x1F38, 0x1F3F).addRange(0x1F48, 0x1F4D).addRange(0x1F68, 0x1F6F).addRange(0x1F80, 0x1FAF).addRange(0x1FB2, 0x1FB4).addRange(0x1FB7, 0x1FC4).addRange(0x1FC7, 0x1FCF).addRange(0x1FD8, 0x1FDB).addRange(0x1FDD, 0x1FDF).addRange(0x1FE8, 0x1FEF).addRange(0x1FF2, 0x1FF4).addRange(0x1FF7, 0x1FFE).addRange(0x2000, 0x200F).addRange(0x2024, 0x2026).addRange(0x202A, 0x202F).addRange(0x2033, 0x2034).addRange(0x2036, 0x2037).addRange(0x2047, 0x2049).addRange(0x205F, 0x2071).addRange(0x2074, 0x208E).addRange(0x2090, 0x209C).addRange(0x2100, 0x2103).addRange(0x2105, 0x2107).addRange(0x2109, 0x2113).addRange(0x2115, 0x2116).addRange(0x2119, 0x211D).addRange(0x2120, 0x2122).addRange(0x212A, 0x212D).addRange(0x212F, 0x2139).addRange(0x213B, 0x2140).addRange(0x2145, 0x2149).addRange(0x2150, 0x217F).addRange(0x222C, 0x222D);
    set.addRange(0x222F, 0x2230).addRange(0x2329, 0x232A).addRange(0x2460, 0x24EA).addRange(0x2A74, 0x2A76).addRange(0x2C00, 0x2C2F).addRange(0x2C62, 0x2C64).addRange(0x2C6D, 0x2C70).addRange(0x2C7C, 0x2C80).addRange(0x2F00, 0x2FD5).addRange(0x3038, 0x303A).addRange(0x309B, 0x309C).addRange(0x3131, 0x318E).addRange(0x3192, 0x319F).addRange(0x3200, 0x321E).addRange(0x3220, 0x3247).addRange(0x3250, 0x327E).addRange(0x3280, 0x33FF).addRange(0xA69C, 0xA69D).addRange(0xA77D, 0xA77E).addRange(0xA7AA, 0xA7AE).addRange(0xA7B0, 0xA7B4).addRange(0xA7C4, 0xA7C7).addRange(0xA7CB, 0xA7CC).addRange(0xA7F2, 0xA7F5).addRange(0xA7F8, 0xA7F9).addRange(0xAB5C, 0xAB5F).addRange(0xAB70, 0xABBF).addRange(0xF900, 0xFA0D).addRange(0xFA15, 0xFA1E).addRange(0xFA25, 0xFA26).addRange(0xFA2A, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1F, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFC).addRange(0xFE00, 0xFE19).addRange(0xFE30, 0xFE44).addRange(0xFE47, 0xFE52).addRange(0xFE54, 0xFE66).addRange(0xFE68, 0xFE6B).addRange(0xFE70, 0xFE72).addRange(0xFE76, 0xFEFC).addRange(0xFF01, 0xFFBE);
    set.addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFF0, 0xFFF8).addRange(0x10400, 0x10427).addRange(0x104B0, 0x104D3).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10781, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10C80, 0x10CB2).addRange(0x10D50, 0x10D65).addRange(0x118A0, 0x118BF).addRange(0x16E40, 0x16E5F).addRange(0x1BCA0, 0x1BCA3).addRange(0x1CCD6, 0x1CCF9).addRange(0x1D15E, 0x1D164).addRange(0x1D173, 0x1D17A).addRange(0x1D1BB, 0x1D1C0).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D7CB).addRange(0x1D7CE, 0x1D7FF).addRange(0x1E030, 0x1E06D).addRange(0x1E900, 0x1E921).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F);
    set.addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1F100, 0x1F10A).addRange(0x1F110, 0x1F12E).addRange(0x1F130, 0x1F14F).addRange(0x1F16A, 0x1F16C).addRange(0x1F200, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F250, 0x1F251).addRange(0x1FBF0, 0x1FBF9).addRange(0x2F800, 0x2FA1D).addRange(0xE0000, 0xE0FFF);
    Changes_When_NFKC_Casefolded.characters = set;
    return Changes_When_NFKC_Casefolded;
  }

var Changes_When_Titlecased = {};

var hasRequiredChanges_When_Titlecased;
  function requireChanges_When_Titlecased() {
    if (hasRequiredChanges_When_Titlecased) return Changes_When_Titlecased;
    hasRequiredChanges_When_Titlecased = 1;
    var set = regenerateExports(0xB5, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x137, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x183, 0x185, 0x188, 0x18C, 0x192, 0x195, 0x19E, 0x1A1, 0x1A3, 0x1A5, 0x1A8, 0x1AD, 0x1B0, 0x1B4, 0x1B6, 0x1B9, 0x1BD, 0x1BF, 0x1C4, 0x1CC, 0x1CE, 0x1D0, 0x1D2, 0x1D4, 0x1D6, 0x1D8, 0x1DA, 0x1DF, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x1E9, 0x1EB, 0x1ED, 0x1F3, 0x1F5, 0x1F9, 0x1FB, 0x1FD, 0x1FF, 0x201, 0x203, 0x205, 0x207, 0x209, 0x20B, 0x20D, 0x20F, 0x211, 0x213, 0x215, 0x217, 0x219, 0x21B, 0x21D, 0x21F, 0x223, 0x225, 0x227, 0x229, 0x22B, 0x22D, 0x22F, 0x231, 0x233, 0x23C, 0x242, 0x247, 0x249, 0x24B, 0x24D, 0x259, 0x26F, 0x275, 0x27D, 0x280, 0x292, 0x345, 0x371, 0x373, 0x377, 0x390, 0x3D9, 0x3DB, 0x3DD, 0x3DF, 0x3E1, 0x3E3, 0x3E5, 0x3E7, 0x3E9, 0x3EB, 0x3ED, 0x3F5, 0x3F8, 0x3FB, 0x461, 0x463, 0x465, 0x467, 0x469, 0x46B, 0x46D, 0x46F, 0x471, 0x473, 0x475, 0x477, 0x479, 0x47B, 0x47D, 0x47F, 0x481, 0x48B, 0x48D, 0x48F, 0x491, 0x493, 0x495, 0x497, 0x499, 0x49B, 0x49D, 0x49F, 0x4A1, 0x4A3, 0x4A5, 0x4A7, 0x4A9, 0x4AB, 0x4AD, 0x4AF, 0x4B1, 0x4B3, 0x4B5, 0x4B7, 0x4B9, 0x4BB, 0x4BD, 0x4BF, 0x4C2, 0x4C4, 0x4C6, 0x4C8, 0x4CA, 0x4CC, 0x4D1, 0x4D3, 0x4D5, 0x4D7, 0x4D9, 0x4DB, 0x4DD, 0x4DF, 0x4E1, 0x4E3, 0x4E5, 0x4E7, 0x4E9, 0x4EB, 0x4ED, 0x4EF, 0x4F1, 0x4F3, 0x4F5, 0x4F7, 0x4F9, 0x4FB, 0x4FD, 0x4FF, 0x501, 0x503, 0x505, 0x507, 0x509, 0x50B, 0x50D, 0x50F, 0x511, 0x513, 0x515, 0x517, 0x519, 0x51B, 0x51D, 0x51F, 0x521, 0x523, 0x525, 0x527, 0x529, 0x52B, 0x52D, 0x52F, 0x1C8A, 0x1D79, 0x1D7D, 0x1D8E, 0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9, 0x1EFB, 0x1EFD, 0x1FBE, 0x214E, 0x2184, 0x2C61, 0x2C68, 0x2C6A, 0x2C6C, 0x2C73, 0x2C76, 0x2C81, 0x2C83, 0x2C85, 0x2C87, 0x2C89, 0x2C8B, 0x2C8D, 0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1, 0x2CA3, 0x2CA5, 0x2CA7, 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5, 0x2CB7, 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, 0x2CC9, 0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, 0x2CD9, 0x2CDB, 0x2CDD, 0x2CDF, 0x2CE1, 0x2CE3, 0x2CEC, 0x2CEE, 0x2CF3, 0x2D27, 0x2D2D, 0xA641, 0xA643, 0xA645, 0xA647, 0xA649, 0xA64B, 0xA64D, 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B, 0xA65D, 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA66D, 0xA681, 0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, 0xA691, 0xA693, 0xA695, 0xA697, 0xA699, 0xA69B, 0xA723, 0xA725, 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA72F, 0xA733, 0xA735, 0xA737, 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745, 0xA747, 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, 0xA759, 0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D, 0xA76F, 0xA77A, 0xA77C, 0xA77F, 0xA781, 0xA783, 0xA785, 0xA787, 0xA78C, 0xA791, 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, 0xA7A7, 0xA7A9, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3, 0xA7C8, 0xA7CA, 0xA7CD, 0xA7D1, 0xA7D7, 0xA7D9, 0xA7DB, 0xA7F6, 0xAB53);
    set.addRange(0x61, 0x7A).addRange(0xDF, 0xF6).addRange(0xF8, 0xFF).addRange(0x148, 0x149).addRange(0x17E, 0x180).addRange(0x199, 0x19B).addRange(0x1C6, 0x1C7).addRange(0x1C9, 0x1CA).addRange(0x1DC, 0x1DD).addRange(0x1EF, 0x1F1).addRange(0x23F, 0x240).addRange(0x24F, 0x254).addRange(0x256, 0x257).addRange(0x25B, 0x25C).addRange(0x260, 0x261).addRange(0x263, 0x266).addRange(0x268, 0x26C).addRange(0x271, 0x272).addRange(0x282, 0x283).addRange(0x287, 0x28C).addRange(0x29D, 0x29E).addRange(0x37B, 0x37D).addRange(0x3AC, 0x3CE).addRange(0x3D0, 0x3D1).addRange(0x3D5, 0x3D7).addRange(0x3EF, 0x3F3).addRange(0x430, 0x45F).addRange(0x4CE, 0x4CF).addRange(0x561, 0x587).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C88).addRange(0x1E95, 0x1E9B).addRange(0x1EFF, 0x1F07).addRange(0x1F10, 0x1F15).addRange(0x1F20, 0x1F27).addRange(0x1F30, 0x1F37).addRange(0x1F40, 0x1F45).addRange(0x1F50, 0x1F57).addRange(0x1F60, 0x1F67).addRange(0x1F70, 0x1F7D).addRange(0x1F80, 0x1F87).addRange(0x1F90, 0x1F97).addRange(0x1FA0, 0x1FA7).addRange(0x1FB0, 0x1FB4).addRange(0x1FB6, 0x1FB7).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FC7).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FD7).addRange(0x1FE0, 0x1FE7).addRange(0x1FF2, 0x1FF4);
    set.addRange(0x1FF6, 0x1FF7).addRange(0x2170, 0x217F).addRange(0x24D0, 0x24E9).addRange(0x2C30, 0x2C5F).addRange(0x2C65, 0x2C66).addRange(0x2D00, 0x2D25).addRange(0xA793, 0xA794).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF41, 0xFF5A).addRange(0x10428, 0x1044F).addRange(0x104D8, 0x104FB).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10CC0, 0x10CF2).addRange(0x10D70, 0x10D85).addRange(0x118C0, 0x118DF).addRange(0x16E60, 0x16E7F).addRange(0x1E922, 0x1E943);
    Changes_When_Titlecased.characters = set;
    return Changes_When_Titlecased;
  }

var Changes_When_Uppercased = {};

var hasRequiredChanges_When_Uppercased;
  function requireChanges_When_Uppercased() {
    if (hasRequiredChanges_When_Uppercased) return Changes_When_Uppercased;
    hasRequiredChanges_When_Uppercased = 1;
    var set = regenerateExports(0xB5, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x137, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x183, 0x185, 0x188, 0x18C, 0x192, 0x195, 0x19E, 0x1A1, 0x1A3, 0x1A5, 0x1A8, 0x1AD, 0x1B0, 0x1B4, 0x1B6, 0x1B9, 0x1BD, 0x1BF, 0x1CE, 0x1D0, 0x1D2, 0x1D4, 0x1D6, 0x1D8, 0x1DA, 0x1DF, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x1E9, 0x1EB, 0x1ED, 0x1F5, 0x1F9, 0x1FB, 0x1FD, 0x1FF, 0x201, 0x203, 0x205, 0x207, 0x209, 0x20B, 0x20D, 0x20F, 0x211, 0x213, 0x215, 0x217, 0x219, 0x21B, 0x21D, 0x21F, 0x223, 0x225, 0x227, 0x229, 0x22B, 0x22D, 0x22F, 0x231, 0x233, 0x23C, 0x242, 0x247, 0x249, 0x24B, 0x24D, 0x259, 0x26F, 0x275, 0x27D, 0x280, 0x292, 0x345, 0x371, 0x373, 0x377, 0x390, 0x3D9, 0x3DB, 0x3DD, 0x3DF, 0x3E1, 0x3E3, 0x3E5, 0x3E7, 0x3E9, 0x3EB, 0x3ED, 0x3F5, 0x3F8, 0x3FB, 0x461, 0x463, 0x465, 0x467, 0x469, 0x46B, 0x46D, 0x46F, 0x471, 0x473, 0x475, 0x477, 0x479, 0x47B, 0x47D, 0x47F, 0x481, 0x48B, 0x48D, 0x48F, 0x491, 0x493, 0x495, 0x497, 0x499, 0x49B, 0x49D, 0x49F, 0x4A1, 0x4A3, 0x4A5, 0x4A7, 0x4A9, 0x4AB, 0x4AD, 0x4AF, 0x4B1, 0x4B3, 0x4B5, 0x4B7, 0x4B9, 0x4BB, 0x4BD, 0x4BF, 0x4C2, 0x4C4, 0x4C6, 0x4C8, 0x4CA, 0x4CC, 0x4D1, 0x4D3, 0x4D5, 0x4D7, 0x4D9, 0x4DB, 0x4DD, 0x4DF, 0x4E1, 0x4E3, 0x4E5, 0x4E7, 0x4E9, 0x4EB, 0x4ED, 0x4EF, 0x4F1, 0x4F3, 0x4F5, 0x4F7, 0x4F9, 0x4FB, 0x4FD, 0x4FF, 0x501, 0x503, 0x505, 0x507, 0x509, 0x50B, 0x50D, 0x50F, 0x511, 0x513, 0x515, 0x517, 0x519, 0x51B, 0x51D, 0x51F, 0x521, 0x523, 0x525, 0x527, 0x529, 0x52B, 0x52D, 0x52F, 0x1C8A, 0x1D79, 0x1D7D, 0x1D8E, 0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9, 0x1EFB, 0x1EFD, 0x1FBC, 0x1FBE, 0x1FCC, 0x1FFC, 0x214E, 0x2184, 0x2C61, 0x2C68, 0x2C6A, 0x2C6C, 0x2C73, 0x2C76, 0x2C81, 0x2C83, 0x2C85, 0x2C87, 0x2C89, 0x2C8B, 0x2C8D, 0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1, 0x2CA3, 0x2CA5, 0x2CA7, 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5, 0x2CB7, 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, 0x2CC9, 0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, 0x2CD9, 0x2CDB, 0x2CDD, 0x2CDF, 0x2CE1, 0x2CE3, 0x2CEC, 0x2CEE, 0x2CF3, 0x2D27, 0x2D2D, 0xA641, 0xA643, 0xA645, 0xA647, 0xA649, 0xA64B, 0xA64D, 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B, 0xA65D, 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA66D, 0xA681, 0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, 0xA691, 0xA693, 0xA695, 0xA697, 0xA699, 0xA69B, 0xA723, 0xA725, 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA72F, 0xA733, 0xA735, 0xA737, 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745, 0xA747, 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, 0xA759, 0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D, 0xA76F, 0xA77A, 0xA77C, 0xA77F, 0xA781, 0xA783, 0xA785, 0xA787, 0xA78C, 0xA791, 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, 0xA7A7, 0xA7A9, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3, 0xA7C8, 0xA7CA, 0xA7CD, 0xA7D1, 0xA7D7, 0xA7D9, 0xA7DB, 0xA7F6, 0xAB53);
    set.addRange(0x61, 0x7A).addRange(0xDF, 0xF6).addRange(0xF8, 0xFF).addRange(0x148, 0x149).addRange(0x17E, 0x180).addRange(0x199, 0x19B).addRange(0x1C5, 0x1C6).addRange(0x1C8, 0x1C9).addRange(0x1CB, 0x1CC).addRange(0x1DC, 0x1DD).addRange(0x1EF, 0x1F0).addRange(0x1F2, 0x1F3).addRange(0x23F, 0x240).addRange(0x24F, 0x254).addRange(0x256, 0x257).addRange(0x25B, 0x25C).addRange(0x260, 0x261).addRange(0x263, 0x266).addRange(0x268, 0x26C).addRange(0x271, 0x272).addRange(0x282, 0x283).addRange(0x287, 0x28C).addRange(0x29D, 0x29E).addRange(0x37B, 0x37D).addRange(0x3AC, 0x3CE).addRange(0x3D0, 0x3D1).addRange(0x3D5, 0x3D7).addRange(0x3EF, 0x3F3).addRange(0x430, 0x45F).addRange(0x4CE, 0x4CF).addRange(0x561, 0x587).addRange(0x10D0, 0x10FA).addRange(0x10FD, 0x10FF).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C88).addRange(0x1E95, 0x1E9B).addRange(0x1EFF, 0x1F07).addRange(0x1F10, 0x1F15).addRange(0x1F20, 0x1F27).addRange(0x1F30, 0x1F37).addRange(0x1F40, 0x1F45).addRange(0x1F50, 0x1F57).addRange(0x1F60, 0x1F67).addRange(0x1F70, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FB7).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FC7).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FD7).addRange(0x1FE0, 0x1FE7);
    set.addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FF7).addRange(0x2170, 0x217F).addRange(0x24D0, 0x24E9).addRange(0x2C30, 0x2C5F).addRange(0x2C65, 0x2C66).addRange(0x2D00, 0x2D25).addRange(0xA793, 0xA794).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF41, 0xFF5A).addRange(0x10428, 0x1044F).addRange(0x104D8, 0x104FB).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10CC0, 0x10CF2).addRange(0x10D70, 0x10D85).addRange(0x118C0, 0x118DF).addRange(0x16E60, 0x16E7F).addRange(0x1E922, 0x1E943);
    Changes_When_Uppercased.characters = set;
    return Changes_When_Uppercased;
  }

var Dash = {};

var hasRequiredDash;
  function requireDash() {
    if (hasRequiredDash) return Dash;
    hasRequiredDash = 1;
    var set = regenerateExports(0x2D, 0x58A, 0x5BE, 0x1400, 0x1806, 0x2053, 0x207B, 0x208B, 0x2212, 0x2E17, 0x2E1A, 0x2E40, 0x2E5D, 0x301C, 0x3030, 0x30A0, 0xFE58, 0xFE63, 0xFF0D, 0x10D6E, 0x10EAD);
    set.addRange(0x2010, 0x2015).addRange(0x2E3A, 0x2E3B).addRange(0xFE31, 0xFE32);
    Dash.characters = set;
    return Dash;
  }

var Default_Ignorable_Code_Point = {};

var hasRequiredDefault_Ignorable_Code_Point;
  function requireDefault_Ignorable_Code_Point() {
    if (hasRequiredDefault_Ignorable_Code_Point) return Default_Ignorable_Code_Point;
    hasRequiredDefault_Ignorable_Code_Point = 1;
    var set = regenerateExports(0xAD, 0x34F, 0x61C, 0x3164, 0xFEFF, 0xFFA0);
    set.addRange(0x115F, 0x1160).addRange(0x17B4, 0x17B5).addRange(0x180B, 0x180F).addRange(0x200B, 0x200F).addRange(0x202A, 0x202E).addRange(0x2060, 0x206F).addRange(0xFE00, 0xFE0F).addRange(0xFFF0, 0xFFF8).addRange(0x1BCA0, 0x1BCA3).addRange(0x1D173, 0x1D17A).addRange(0xE0000, 0xE0FFF);
    Default_Ignorable_Code_Point.characters = set;
    return Default_Ignorable_Code_Point;
  }

var Deprecated = {};

var hasRequiredDeprecated;
  function requireDeprecated() {
    if (hasRequiredDeprecated) return Deprecated;
    hasRequiredDeprecated = 1;
    var set = regenerateExports(0x149, 0x673, 0xF77, 0xF79, 0xE0001);
    set.addRange(0x17A3, 0x17A4).addRange(0x206A, 0x206F).addRange(0x2329, 0x232A);
    Deprecated.characters = set;
    return Deprecated;
  }

var Diacritic = {};

var hasRequiredDiacritic;
  function requireDiacritic() {
    if (hasRequiredDiacritic) return Diacritic;
    hasRequiredDiacritic = 1;
    var set = regenerateExports(0x5E, 0x60, 0xA8, 0xAF, 0xB4, 0x37A, 0x559, 0x5BF, 0x5C4, 0x93C, 0x94D, 0x971, 0x9BC, 0x9CD, 0xA3C, 0xA4D, 0xABC, 0xACD, 0xB3C, 0xB4D, 0xB55, 0xBCD, 0xC3C, 0xC4D, 0xCBC, 0xCCD, 0xD4D, 0xDCA, 0xE3A, 0xE4E, 0xEBA, 0xF35, 0xF37, 0xF39, 0xFC6, 0x1037, 0x108F, 0x1734, 0x17DD, 0x1A60, 0x1A7F, 0x1B34, 0x1B44, 0x1BE6, 0x1CED, 0x1CF4, 0x1FBD, 0x2E2F, 0x30FC, 0xA66F, 0xA67F, 0xA806, 0xA82C, 0xA8C4, 0xA953, 0xA9B3, 0xA9C0, 0xA9E5, 0xAAF6, 0xFB1E, 0xFF3E, 0xFF40, 0xFF70, 0xFFE3, 0x102E0, 0x10A3F, 0x10D4E, 0x11046, 0x11070, 0x11173, 0x111C0, 0x1134D, 0x11442, 0x11446, 0x1163F, 0x1172B, 0x11943, 0x119E0, 0x11A34, 0x11A47, 0x11A99, 0x11C3F, 0x11D42, 0x11D97, 0x11F5A, 0x1612F, 0x1E2AE);
    set.addRange(0xB7, 0xB8).addRange(0x2B0, 0x34E).addRange(0x350, 0x357).addRange(0x35D, 0x362).addRange(0x374, 0x375).addRange(0x384, 0x385).addRange(0x483, 0x487).addRange(0x591, 0x5A1).addRange(0x5A3, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x64B, 0x652).addRange(0x657, 0x658).addRange(0x6DF, 0x6E0).addRange(0x6E5, 0x6E6).addRange(0x6EA, 0x6EC).addRange(0x730, 0x74A).addRange(0x7A6, 0x7B0).addRange(0x7EB, 0x7F5).addRange(0x818, 0x819).addRange(0x898, 0x89F).addRange(0x8C9, 0x8D2).addRange(0x8E3, 0x8FE).addRange(0x951, 0x954).addRange(0xAFD, 0xAFF).addRange(0xD3B, 0xD3C).addRange(0xE47, 0xE4C).addRange(0xEC8, 0xECC).addRange(0xF18, 0xF19).addRange(0xF3E, 0xF3F).addRange(0xF82, 0xF84).addRange(0xF86, 0xF87).addRange(0x1039, 0x103A).addRange(0x1063, 0x1064).addRange(0x1069, 0x106D).addRange(0x1087, 0x108D).addRange(0x109A, 0x109B).addRange(0x135D, 0x135F).addRange(0x1714, 0x1715).addRange(0x17C9, 0x17D3).addRange(0x1939, 0x193B).addRange(0x1A75, 0x1A7C).addRange(0x1AB0, 0x1ABE).addRange(0x1AC1, 0x1ACB).addRange(0x1B6B, 0x1B73).addRange(0x1BAA, 0x1BAB).addRange(0x1BF2, 0x1BF3).addRange(0x1C36, 0x1C37).addRange(0x1C78, 0x1C7D).addRange(0x1CD0, 0x1CE8).addRange(0x1CF7, 0x1CF9).addRange(0x1D2C, 0x1D6A);
    set.addRange(0x1DC4, 0x1DCF).addRange(0x1DF5, 0x1DFF).addRange(0x1FBF, 0x1FC1).addRange(0x1FCD, 0x1FCF).addRange(0x1FDD, 0x1FDF).addRange(0x1FED, 0x1FEF).addRange(0x1FFD, 0x1FFE).addRange(0x2CEF, 0x2CF1).addRange(0x302A, 0x302F).addRange(0x3099, 0x309C).addRange(0xA67C, 0xA67D).addRange(0xA69C, 0xA69D).addRange(0xA6F0, 0xA6F1).addRange(0xA700, 0xA721).addRange(0xA788, 0xA78A).addRange(0xA7F8, 0xA7F9).addRange(0xA8E0, 0xA8F1).addRange(0xA92B, 0xA92E).addRange(0xAA7B, 0xAA7D).addRange(0xAABF, 0xAAC2).addRange(0xAB5B, 0xAB5F).addRange(0xAB69, 0xAB6B).addRange(0xABEC, 0xABED).addRange(0xFE20, 0xFE2F).addRange(0xFF9E, 0xFF9F).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10A38, 0x10A3A).addRange(0x10AE5, 0x10AE6).addRange(0x10D22, 0x10D27).addRange(0x10D69, 0x10D6D).addRange(0x10EFD, 0x10EFF).addRange(0x10F46, 0x10F50).addRange(0x10F82, 0x10F85).addRange(0x110B9, 0x110BA).addRange(0x11133, 0x11134).addRange(0x111CA, 0x111CC).addRange(0x11235, 0x11236).addRange(0x112E9, 0x112EA).addRange(0x1133B, 0x1133C).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x113CE, 0x113D0).addRange(0x113D2, 0x113D3).addRange(0x113E1, 0x113E2).addRange(0x114C2, 0x114C3).addRange(0x115BF, 0x115C0).addRange(0x116B6, 0x116B7).addRange(0x11839, 0x1183A).addRange(0x1193D, 0x1193E);
    set.addRange(0x11D44, 0x11D45).addRange(0x11F41, 0x11F42).addRange(0x13447, 0x13455).addRange(0x16AF0, 0x16AF4).addRange(0x16B30, 0x16B36).addRange(0x16D6B, 0x16D6C).addRange(0x16F8F, 0x16F9F).addRange(0x16FF0, 0x16FF1).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D167, 0x1D169).addRange(0x1D16D, 0x1D172).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1E030, 0x1E06D).addRange(0x1E130, 0x1E136).addRange(0x1E2EC, 0x1E2EF).addRange(0x1E5EE, 0x1E5EF).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E944, 0x1E946).addRange(0x1E948, 0x1E94A);
    Diacritic.characters = set;
    return Diacritic;
  }

var Emoji_Component = {};

var hasRequiredEmoji_Component;
  function requireEmoji_Component() {
    if (hasRequiredEmoji_Component) return Emoji_Component;
    hasRequiredEmoji_Component = 1;
    var set = regenerateExports(0x23, 0x2A, 0x200D, 0x20E3, 0xFE0F);
    set.addRange(0x30, 0x39).addRange(0x1F1E6, 0x1F1FF).addRange(0x1F3FB, 0x1F3FF).addRange(0x1F9B0, 0x1F9B3).addRange(0xE0020, 0xE007F);
    Emoji_Component.characters = set;
    return Emoji_Component;
  }

var Emoji_Modifier_Base = {};

var hasRequiredEmoji_Modifier_Base;
  function requireEmoji_Modifier_Base() {
    if (hasRequiredEmoji_Modifier_Base) return Emoji_Modifier_Base;
    hasRequiredEmoji_Modifier_Base = 1;
    var set = regenerateExports(0x261D, 0x26F9, 0x1F385, 0x1F3C7, 0x1F47C, 0x1F48F, 0x1F491, 0x1F4AA, 0x1F57A, 0x1F590, 0x1F6A3, 0x1F6C0, 0x1F6CC, 0x1F90C, 0x1F90F, 0x1F926, 0x1F977, 0x1F9BB);
    set.addRange(0x270A, 0x270D).addRange(0x1F3C2, 0x1F3C4).addRange(0x1F3CA, 0x1F3CC).addRange(0x1F442, 0x1F443).addRange(0x1F446, 0x1F450).addRange(0x1F466, 0x1F478).addRange(0x1F481, 0x1F483).addRange(0x1F485, 0x1F487).addRange(0x1F574, 0x1F575).addRange(0x1F595, 0x1F596).addRange(0x1F645, 0x1F647).addRange(0x1F64B, 0x1F64F).addRange(0x1F6B4, 0x1F6B6).addRange(0x1F918, 0x1F91F).addRange(0x1F930, 0x1F939).addRange(0x1F93C, 0x1F93E).addRange(0x1F9B5, 0x1F9B6).addRange(0x1F9B8, 0x1F9B9).addRange(0x1F9CD, 0x1F9CF).addRange(0x1F9D1, 0x1F9DD).addRange(0x1FAC3, 0x1FAC5).addRange(0x1FAF0, 0x1FAF8);
    Emoji_Modifier_Base.characters = set;
    return Emoji_Modifier_Base;
  }

var Emoji_Modifier = {};

var hasRequiredEmoji_Modifier;
  function requireEmoji_Modifier() {
    if (hasRequiredEmoji_Modifier) return Emoji_Modifier;
    hasRequiredEmoji_Modifier = 1;
    var set = regenerateExports();
    set.addRange(0x1F3FB, 0x1F3FF);
    Emoji_Modifier.characters = set;
    return Emoji_Modifier;
  }

var Emoji_Presentation = {};

var hasRequiredEmoji_Presentation;
  function requireEmoji_Presentation() {
    if (hasRequiredEmoji_Presentation) return Emoji_Presentation;
    hasRequiredEmoji_Presentation = 1;
    var set = regenerateExports(0x23F0, 0x23F3, 0x267F, 0x2693, 0x26A1, 0x26CE, 0x26D4, 0x26EA, 0x26F5, 0x26FA, 0x26FD, 0x2705, 0x2728, 0x274C, 0x274E, 0x2757, 0x27B0, 0x27BF, 0x2B50, 0x2B55, 0x1F004, 0x1F0CF, 0x1F18E, 0x1F201, 0x1F21A, 0x1F22F, 0x1F3F4, 0x1F440, 0x1F57A, 0x1F5A4, 0x1F6CC, 0x1F7F0);
    set.addRange(0x231A, 0x231B).addRange(0x23E9, 0x23EC).addRange(0x25FD, 0x25FE).addRange(0x2614, 0x2615).addRange(0x2648, 0x2653).addRange(0x26AA, 0x26AB).addRange(0x26BD, 0x26BE).addRange(0x26C4, 0x26C5).addRange(0x26F2, 0x26F3).addRange(0x270A, 0x270B).addRange(0x2753, 0x2755).addRange(0x2795, 0x2797).addRange(0x2B1B, 0x2B1C).addRange(0x1F191, 0x1F19A).addRange(0x1F1E6, 0x1F1FF).addRange(0x1F232, 0x1F236).addRange(0x1F238, 0x1F23A).addRange(0x1F250, 0x1F251).addRange(0x1F300, 0x1F320).addRange(0x1F32D, 0x1F335).addRange(0x1F337, 0x1F37C).addRange(0x1F37E, 0x1F393).addRange(0x1F3A0, 0x1F3CA).addRange(0x1F3CF, 0x1F3D3).addRange(0x1F3E0, 0x1F3F0).addRange(0x1F3F8, 0x1F43E).addRange(0x1F442, 0x1F4FC).addRange(0x1F4FF, 0x1F53D).addRange(0x1F54B, 0x1F54E).addRange(0x1F550, 0x1F567).addRange(0x1F595, 0x1F596).addRange(0x1F5FB, 0x1F64F).addRange(0x1F680, 0x1F6C5).addRange(0x1F6D0, 0x1F6D2).addRange(0x1F6D5, 0x1F6D7).addRange(0x1F6DC, 0x1F6DF).addRange(0x1F6EB, 0x1F6EC).addRange(0x1F6F4, 0x1F6FC).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F90C, 0x1F93A).addRange(0x1F93C, 0x1F945).addRange(0x1F947, 0x1F9FF).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA89).addRange(0x1FA8F, 0x1FAC6).addRange(0x1FACE, 0x1FADC).addRange(0x1FADF, 0x1FAE9).addRange(0x1FAF0, 0x1FAF8);
    Emoji_Presentation.characters = set;
    return Emoji_Presentation;
  }

var Emoji = {};

var hasRequiredEmoji;
  function requireEmoji() {
    if (hasRequiredEmoji) return Emoji;
    hasRequiredEmoji = 1;
    var set = regenerateExports(0x23, 0x2A, 0xA9, 0xAE, 0x203C, 0x2049, 0x2122, 0x2139, 0x2328, 0x23CF, 0x24C2, 0x25B6, 0x25C0, 0x260E, 0x2611, 0x2618, 0x261D, 0x2620, 0x2626, 0x262A, 0x2640, 0x2642, 0x2663, 0x2668, 0x267B, 0x2699, 0x26A7, 0x26C8, 0x26D1, 0x26FD, 0x2702, 0x2705, 0x270F, 0x2712, 0x2714, 0x2716, 0x271D, 0x2721, 0x2728, 0x2744, 0x2747, 0x274C, 0x274E, 0x2757, 0x27A1, 0x27B0, 0x27BF, 0x2B50, 0x2B55, 0x3030, 0x303D, 0x3297, 0x3299, 0x1F004, 0x1F0CF, 0x1F18E, 0x1F21A, 0x1F22F, 0x1F587, 0x1F590, 0x1F5A8, 0x1F5BC, 0x1F5E1, 0x1F5E3, 0x1F5E8, 0x1F5EF, 0x1F5F3, 0x1F6E9, 0x1F6F0, 0x1F7F0);
    set.addRange(0x30, 0x39).addRange(0x2194, 0x2199).addRange(0x21A9, 0x21AA).addRange(0x231A, 0x231B).addRange(0x23E9, 0x23F3).addRange(0x23F8, 0x23FA).addRange(0x25AA, 0x25AB).addRange(0x25FB, 0x25FE).addRange(0x2600, 0x2604).addRange(0x2614, 0x2615).addRange(0x2622, 0x2623).addRange(0x262E, 0x262F).addRange(0x2638, 0x263A).addRange(0x2648, 0x2653).addRange(0x265F, 0x2660).addRange(0x2665, 0x2666).addRange(0x267E, 0x267F).addRange(0x2692, 0x2697).addRange(0x269B, 0x269C).addRange(0x26A0, 0x26A1).addRange(0x26AA, 0x26AB).addRange(0x26B0, 0x26B1).addRange(0x26BD, 0x26BE).addRange(0x26C4, 0x26C5).addRange(0x26CE, 0x26CF).addRange(0x26D3, 0x26D4).addRange(0x26E9, 0x26EA).addRange(0x26F0, 0x26F5).addRange(0x26F7, 0x26FA).addRange(0x2708, 0x270D).addRange(0x2733, 0x2734).addRange(0x2753, 0x2755).addRange(0x2763, 0x2764).addRange(0x2795, 0x2797).addRange(0x2934, 0x2935).addRange(0x2B05, 0x2B07).addRange(0x2B1B, 0x2B1C).addRange(0x1F170, 0x1F171).addRange(0x1F17E, 0x1F17F).addRange(0x1F191, 0x1F19A).addRange(0x1F1E6, 0x1F1FF).addRange(0x1F201, 0x1F202).addRange(0x1F232, 0x1F23A).addRange(0x1F250, 0x1F251).addRange(0x1F300, 0x1F321).addRange(0x1F324, 0x1F393).addRange(0x1F396, 0x1F397).addRange(0x1F399, 0x1F39B).addRange(0x1F39E, 0x1F3F0).addRange(0x1F3F3, 0x1F3F5).addRange(0x1F3F7, 0x1F4FD);
    set.addRange(0x1F4FF, 0x1F53D).addRange(0x1F549, 0x1F54E).addRange(0x1F550, 0x1F567).addRange(0x1F56F, 0x1F570).addRange(0x1F573, 0x1F57A).addRange(0x1F58A, 0x1F58D).addRange(0x1F595, 0x1F596).addRange(0x1F5A4, 0x1F5A5).addRange(0x1F5B1, 0x1F5B2).addRange(0x1F5C2, 0x1F5C4).addRange(0x1F5D1, 0x1F5D3).addRange(0x1F5DC, 0x1F5DE).addRange(0x1F5FA, 0x1F64F).addRange(0x1F680, 0x1F6C5).addRange(0x1F6CB, 0x1F6D2).addRange(0x1F6D5, 0x1F6D7).addRange(0x1F6DC, 0x1F6E5).addRange(0x1F6EB, 0x1F6EC).addRange(0x1F6F3, 0x1F6FC).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F90C, 0x1F93A).addRange(0x1F93C, 0x1F945).addRange(0x1F947, 0x1F9FF).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA89).addRange(0x1FA8F, 0x1FAC6).addRange(0x1FACE, 0x1FADC).addRange(0x1FADF, 0x1FAE9).addRange(0x1FAF0, 0x1FAF8);
    Emoji.characters = set;
    return Emoji;
  }

var Extended_Pictographic = {};

var hasRequiredExtended_Pictographic;
  function requireExtended_Pictographic() {
    if (hasRequiredExtended_Pictographic) return Extended_Pictographic;
    hasRequiredExtended_Pictographic = 1;
    var set = regenerateExports(0xA9, 0xAE, 0x203C, 0x2049, 0x2122, 0x2139, 0x2328, 0x2388, 0x23CF, 0x24C2, 0x25B6, 0x25C0, 0x2714, 0x2716, 0x271D, 0x2721, 0x2728, 0x2744, 0x2747, 0x274C, 0x274E, 0x2757, 0x27A1, 0x27B0, 0x27BF, 0x2B50, 0x2B55, 0x3030, 0x303D, 0x3297, 0x3299, 0x1F12F, 0x1F18E, 0x1F21A, 0x1F22F);
    set.addRange(0x2194, 0x2199).addRange(0x21A9, 0x21AA).addRange(0x231A, 0x231B).addRange(0x23E9, 0x23F3).addRange(0x23F8, 0x23FA).addRange(0x25AA, 0x25AB).addRange(0x25FB, 0x25FE).addRange(0x2600, 0x2605).addRange(0x2607, 0x2612).addRange(0x2614, 0x2685).addRange(0x2690, 0x2705).addRange(0x2708, 0x2712).addRange(0x2733, 0x2734).addRange(0x2753, 0x2755).addRange(0x2763, 0x2767).addRange(0x2795, 0x2797).addRange(0x2934, 0x2935).addRange(0x2B05, 0x2B07).addRange(0x2B1B, 0x2B1C).addRange(0x1F000, 0x1F0FF).addRange(0x1F10D, 0x1F10F).addRange(0x1F16C, 0x1F171).addRange(0x1F17E, 0x1F17F).addRange(0x1F191, 0x1F19A).addRange(0x1F1AD, 0x1F1E5).addRange(0x1F201, 0x1F20F).addRange(0x1F232, 0x1F23A).addRange(0x1F23C, 0x1F23F).addRange(0x1F249, 0x1F3FA).addRange(0x1F400, 0x1F53D).addRange(0x1F546, 0x1F64F).addRange(0x1F680, 0x1F6FF).addRange(0x1F774, 0x1F77F).addRange(0x1F7D5, 0x1F7FF).addRange(0x1F80C, 0x1F80F).addRange(0x1F848, 0x1F84F).addRange(0x1F85A, 0x1F85F).addRange(0x1F888, 0x1F88F).addRange(0x1F8AE, 0x1F8FF).addRange(0x1F90C, 0x1F93A).addRange(0x1F93C, 0x1F945).addRange(0x1F947, 0x1FAFF).addRange(0x1FC00, 0x1FFFD);
    Extended_Pictographic.characters = set;
    return Extended_Pictographic;
  }

var Extender = {};

var hasRequiredExtender;
  function requireExtender() {
    if (hasRequiredExtender) return Extender;
    hasRequiredExtender = 1;
    var set = regenerateExports(0xB7, 0x640, 0x7FA, 0xA71, 0xAFB, 0xB55, 0xE46, 0xEC6, 0x180A, 0x1843, 0x1AA7, 0x1C36, 0x1C7B, 0x3005, 0xA015, 0xA60C, 0xA9CF, 0xA9E6, 0xAA70, 0xAADD, 0xFF70, 0x10D4E, 0x10D6A, 0x10D6F, 0x11237, 0x1135D, 0x11A98, 0x16FE3, 0x1E5EF);
    set.addRange(0x2D0, 0x2D1).addRange(0x3031, 0x3035).addRange(0x309D, 0x309E).addRange(0x30FC, 0x30FE).addRange(0xAAF3, 0xAAF4).addRange(0x10781, 0x10782).addRange(0x113D2, 0x113D3).addRange(0x115C6, 0x115C8).addRange(0x16B42, 0x16B43).addRange(0x16FE0, 0x16FE1).addRange(0x1E13C, 0x1E13D).addRange(0x1E944, 0x1E946);
    Extender.characters = set;
    return Extender;
  }

var Grapheme_Base = {};

var hasRequiredGrapheme_Base;
  function requireGrapheme_Base() {
    if (hasRequiredGrapheme_Base) return Grapheme_Base;
    hasRequiredGrapheme_Base = 1;
    var set = regenerateExports(0x38C, 0x5BE, 0x5C0, 0x5C3, 0x5C6, 0x61B, 0x6DE, 0x6E9, 0x710, 0x7B1, 0x81A, 0x824, 0x828, 0x85E, 0x93B, 0x9B2, 0x9BD, 0x9CE, 0xA03, 0xA5E, 0xA76, 0xA83, 0xAC9, 0xAD0, 0xAF9, 0xB3D, 0xB40, 0xB83, 0xB9C, 0xBBF, 0xBD0, 0xC3D, 0xC5D, 0xCC1, 0xD3D, 0xDBD, 0xE84, 0xEA5, 0xEBD, 0xEC6, 0xF36, 0xF38, 0xF7F, 0xF85, 0x1031, 0x1038, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17B6, 0x18AA, 0x1940, 0x1A57, 0x1A61, 0x1BE7, 0x1BEE, 0x1CD3, 0x1CE1, 0x1CFA, 0x1F59, 0x1F5B, 0x1F5D, 0x2D27, 0x2D2D, 0xA673, 0xA7D3, 0xA952, 0xAA4D, 0xAAB1, 0xAAC0, 0xAAC2, 0xFB1D, 0xFB3E, 0xFDCF, 0x101A0, 0x10808, 0x1083C, 0x1093F, 0x10EAD, 0x11000, 0x11075, 0x1112C, 0x111BF, 0x11288, 0x1133D, 0x1133F, 0x11350, 0x1138B, 0x1138E, 0x113B7, 0x113CA, 0x113D1, 0x11445, 0x1145D, 0x114B9, 0x114BE, 0x114C1, 0x115BE, 0x1163E, 0x116AC, 0x1171E, 0x11726, 0x11838, 0x1183B, 0x11909, 0x11A00, 0x11A50, 0x11A97, 0x11C3E, 0x11CA9, 0x11CB1, 0x11CB4, 0x11D46, 0x11D96, 0x11D98, 0x11FB0, 0x16AF5, 0x1B132, 0x1B155, 0x1BC9C, 0x1BC9F, 0x1D245, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E2FF, 0x1E5FF, 0x1E94B, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E, 0x1F7F0);
    set.addRange(0x20, 0x7E).addRange(0xA0, 0xAC).addRange(0xAE, 0x2FF).addRange(0x370, 0x377).addRange(0x37A, 0x37F).addRange(0x384, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x482).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x559, 0x58A).addRange(0x58D, 0x58F).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F4).addRange(0x606, 0x60F).addRange(0x61D, 0x64A).addRange(0x660, 0x66F).addRange(0x671, 0x6D5).addRange(0x6E5, 0x6E6).addRange(0x6EE, 0x70D).addRange(0x712, 0x72F).addRange(0x74D, 0x7A5).addRange(0x7C0, 0x7EA).addRange(0x7F4, 0x7FA).addRange(0x7FE, 0x815).addRange(0x830, 0x83E).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x88E).addRange(0x8A0, 0x8C9).addRange(0x903, 0x939).addRange(0x93D, 0x940).addRange(0x949, 0x94C).addRange(0x94E, 0x950).addRange(0x958, 0x961).addRange(0x964, 0x980).addRange(0x982, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BF, 0x9C0).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CC).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E1).addRange(0x9E6, 0x9FD).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28);
    set.addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA40).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA6F).addRange(0xA72, 0xA74).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABD, 0xAC0).addRange(0xACB, 0xACC).addRange(0xAE0, 0xAE1).addRange(0xAE6, 0xAF1).addRange(0xB02, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4C).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB61).addRange(0xB66, 0xB77).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xBC1, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCC).addRange(0xBE6, 0xBFA).addRange(0xC01, 0xC03).addRange(0xC05, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC41, 0xC44).addRange(0xC58, 0xC5A).addRange(0xC60, 0xC61).addRange(0xC66, 0xC6F);
    set.addRange(0xC77, 0xC80).addRange(0xC82, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBD, 0xCBE).addRange(0xCC3, 0xCC4).addRange(0xCDD, 0xCDE).addRange(0xCE0, 0xCE1).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3).addRange(0xD02, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD3F, 0xD40).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4C).addRange(0xD4E, 0xD4F).addRange(0xD54, 0xD56).addRange(0xD58, 0xD61).addRange(0xD66, 0xD7F).addRange(0xD82, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDD0, 0xDD1).addRange(0xDD8, 0xDDE).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF4).addRange(0xE01, 0xE30).addRange(0xE32, 0xE33).addRange(0xE3F, 0xE46).addRange(0xE4F, 0xE5B).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB0).addRange(0xEB2, 0xEB3).addRange(0xEC0, 0xEC4).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF).addRange(0xF00, 0xF17).addRange(0xF1A, 0xF34).addRange(0xF3A, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF88, 0xF8C).addRange(0xFBE, 0xFC5).addRange(0xFC7, 0xFCC).addRange(0xFCE, 0xFDA);
    set.addRange(0x1000, 0x102C).addRange(0x103B, 0x103C).addRange(0x103F, 0x1057).addRange(0x105A, 0x105D).addRange(0x1061, 0x1070).addRange(0x1075, 0x1081).addRange(0x1083, 0x1084).addRange(0x1087, 0x108C).addRange(0x108E, 0x109C).addRange(0x109E, 0x10C5).addRange(0x10D0, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1360, 0x137C).addRange(0x1380, 0x1399).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1400, 0x169C).addRange(0x16A0, 0x16F8).addRange(0x1700, 0x1711).addRange(0x171F, 0x1731).addRange(0x1735, 0x1736).addRange(0x1740, 0x1751).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1780, 0x17B3).addRange(0x17BE, 0x17C5).addRange(0x17C7, 0x17C8).addRange(0x17D4, 0x17DC).addRange(0x17E0, 0x17E9).addRange(0x17F0, 0x17F9).addRange(0x1800, 0x180A).addRange(0x1810, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x1884).addRange(0x1887, 0x18A8).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1923, 0x1926).addRange(0x1929, 0x192B);
    set.addRange(0x1930, 0x1931).addRange(0x1933, 0x1938).addRange(0x1944, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x19DE, 0x1A16).addRange(0x1A19, 0x1A1A).addRange(0x1A1E, 0x1A55).addRange(0x1A63, 0x1A64).addRange(0x1A6D, 0x1A72).addRange(0x1A80, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AA0, 0x1AAD).addRange(0x1B04, 0x1B33).addRange(0x1B3E, 0x1B41).addRange(0x1B45, 0x1B4C).addRange(0x1B4E, 0x1B6A).addRange(0x1B74, 0x1B7F).addRange(0x1B82, 0x1BA1).addRange(0x1BA6, 0x1BA7).addRange(0x1BAE, 0x1BE5).addRange(0x1BEA, 0x1BEC).addRange(0x1BFC, 0x1C2B).addRange(0x1C34, 0x1C35).addRange(0x1C3B, 0x1C49).addRange(0x1C4D, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CC7).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF7).addRange(0x1D00, 0x1DBF).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FC4).addRange(0x1FC6, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FDD, 0x1FEF).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFE).addRange(0x2000, 0x200A).addRange(0x2010, 0x2027).addRange(0x202F, 0x205F).addRange(0x2070, 0x2071);
    set.addRange(0x2074, 0x208E).addRange(0x2090, 0x209C).addRange(0x20A0, 0x20C0).addRange(0x2100, 0x218B).addRange(0x2190, 0x2429).addRange(0x2440, 0x244A).addRange(0x2460, 0x2B73).addRange(0x2B76, 0x2B95).addRange(0x2B97, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2CF9, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D6F, 0x2D70).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x2E00, 0x2E5D).addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x2FF0, 0x3029).addRange(0x3030, 0x303F).addRange(0x3041, 0x3096).addRange(0x309B, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x3190, 0x31E5).addRange(0x31EF, 0x321E).addRange(0x3220, 0xA48C).addRange(0xA490, 0xA4C6).addRange(0xA4D0, 0xA62B).addRange(0xA640, 0xA66E).addRange(0xA67E, 0xA69D).addRange(0xA6A0, 0xA6EF).addRange(0xA6F2, 0xA6F7).addRange(0xA700, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F2, 0xA801).addRange(0xA803, 0xA805).addRange(0xA807, 0xA80A).addRange(0xA80C, 0xA824).addRange(0xA827, 0xA82B).addRange(0xA830, 0xA839).addRange(0xA840, 0xA877);
    set.addRange(0xA880, 0xA8C3).addRange(0xA8CE, 0xA8D9).addRange(0xA8F2, 0xA8FE).addRange(0xA900, 0xA925).addRange(0xA92E, 0xA946).addRange(0xA95F, 0xA97C).addRange(0xA983, 0xA9B2).addRange(0xA9B4, 0xA9B5).addRange(0xA9BA, 0xA9BB).addRange(0xA9BE, 0xA9BF).addRange(0xA9C1, 0xA9CD).addRange(0xA9CF, 0xA9D9).addRange(0xA9DE, 0xA9E4).addRange(0xA9E6, 0xA9FE).addRange(0xAA00, 0xAA28).addRange(0xAA2F, 0xAA30).addRange(0xAA33, 0xAA34).addRange(0xAA40, 0xAA42).addRange(0xAA44, 0xAA4B).addRange(0xAA50, 0xAA59).addRange(0xAA5C, 0xAA7B).addRange(0xAA7D, 0xAAAF).addRange(0xAAB5, 0xAAB6).addRange(0xAAB9, 0xAABD).addRange(0xAADB, 0xAAEB).addRange(0xAAEE, 0xAAF5).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB6B).addRange(0xAB70, 0xABE4).addRange(0xABE6, 0xABE7).addRange(0xABE9, 0xABEC).addRange(0xABF0, 0xABF9).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1F, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBC2).addRange(0xFBD3, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFF);
    set.addRange(0xFE10, 0xFE19).addRange(0xFE30, 0xFE52).addRange(0xFE54, 0xFE66).addRange(0xFE68, 0xFE6B).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF01, 0xFF9D).addRange(0xFFA0, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFFC, 0xFFFD).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10100, 0x10102).addRange(0x10107, 0x10133).addRange(0x10137, 0x1018E).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FC).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x102E1, 0x102FB).addRange(0x10300, 0x10323).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x10375).addRange(0x10380, 0x1039D).addRange(0x1039F, 0x103C3).addRange(0x103C8, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104A0, 0x104A9).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x1056F, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3);
    set.addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10857, 0x1089E).addRange(0x108A7, 0x108AF).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x108FB, 0x1091B).addRange(0x1091F, 0x10939).addRange(0x10980, 0x109B7).addRange(0x109BC, 0x109CF).addRange(0x109D2, 0x10A00).addRange(0x10A10, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A40, 0x10A48).addRange(0x10A50, 0x10A58).addRange(0x10A60, 0x10A9F).addRange(0x10AC0, 0x10AE4).addRange(0x10AEB, 0x10AF6).addRange(0x10B00, 0x10B35).addRange(0x10B39, 0x10B55).addRange(0x10B58, 0x10B72).addRange(0x10B78, 0x10B91).addRange(0x10B99, 0x10B9C).addRange(0x10BA9, 0x10BAF).addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10CFA, 0x10D23).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D65).addRange(0x10D6E, 0x10D85).addRange(0x10D8E, 0x10D8F).addRange(0x10E60, 0x10E7E).addRange(0x10E80, 0x10EA9).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC4).addRange(0x10F00, 0x10F27).addRange(0x10F30, 0x10F45).addRange(0x10F51, 0x10F59).addRange(0x10F70, 0x10F81).addRange(0x10F86, 0x10F89).addRange(0x10FB0, 0x10FCB);
    set.addRange(0x10FE0, 0x10FF6).addRange(0x11002, 0x11037).addRange(0x11047, 0x1104D).addRange(0x11052, 0x1106F).addRange(0x11071, 0x11072).addRange(0x11082, 0x110B2).addRange(0x110B7, 0x110B8).addRange(0x110BB, 0x110BC).addRange(0x110BE, 0x110C1).addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9).addRange(0x11103, 0x11126).addRange(0x11136, 0x11147).addRange(0x11150, 0x11172).addRange(0x11174, 0x11176).addRange(0x11182, 0x111B5).addRange(0x111C1, 0x111C8).addRange(0x111CD, 0x111CE).addRange(0x111D0, 0x111DF).addRange(0x111E1, 0x111F4).addRange(0x11200, 0x11211).addRange(0x11213, 0x1122E).addRange(0x11232, 0x11233).addRange(0x11238, 0x1123D).addRange(0x1123F, 0x11240).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A9).addRange(0x112B0, 0x112DE).addRange(0x112E0, 0x112E2).addRange(0x112F0, 0x112F9).addRange(0x11302, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x11341, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134C).addRange(0x1135D, 0x11363).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B9, 0x113BA).addRange(0x113CC, 0x113CD).addRange(0x113D3, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x11400, 0x11437).addRange(0x11440, 0x11441);
    set.addRange(0x11447, 0x1145B).addRange(0x1145F, 0x11461).addRange(0x11480, 0x114AF).addRange(0x114B1, 0x114B2).addRange(0x114BB, 0x114BC).addRange(0x114C4, 0x114C7).addRange(0x114D0, 0x114D9).addRange(0x11580, 0x115AE).addRange(0x115B0, 0x115B1).addRange(0x115B8, 0x115BB).addRange(0x115C1, 0x115DB).addRange(0x11600, 0x11632).addRange(0x1163B, 0x1163C).addRange(0x11641, 0x11644).addRange(0x11650, 0x11659).addRange(0x11660, 0x1166C).addRange(0x11680, 0x116AA).addRange(0x116AE, 0x116AF).addRange(0x116B8, 0x116B9).addRange(0x116C0, 0x116C9).addRange(0x116D0, 0x116E3).addRange(0x11700, 0x1171A).addRange(0x11720, 0x11721).addRange(0x11730, 0x11746).addRange(0x11800, 0x1182E).addRange(0x118A0, 0x118F2).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x1192F).addRange(0x11931, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193F, 0x11942).addRange(0x11944, 0x11946).addRange(0x11950, 0x11959).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D3).addRange(0x119DC, 0x119DF).addRange(0x119E1, 0x119E4).addRange(0x11A0B, 0x11A32).addRange(0x11A39, 0x11A3A).addRange(0x11A3F, 0x11A46).addRange(0x11A57, 0x11A58).addRange(0x11A5C, 0x11A89).addRange(0x11A9A, 0x11AA2).addRange(0x11AB0, 0x11AF8).addRange(0x11B00, 0x11B09).addRange(0x11BC0, 0x11BE1).addRange(0x11BF0, 0x11BF9).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C2F);
    set.addRange(0x11C40, 0x11C45).addRange(0x11C50, 0x11C6C).addRange(0x11C70, 0x11C8F).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D30).addRange(0x11D50, 0x11D59).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D93, 0x11D94).addRange(0x11DA0, 0x11DA9).addRange(0x11EE0, 0x11EF2).addRange(0x11EF5, 0x11EF8).addRange(0x11F02, 0x11F10).addRange(0x11F12, 0x11F35).addRange(0x11F3E, 0x11F3F).addRange(0x11F43, 0x11F59).addRange(0x11FC0, 0x11FF1).addRange(0x11FFF, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12470, 0x12474).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF2).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1611D).addRange(0x1612A, 0x1612C).addRange(0x16130, 0x16139).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A6E, 0x16ABE).addRange(0x16AC0, 0x16AC9).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B37, 0x16B45).addRange(0x16B50, 0x16B59).addRange(0x16B5B, 0x16B61).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D79).addRange(0x16E40, 0x16E9A).addRange(0x16F00, 0x16F4A).addRange(0x16F50, 0x16F87).addRange(0x16F93, 0x16F9F).addRange(0x16FE0, 0x16FE3).addRange(0x17000, 0x187F7).addRange(0x18800, 0x18CD5);
    set.addRange(0x18CFF, 0x18D08).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1CC00, 0x1CCF9).addRange(0x1CD00, 0x1CEB3).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D164).addRange(0x1D16A, 0x1D16C).addRange(0x1D183, 0x1D184).addRange(0x1D18C, 0x1D1A9).addRange(0x1D1AE, 0x1D1EA).addRange(0x1D200, 0x1D241).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D300, 0x1D356).addRange(0x1D360, 0x1D378).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D7CB).addRange(0x1D7CE, 0x1D9FF).addRange(0x1DA37, 0x1DA3A).addRange(0x1DA6D, 0x1DA74).addRange(0x1DA76, 0x1DA83).addRange(0x1DA85, 0x1DA8B).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A);
    set.addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E137, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E14E, 0x1E14F).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E2F0, 0x1E2F9).addRange(0x1E4D0, 0x1E4EB).addRange(0x1E4F0, 0x1E4F9).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E5F0, 0x1E5FA).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E8C7, 0x1E8CF).addRange(0x1E900, 0x1E943).addRange(0x1E950, 0x1E959).addRange(0x1E95E, 0x1E95F).addRange(0x1EC71, 0x1ECB4).addRange(0x1ED01, 0x1ED3D).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1EEF0, 0x1EEF1).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093).addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF).addRange(0x1F0D1, 0x1F0F5).addRange(0x1F100, 0x1F1AD).addRange(0x1F1E6, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248);
    set.addRange(0x1F250, 0x1F251).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F6D7).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F776).addRange(0x1F77B, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F900, 0x1FA53).addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA89).addRange(0x1FA8F, 0x1FAC6).addRange(0x1FACE, 0x1FADC).addRange(0x1FADF, 0x1FAE9).addRange(0x1FAF0, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBF9).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF);
    Grapheme_Base.characters = set;
    return Grapheme_Base;
  }

var Grapheme_Extend = {};

var hasRequiredGrapheme_Extend;
  function requireGrapheme_Extend() {
    if (hasRequiredGrapheme_Extend) return Grapheme_Extend;
    hasRequiredGrapheme_Extend = 1;
    var set = regenerateExports(0x5BF, 0x5C7, 0x670, 0x711, 0x7FD, 0x93A, 0x93C, 0x94D, 0x981, 0x9BC, 0x9BE, 0x9CD, 0x9D7, 0x9FE, 0xA3C, 0xA51, 0xA75, 0xABC, 0xACD, 0xB01, 0xB3C, 0xB4D, 0xB82, 0xBBE, 0xBC0, 0xBCD, 0xBD7, 0xC00, 0xC04, 0xC3C, 0xC81, 0xCBC, 0xCC2, 0xD3E, 0xD4D, 0xD57, 0xD81, 0xDCA, 0xDCF, 0xDD6, 0xDDF, 0xE31, 0xEB1, 0xF35, 0xF37, 0xF39, 0xFC6, 0x1082, 0x108D, 0x109D, 0x17C6, 0x17DD, 0x180F, 0x18A9, 0x1932, 0x1A1B, 0x1A56, 0x1A60, 0x1A62, 0x1A7F, 0x1BE6, 0x1BED, 0x1CED, 0x1CF4, 0x200C, 0x2D7F, 0xA802, 0xA806, 0xA80B, 0xA82C, 0xA8FF, 0xA953, 0xA9B3, 0xA9C0, 0xA9E5, 0xAA43, 0xAA4C, 0xAA7C, 0xAAB0, 0xAAC1, 0xAAF6, 0xABE5, 0xABE8, 0xABED, 0xFB1E, 0x101FD, 0x102E0, 0x10A3F, 0x11001, 0x11070, 0x110C2, 0x11173, 0x111C0, 0x111CF, 0x1123E, 0x11241, 0x112DF, 0x1133E, 0x11340, 0x1134D, 0x11357, 0x113B8, 0x113C2, 0x113C5, 0x113D2, 0x11446, 0x1145E, 0x114B0, 0x114BA, 0x114BD, 0x115AF, 0x1163D, 0x116AB, 0x116AD, 0x1171D, 0x1171F, 0x11930, 0x11943, 0x119E0, 0x11A47, 0x11C3F, 0x11D3A, 0x11D47, 0x11D95, 0x11D97, 0x11F5A, 0x13440, 0x16F4F, 0x16FE4, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E2AE);
    set.addRange(0x300, 0x36F).addRange(0x483, 0x489).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x610, 0x61A).addRange(0x64B, 0x65F).addRange(0x6D6, 0x6DC).addRange(0x6DF, 0x6E4).addRange(0x6E7, 0x6E8).addRange(0x6EA, 0x6ED).addRange(0x730, 0x74A).addRange(0x7A6, 0x7B0).addRange(0x7EB, 0x7F3).addRange(0x816, 0x819).addRange(0x81B, 0x823).addRange(0x825, 0x827).addRange(0x829, 0x82D).addRange(0x859, 0x85B).addRange(0x897, 0x89F).addRange(0x8CA, 0x8E1).addRange(0x8E3, 0x902).addRange(0x941, 0x948).addRange(0x951, 0x957).addRange(0x962, 0x963).addRange(0x9C1, 0x9C4).addRange(0x9E2, 0x9E3).addRange(0xA01, 0xA02).addRange(0xA41, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA70, 0xA71).addRange(0xA81, 0xA82).addRange(0xAC1, 0xAC5).addRange(0xAC7, 0xAC8).addRange(0xAE2, 0xAE3).addRange(0xAFA, 0xAFF).addRange(0xB3E, 0xB3F).addRange(0xB41, 0xB44).addRange(0xB55, 0xB57).addRange(0xB62, 0xB63).addRange(0xC3E, 0xC40).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC62, 0xC63).addRange(0xCBF, 0xCC0).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCE2, 0xCE3);
    set.addRange(0xD00, 0xD01).addRange(0xD3B, 0xD3C).addRange(0xD41, 0xD44).addRange(0xD62, 0xD63).addRange(0xDD2, 0xDD4).addRange(0xE34, 0xE3A).addRange(0xE47, 0xE4E).addRange(0xEB4, 0xEBC).addRange(0xEC8, 0xECE).addRange(0xF18, 0xF19).addRange(0xF71, 0xF7E).addRange(0xF80, 0xF84).addRange(0xF86, 0xF87).addRange(0xF8D, 0xF97).addRange(0xF99, 0xFBC).addRange(0x102D, 0x1030).addRange(0x1032, 0x1037).addRange(0x1039, 0x103A).addRange(0x103D, 0x103E).addRange(0x1058, 0x1059).addRange(0x105E, 0x1060).addRange(0x1071, 0x1074).addRange(0x1085, 0x1086).addRange(0x135D, 0x135F).addRange(0x1712, 0x1715).addRange(0x1732, 0x1734).addRange(0x1752, 0x1753).addRange(0x1772, 0x1773).addRange(0x17B4, 0x17B5).addRange(0x17B7, 0x17BD).addRange(0x17C9, 0x17D3).addRange(0x180B, 0x180D).addRange(0x1885, 0x1886).addRange(0x1920, 0x1922).addRange(0x1927, 0x1928).addRange(0x1939, 0x193B).addRange(0x1A17, 0x1A18).addRange(0x1A58, 0x1A5E).addRange(0x1A65, 0x1A6C).addRange(0x1A73, 0x1A7C).addRange(0x1AB0, 0x1ACE).addRange(0x1B00, 0x1B03).addRange(0x1B34, 0x1B3D).addRange(0x1B42, 0x1B44).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1B81).addRange(0x1BA2, 0x1BA5).addRange(0x1BA8, 0x1BAD).addRange(0x1BE8, 0x1BE9).addRange(0x1BEF, 0x1BF3).addRange(0x1C2C, 0x1C33);
    set.addRange(0x1C36, 0x1C37).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CE0).addRange(0x1CE2, 0x1CE8).addRange(0x1CF8, 0x1CF9).addRange(0x1DC0, 0x1DFF).addRange(0x20D0, 0x20F0).addRange(0x2CEF, 0x2CF1).addRange(0x2DE0, 0x2DFF).addRange(0x302A, 0x302F).addRange(0x3099, 0x309A).addRange(0xA66F, 0xA672).addRange(0xA674, 0xA67D).addRange(0xA69E, 0xA69F).addRange(0xA6F0, 0xA6F1).addRange(0xA825, 0xA826).addRange(0xA8C4, 0xA8C5).addRange(0xA8E0, 0xA8F1).addRange(0xA926, 0xA92D).addRange(0xA947, 0xA951).addRange(0xA980, 0xA982).addRange(0xA9B6, 0xA9B9).addRange(0xA9BC, 0xA9BD).addRange(0xAA29, 0xAA2E).addRange(0xAA31, 0xAA32).addRange(0xAA35, 0xAA36).addRange(0xAAB2, 0xAAB4).addRange(0xAAB7, 0xAAB8).addRange(0xAABE, 0xAABF).addRange(0xAAEC, 0xAAED).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0xFF9E, 0xFF9F).addRange(0x10376, 0x1037A).addRange(0x10A01, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A0F).addRange(0x10A38, 0x10A3A).addRange(0x10AE5, 0x10AE6).addRange(0x10D24, 0x10D27).addRange(0x10D69, 0x10D6D).addRange(0x10EAB, 0x10EAC).addRange(0x10EFC, 0x10EFF).addRange(0x10F46, 0x10F50).addRange(0x10F82, 0x10F85).addRange(0x11038, 0x11046).addRange(0x11073, 0x11074).addRange(0x1107F, 0x11081).addRange(0x110B3, 0x110B6).addRange(0x110B9, 0x110BA).addRange(0x11100, 0x11102);
    set.addRange(0x11127, 0x1112B).addRange(0x1112D, 0x11134).addRange(0x11180, 0x11181).addRange(0x111B6, 0x111BE).addRange(0x111C9, 0x111CC).addRange(0x1122F, 0x11231).addRange(0x11234, 0x11237).addRange(0x112E3, 0x112EA).addRange(0x11300, 0x11301).addRange(0x1133B, 0x1133C).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x113BB, 0x113C0).addRange(0x113C7, 0x113C9).addRange(0x113CE, 0x113D0).addRange(0x113E1, 0x113E2).addRange(0x11438, 0x1143F).addRange(0x11442, 0x11444).addRange(0x114B3, 0x114B8).addRange(0x114BF, 0x114C0).addRange(0x114C2, 0x114C3).addRange(0x115B2, 0x115B5).addRange(0x115BC, 0x115BD).addRange(0x115BF, 0x115C0).addRange(0x115DC, 0x115DD).addRange(0x11633, 0x1163A).addRange(0x1163F, 0x11640).addRange(0x116B0, 0x116B7).addRange(0x11722, 0x11725).addRange(0x11727, 0x1172B).addRange(0x1182F, 0x11837).addRange(0x11839, 0x1183A).addRange(0x1193B, 0x1193E).addRange(0x119D4, 0x119D7).addRange(0x119DA, 0x119DB).addRange(0x11A01, 0x11A0A).addRange(0x11A33, 0x11A38).addRange(0x11A3B, 0x11A3E).addRange(0x11A51, 0x11A56).addRange(0x11A59, 0x11A5B).addRange(0x11A8A, 0x11A96).addRange(0x11A98, 0x11A99).addRange(0x11C30, 0x11C36).addRange(0x11C38, 0x11C3D).addRange(0x11C92, 0x11CA7).addRange(0x11CAA, 0x11CB0).addRange(0x11CB2, 0x11CB3).addRange(0x11CB5, 0x11CB6).addRange(0x11D31, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D45);
    set.addRange(0x11D90, 0x11D91).addRange(0x11EF3, 0x11EF4).addRange(0x11F00, 0x11F01).addRange(0x11F36, 0x11F3A).addRange(0x11F40, 0x11F42).addRange(0x13447, 0x13455).addRange(0x1611E, 0x16129).addRange(0x1612D, 0x1612F).addRange(0x16AF0, 0x16AF4).addRange(0x16B30, 0x16B36).addRange(0x16F8F, 0x16F92).addRange(0x16FF0, 0x16FF1).addRange(0x1BC9D, 0x1BC9E).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D165, 0x1D169).addRange(0x1D16D, 0x1D172).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1D242, 0x1D244).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E130, 0x1E136).addRange(0x1E2EC, 0x1E2EF).addRange(0x1E4EC, 0x1E4EF).addRange(0x1E5EE, 0x1E5EF).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E944, 0x1E94A).addRange(0xE0020, 0xE007F).addRange(0xE0100, 0xE01EF);
    Grapheme_Extend.characters = set;
    return Grapheme_Extend;
  }

var Hex_Digit = {};

var hasRequiredHex_Digit;
  function requireHex_Digit() {
    if (hasRequiredHex_Digit) return Hex_Digit;
    hasRequiredHex_Digit = 1;
    var set = regenerateExports();
    set.addRange(0x30, 0x39).addRange(0x41, 0x46).addRange(0x61, 0x66).addRange(0xFF10, 0xFF19).addRange(0xFF21, 0xFF26).addRange(0xFF41, 0xFF46);
    Hex_Digit.characters = set;
    return Hex_Digit;
  }

var ID_Continue = {};

var hasRequiredID_Continue;
  function requireID_Continue() {
    if (hasRequiredID_Continue) return ID_Continue;
    hasRequiredID_Continue = 1;
    var set = regenerateExports(0x5F, 0xAA, 0xB5, 0xB7, 0xBA, 0x2EC, 0x2EE, 0x37F, 0x38C, 0x559, 0x5BF, 0x5C7, 0x6FF, 0x7FA, 0x7FD, 0x9B2, 0x9D7, 0x9FC, 0x9FE, 0xA3C, 0xA51, 0xA5E, 0xAD0, 0xB71, 0xB9C, 0xBD0, 0xBD7, 0xC5D, 0xDBD, 0xDCA, 0xDD6, 0xE84, 0xEA5, 0xEC6, 0xF00, 0xF35, 0xF37, 0xF39, 0xFC6, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x1AA7, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2054, 0x2071, 0x207F, 0x20E1, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0xA7D3, 0xA82C, 0xA8FB, 0xFB3E, 0xFF3F, 0x101FD, 0x102E0, 0x10808, 0x1083C, 0x10A3F, 0x10F27, 0x110C2, 0x11176, 0x111DC, 0x11288, 0x11350, 0x11357, 0x1138B, 0x1138E, 0x113C2, 0x113C5, 0x114C7, 0x11644, 0x11909, 0x11A47, 0x11A9D, 0x11D3A, 0x11FB0, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E14E, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E);
    set.addRange(0x30, 0x39).addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x300, 0x374).addRange(0x376, 0x377).addRange(0x37A, 0x37D).addRange(0x386, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x483, 0x487).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x610, 0x61A).addRange(0x620, 0x669).addRange(0x66E, 0x6D3).addRange(0x6D5, 0x6DC).addRange(0x6DF, 0x6E8).addRange(0x6EA, 0x6FC).addRange(0x710, 0x74A).addRange(0x74D, 0x7B1).addRange(0x7C0, 0x7F5).addRange(0x800, 0x82D).addRange(0x840, 0x85B).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88E).addRange(0x897, 0x8E1).addRange(0x8E3, 0x963).addRange(0x966, 0x96F).addRange(0x971, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BC, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CE).addRange(0x9DC, 0x9DD);
    set.addRange(0x9DF, 0x9E3).addRange(0x9E6, 0x9F1).addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA75).addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABC, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE0, 0xAE3).addRange(0xAE6, 0xAEF).addRange(0xAF9, 0xAFF).addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3C, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB66, 0xB6F).addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9);
    set.addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD).addRange(0xBE6, 0xBEF).addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3C, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC60, 0xC63).addRange(0xC66, 0xC6F).addRange(0xC80, 0xC83).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBC, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCDD, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3).addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4E).addRange(0xD54, 0xD57).addRange(0xD5F, 0xD63).addRange(0xD66, 0xD6F).addRange(0xD7A, 0xD7F).addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF3).addRange(0xE01, 0xE3A).addRange(0xE40, 0xE4E).addRange(0xE50, 0xE59).addRange(0xE81, 0xE82);
    set.addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEC8, 0xECE).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF).addRange(0xF18, 0xF19).addRange(0xF20, 0xF29).addRange(0xF3E, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF84).addRange(0xF86, 0xF97).addRange(0xF99, 0xFBC).addRange(0x1000, 0x1049).addRange(0x1050, 0x109D).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x135D, 0x135F).addRange(0x1369, 0x1371).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8).addRange(0x1700, 0x1715).addRange(0x171F, 0x1734).addRange(0x1740, 0x1753).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773).addRange(0x1780, 0x17D3).addRange(0x17DC, 0x17DD).addRange(0x17E0, 0x17E9);
    set.addRange(0x180B, 0x180D).addRange(0x180F, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1946, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x1A00, 0x1A1B).addRange(0x1A20, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1A7F, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AB0, 0x1ABD).addRange(0x1ABF, 0x1ACE).addRange(0x1B00, 0x1B4C).addRange(0x1B50, 0x1B59).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1BF3).addRange(0x1C00, 0x1C37).addRange(0x1C40, 0x1C49).addRange(0x1C4D, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CFA).addRange(0x1D00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x200C, 0x200D).addRange(0x203F, 0x2040).addRange(0x2090, 0x209C).addRange(0x20D0, 0x20DC);
    set.addRange(0x20E5, 0x20F0).addRange(0x210A, 0x2113).addRange(0x2118, 0x211D).addRange(0x212A, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2160, 0x2188).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D7F, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x2DE0, 0x2DFF).addRange(0x3005, 0x3007).addRange(0x3021, 0x302F).addRange(0x3031, 0x3035).addRange(0x3038, 0x303C).addRange(0x3041, 0x3096).addRange(0x3099, 0x309F).addRange(0x30A1, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA62B).addRange(0xA640, 0xA66F).addRange(0xA674, 0xA67D).addRange(0xA67F, 0xA6F1).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F2, 0xA827).addRange(0xA840, 0xA873).addRange(0xA880, 0xA8C5).addRange(0xA8D0, 0xA8D9).addRange(0xA8E0, 0xA8F7).addRange(0xA8FD, 0xA92D);
    set.addRange(0xA930, 0xA953).addRange(0xA960, 0xA97C).addRange(0xA980, 0xA9C0).addRange(0xA9CF, 0xA9D9).addRange(0xA9E0, 0xA9FE).addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA50, 0xAA59).addRange(0xAA60, 0xAA76).addRange(0xAA7A, 0xAAC2).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEF).addRange(0xAAF2, 0xAAF6).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABEA).addRange(0xABEC, 0xABED).addRange(0xABF0, 0xABF9).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1D, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFB).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0xFE33, 0xFE34).addRange(0xFE4D, 0xFE4F).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF10, 0xFF19).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF65, 0xFFBE).addRange(0xFFC2, 0xFFC7);
    set.addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10140, 0x10174).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x10300, 0x1031F).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x1037A).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x103D1, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104A0, 0x104A9).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939);
    set.addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A00, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A38, 0x10A3A).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE6).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91).addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D27).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D65).addRange(0x10D69, 0x10D6D).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAC).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC4).addRange(0x10EFC, 0x10F1C).addRange(0x10F30, 0x10F50).addRange(0x10F70, 0x10F85).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11000, 0x11046).addRange(0x11066, 0x11075).addRange(0x1107F, 0x110BA).addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9).addRange(0x11100, 0x11134).addRange(0x11136, 0x1113F).addRange(0x11144, 0x11147).addRange(0x11150, 0x11173).addRange(0x11180, 0x111C4).addRange(0x111C9, 0x111CC).addRange(0x111CE, 0x111DA).addRange(0x11200, 0x11211).addRange(0x11213, 0x11237).addRange(0x1123E, 0x11241).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D);
    set.addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112EA).addRange(0x112F0, 0x112F9).addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133B, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x1135D, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D3).addRange(0x113E1, 0x113E2).addRange(0x11400, 0x1144A).addRange(0x11450, 0x11459).addRange(0x1145E, 0x11461).addRange(0x11480, 0x114C5).addRange(0x114D0, 0x114D9).addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115C0).addRange(0x115D8, 0x115DD).addRange(0x11600, 0x11640).addRange(0x11650, 0x11659).addRange(0x11680, 0x116B8).addRange(0x116C0, 0x116C9).addRange(0x116D0, 0x116E3).addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172B).addRange(0x11730, 0x11739).addRange(0x11740, 0x11746).addRange(0x11800, 0x1183A).addRange(0x118A0, 0x118E9).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x11943).addRange(0x11950, 0x11959).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D7).addRange(0x119DA, 0x119E1);
    set.addRange(0x119E3, 0x119E4).addRange(0x11A00, 0x11A3E).addRange(0x11A50, 0x11A99).addRange(0x11AB0, 0x11AF8).addRange(0x11BC0, 0x11BE0).addRange(0x11BF0, 0x11BF9).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C40).addRange(0x11C50, 0x11C59).addRange(0x11C72, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D47).addRange(0x11D50, 0x11D59).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D98).addRange(0x11DA0, 0x11DA9).addRange(0x11EE0, 0x11EF6).addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F42).addRange(0x11F50, 0x11F5A).addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13440, 0x13455).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x16139).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A70, 0x16ABE).addRange(0x16AC0, 0x16AC9).addRange(0x16AD0, 0x16AED).addRange(0x16AF0, 0x16AF4).addRange(0x16B00, 0x16B36).addRange(0x16B40, 0x16B43).addRange(0x16B50, 0x16B59).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F);
    set.addRange(0x16D40, 0x16D6C).addRange(0x16D70, 0x16D79).addRange(0x16E40, 0x16E7F).addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FE3, 0x16FE4).addRange(0x16FF0, 0x16FF1).addRange(0x17000, 0x187F7).addRange(0x18800, 0x18CD5).addRange(0x18CFF, 0x18D08).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1BC9D, 0x1BC9E).addRange(0x1CCF0, 0x1CCF9).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D165, 0x1D169).addRange(0x1D16D, 0x1D172).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1D242, 0x1D244).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA);
    set.addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1D7CE, 0x1D7FF).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E130, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E290, 0x1E2AE).addRange(0x1E2C0, 0x1E2F9).addRange(0x1E4D0, 0x1E4F9).addRange(0x1E5D0, 0x1E5FA).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E900, 0x1E94B).addRange(0x1E950, 0x1E959).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B);
    set.addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1FBF0, 0x1FBF9).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF).addRange(0xE0100, 0xE01EF);
    ID_Continue.characters = set;
    return ID_Continue;
  }

var ID_Start = {};

var hasRequiredID_Start;
  function requireID_Start() {
    if (hasRequiredID_Start) return ID_Start;
    hasRequiredID_Start = 1;
    var set = regenerateExports(0xAA, 0xB5, 0xBA, 0x2EC, 0x2EE, 0x37F, 0x386, 0x38C, 0x559, 0x6D5, 0x6FF, 0x710, 0x7B1, 0x7FA, 0x81A, 0x824, 0x828, 0x93D, 0x950, 0x9B2, 0x9BD, 0x9CE, 0x9FC, 0xA5E, 0xABD, 0xAD0, 0xAF9, 0xB3D, 0xB71, 0xB83, 0xB9C, 0xBD0, 0xC3D, 0xC5D, 0xC80, 0xCBD, 0xD3D, 0xD4E, 0xDBD, 0xE84, 0xEA5, 0xEBD, 0xEC6, 0xF00, 0x103F, 0x1061, 0x108E, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x17DC, 0x18AA, 0x1AA7, 0x1CFA, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0xA7D3, 0xA8FB, 0xA9CF, 0xAA7A, 0xAAB1, 0xAAC0, 0xAAC2, 0xFB1D, 0xFB3E, 0x10808, 0x1083C, 0x10A00, 0x10F27, 0x11075, 0x11144, 0x11147, 0x11176, 0x111DA, 0x111DC, 0x11288, 0x1133D, 0x11350, 0x1138B, 0x1138E, 0x113B7, 0x113D1, 0x113D3, 0x114C7, 0x11644, 0x116B8, 0x11909, 0x1193F, 0x11941, 0x119E1, 0x119E3, 0x11A00, 0x11A3A, 0x11A50, 0x11A9D, 0x11C40, 0x11D46, 0x11D98, 0x11F02, 0x11FB0, 0x16F50, 0x16FE3, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E14E, 0x1E5F0, 0x1E94B, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E);
    set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x370, 0x374).addRange(0x376, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x620, 0x64A).addRange(0x66E, 0x66F).addRange(0x671, 0x6D3).addRange(0x6E5, 0x6E6).addRange(0x6EE, 0x6EF).addRange(0x6FA, 0x6FC).addRange(0x712, 0x72F).addRange(0x74D, 0x7A5).addRange(0x7CA, 0x7EA).addRange(0x7F4, 0x7F5).addRange(0x800, 0x815).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88E).addRange(0x8A0, 0x8C9).addRange(0x904, 0x939).addRange(0x958, 0x961).addRange(0x971, 0x980).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E1).addRange(0x9F0, 0x9F1).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33);
    set.addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA59, 0xA5C).addRange(0xA72, 0xA74).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xAE0, 0xAE1).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB61).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xC05, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC58, 0xC5A).addRange(0xC60, 0xC61).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCDD, 0xCDE).addRange(0xCE0, 0xCE1).addRange(0xCF1, 0xCF2).addRange(0xD04, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD54, 0xD56).addRange(0xD5F, 0xD61).addRange(0xD7A, 0xD7F).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6);
    set.addRange(0xE01, 0xE30).addRange(0xE32, 0xE33).addRange(0xE40, 0xE46).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB0).addRange(0xEB2, 0xEB3).addRange(0xEC0, 0xEC4).addRange(0xEDC, 0xEDF).addRange(0xF40, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF88, 0xF8C).addRange(0x1000, 0x102A).addRange(0x1050, 0x1055).addRange(0x105A, 0x105D).addRange(0x1065, 0x1066).addRange(0x106E, 0x1070).addRange(0x1075, 0x1081).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8).addRange(0x1700, 0x1711).addRange(0x171F, 0x1731).addRange(0x1740, 0x1751).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1780, 0x17B3).addRange(0x1820, 0x1878).addRange(0x1880, 0x18A8);
    set.addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1950, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x1A00, 0x1A16).addRange(0x1A20, 0x1A54).addRange(0x1B05, 0x1B33).addRange(0x1B45, 0x1B4C).addRange(0x1B83, 0x1BA0).addRange(0x1BAE, 0x1BAF).addRange(0x1BBA, 0x1BE5).addRange(0x1C00, 0x1C23).addRange(0x1C4D, 0x1C4F).addRange(0x1C5A, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF6).addRange(0x1D00, 0x1DBF).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x2090, 0x209C).addRange(0x210A, 0x2113).addRange(0x2118, 0x211D).addRange(0x212A, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2160, 0x2188).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D80, 0x2D96);
    set.addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x3005, 0x3007).addRange(0x3021, 0x3029).addRange(0x3031, 0x3035).addRange(0x3038, 0x303C).addRange(0x3041, 0x3096).addRange(0x309B, 0x309F).addRange(0x30A1, 0x30FA).addRange(0x30FC, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA61F).addRange(0xA62A, 0xA62B).addRange(0xA640, 0xA66E).addRange(0xA67F, 0xA69D).addRange(0xA6A0, 0xA6EF).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F2, 0xA801).addRange(0xA803, 0xA805).addRange(0xA807, 0xA80A).addRange(0xA80C, 0xA822).addRange(0xA840, 0xA873).addRange(0xA882, 0xA8B3).addRange(0xA8F2, 0xA8F7).addRange(0xA8FD, 0xA8FE).addRange(0xA90A, 0xA925).addRange(0xA930, 0xA946).addRange(0xA960, 0xA97C).addRange(0xA984, 0xA9B2).addRange(0xA9E0, 0xA9E4).addRange(0xA9E6, 0xA9EF).addRange(0xA9FA, 0xA9FE).addRange(0xAA00, 0xAA28).addRange(0xAA40, 0xAA42);
    set.addRange(0xAA44, 0xAA4B).addRange(0xAA60, 0xAA76).addRange(0xAA7E, 0xAAAF).addRange(0xAAB5, 0xAAB6).addRange(0xAAB9, 0xAABD).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEA).addRange(0xAAF2, 0xAAF4).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABE2).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1F, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFB).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF66, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10140, 0x10174).addRange(0x10280, 0x1029C);
    set.addRange(0x102A0, 0x102D0).addRange(0x10300, 0x1031F).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x10375).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x103D1, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A10, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE4).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91);
    set.addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D23).addRange(0x10D4A, 0x10D65).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC4).addRange(0x10F00, 0x10F1C).addRange(0x10F30, 0x10F45).addRange(0x10F70, 0x10F81).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11003, 0x11037).addRange(0x11071, 0x11072).addRange(0x11083, 0x110AF).addRange(0x110D0, 0x110E8).addRange(0x11103, 0x11126).addRange(0x11150, 0x11172).addRange(0x11183, 0x111B2).addRange(0x111C1, 0x111C4).addRange(0x11200, 0x11211).addRange(0x11213, 0x1122B).addRange(0x1123F, 0x11240).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112DE).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1135D, 0x11361).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x11400, 0x11434).addRange(0x11447, 0x1144A).addRange(0x1145F, 0x11461).addRange(0x11480, 0x114AF).addRange(0x114C4, 0x114C5).addRange(0x11580, 0x115AE).addRange(0x115D8, 0x115DB).addRange(0x11600, 0x1162F).addRange(0x11680, 0x116AA).addRange(0x11700, 0x1171A).addRange(0x11740, 0x11746).addRange(0x11800, 0x1182B);
    set.addRange(0x118A0, 0x118DF).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x1192F).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D0).addRange(0x11A0B, 0x11A32).addRange(0x11A5C, 0x11A89).addRange(0x11AB0, 0x11AF8).addRange(0x11BC0, 0x11BE0).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C2E).addRange(0x11C72, 0x11C8F).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D30).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D89).addRange(0x11EE0, 0x11EF2).addRange(0x11F04, 0x11F10).addRange(0x11F12, 0x11F33).addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1611D).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A70, 0x16ABE).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B40, 0x16B43).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D6C).addRange(0x16E40, 0x16E7F).addRange(0x16F00, 0x16F4A).addRange(0x16F93, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x17000, 0x187F7).addRange(0x18800, 0x18CD5).addRange(0x18CFF, 0x18D08).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE);
    set.addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E137, 0x1E13D).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E4D0, 0x1E4EB).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E900, 0x1E943).addRange(0x1EE00, 0x1EE03);
    set.addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF);
    ID_Start.characters = set;
    return ID_Start;
  }

var Ideographic = {};

var hasRequiredIdeographic;
  function requireIdeographic() {
    if (hasRequiredIdeographic) return Ideographic;
    hasRequiredIdeographic = 1;
    var set = regenerateExports(0x16FE4);
    set.addRange(0x3006, 0x3007).addRange(0x3021, 0x3029).addRange(0x3038, 0x303A).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0x9FFF).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0x17000, 0x187F7).addRange(0x18800, 0x18CD5).addRange(0x18CFF, 0x18D08).addRange(0x1B170, 0x1B2FB).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF);
    Ideographic.characters = set;
    return Ideographic;
  }

var IDS_Binary_Operator = {};

var hasRequiredIDS_Binary_Operator;
  function requireIDS_Binary_Operator() {
    if (hasRequiredIDS_Binary_Operator) return IDS_Binary_Operator;
    hasRequiredIDS_Binary_Operator = 1;
    var set = regenerateExports(0x31EF);
    set.addRange(0x2FF0, 0x2FF1).addRange(0x2FF4, 0x2FFD);
    IDS_Binary_Operator.characters = set;
    return IDS_Binary_Operator;
  }

var IDS_Trinary_Operator = {};

var hasRequiredIDS_Trinary_Operator;
  function requireIDS_Trinary_Operator() {
    if (hasRequiredIDS_Trinary_Operator) return IDS_Trinary_Operator;
    hasRequiredIDS_Trinary_Operator = 1;
    var set = regenerateExports();
    set.addRange(0x2FF2, 0x2FF3);
    IDS_Trinary_Operator.characters = set;
    return IDS_Trinary_Operator;
  }

var Join_Control = {};

var hasRequiredJoin_Control;
  function requireJoin_Control() {
    if (hasRequiredJoin_Control) return Join_Control;
    hasRequiredJoin_Control = 1;
    var set = regenerateExports();
    set.addRange(0x200C, 0x200D);
    Join_Control.characters = set;
    return Join_Control;
  }

var Logical_Order_Exception = {};

var hasRequiredLogical_Order_Exception;
  function requireLogical_Order_Exception() {
    if (hasRequiredLogical_Order_Exception) return Logical_Order_Exception;
    hasRequiredLogical_Order_Exception = 1;
    var set = regenerateExports(0x19BA, 0xAAB9);
    set.addRange(0xE40, 0xE44).addRange(0xEC0, 0xEC4).addRange(0x19B5, 0x19B7).addRange(0xAAB5, 0xAAB6).addRange(0xAABB, 0xAABC);
    Logical_Order_Exception.characters = set;
    return Logical_Order_Exception;
  }

var Lowercase = {};

var hasRequiredLowercase;
  function requireLowercase() {
    if (hasRequiredLowercase) return Lowercase;
    hasRequiredLowercase = 1;
    var set = regenerateExports(0xAA, 0xB5, 0xBA, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x183, 0x185, 0x188, 0x192, 0x195, 0x19E, 0x1A1, 0x1A3, 0x1A5, 0x1A8, 0x1AD, 0x1B0, 0x1B4, 0x1B6, 0x1C6, 0x1C9, 0x1CC, 0x1CE, 0x1D0, 0x1D2, 0x1D4, 0x1D6, 0x1D8, 0x1DA, 0x1DF, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x1E9, 0x1EB, 0x1ED, 0x1F3, 0x1F5, 0x1F9, 0x1FB, 0x1FD, 0x1FF, 0x201, 0x203, 0x205, 0x207, 0x209, 0x20B, 0x20D, 0x20F, 0x211, 0x213, 0x215, 0x217, 0x219, 0x21B, 0x21D, 0x21F, 0x221, 0x223, 0x225, 0x227, 0x229, 0x22B, 0x22D, 0x22F, 0x231, 0x23C, 0x242, 0x247, 0x249, 0x24B, 0x24D, 0x345, 0x371, 0x373, 0x377, 0x390, 0x3D9, 0x3DB, 0x3DD, 0x3DF, 0x3E1, 0x3E3, 0x3E5, 0x3E7, 0x3E9, 0x3EB, 0x3ED, 0x3F5, 0x3F8, 0x461, 0x463, 0x465, 0x467, 0x469, 0x46B, 0x46D, 0x46F, 0x471, 0x473, 0x475, 0x477, 0x479, 0x47B, 0x47D, 0x47F, 0x481, 0x48B, 0x48D, 0x48F, 0x491, 0x493, 0x495, 0x497, 0x499, 0x49B, 0x49D, 0x49F, 0x4A1, 0x4A3, 0x4A5, 0x4A7, 0x4A9, 0x4AB, 0x4AD, 0x4AF, 0x4B1, 0x4B3, 0x4B5, 0x4B7, 0x4B9, 0x4BB, 0x4BD, 0x4BF, 0x4C2, 0x4C4, 0x4C6, 0x4C8, 0x4CA, 0x4CC, 0x4D1, 0x4D3, 0x4D5, 0x4D7, 0x4D9, 0x4DB, 0x4DD, 0x4DF, 0x4E1, 0x4E3, 0x4E5, 0x4E7, 0x4E9, 0x4EB, 0x4ED, 0x4EF, 0x4F1, 0x4F3, 0x4F5, 0x4F7, 0x4F9, 0x4FB, 0x4FD, 0x4FF, 0x501, 0x503, 0x505, 0x507, 0x509, 0x50B, 0x50D, 0x50F, 0x511, 0x513, 0x515, 0x517, 0x519, 0x51B, 0x51D, 0x51F, 0x521, 0x523, 0x525, 0x527, 0x529, 0x52B, 0x52D, 0x52F, 0x1C8A, 0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1E9F, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9, 0x1EFB, 0x1EFD, 0x1FBE, 0x2071, 0x207F, 0x210A, 0x2113, 0x212F, 0x2134, 0x2139, 0x214E, 0x2184, 0x2C61, 0x2C68, 0x2C6A, 0x2C6C, 0x2C71, 0x2C81, 0x2C83, 0x2C85, 0x2C87, 0x2C89, 0x2C8B, 0x2C8D, 0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1, 0x2CA3, 0x2CA5, 0x2CA7, 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5, 0x2CB7, 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, 0x2CC9, 0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, 0x2CD9, 0x2CDB, 0x2CDD, 0x2CDF, 0x2CE1, 0x2CEC, 0x2CEE, 0x2CF3, 0x2D27, 0x2D2D, 0xA641, 0xA643, 0xA645, 0xA647, 0xA649, 0xA64B, 0xA64D, 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B, 0xA65D, 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA66D, 0xA681, 0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, 0xA691, 0xA693, 0xA695, 0xA697, 0xA699, 0xA723, 0xA725, 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA733, 0xA735, 0xA737, 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745, 0xA747, 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, 0xA759, 0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D, 0xA77A, 0xA77C, 0xA77F, 0xA781, 0xA783, 0xA785, 0xA787, 0xA78C, 0xA78E, 0xA791, 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, 0xA7A7, 0xA7A9, 0xA7AF, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3, 0xA7C8, 0xA7CA, 0xA7CD, 0xA7D1, 0xA7D3, 0xA7D5, 0xA7D7, 0xA7D9, 0xA7DB, 0xA7F6, 0x10780, 0x1D4BB, 0x1D7CB);
    set.addRange(0x61, 0x7A).addRange(0xDF, 0xF6).addRange(0xF8, 0xFF).addRange(0x137, 0x138).addRange(0x148, 0x149).addRange(0x17E, 0x180).addRange(0x18C, 0x18D).addRange(0x199, 0x19B).addRange(0x1AA, 0x1AB).addRange(0x1B9, 0x1BA).addRange(0x1BD, 0x1BF).addRange(0x1DC, 0x1DD).addRange(0x1EF, 0x1F0).addRange(0x233, 0x239).addRange(0x23F, 0x240).addRange(0x24F, 0x293).addRange(0x295, 0x2B8).addRange(0x2C0, 0x2C1).addRange(0x2E0, 0x2E4).addRange(0x37A, 0x37D).addRange(0x3AC, 0x3CE).addRange(0x3D0, 0x3D1).addRange(0x3D5, 0x3D7).addRange(0x3EF, 0x3F3).addRange(0x3FB, 0x3FC).addRange(0x430, 0x45F).addRange(0x4CE, 0x4CF).addRange(0x560, 0x588).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x10FF).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C88).addRange(0x1D00, 0x1DBF).addRange(0x1E95, 0x1E9D).addRange(0x1EFF, 0x1F07).addRange(0x1F10, 0x1F15).addRange(0x1F20, 0x1F27).addRange(0x1F30, 0x1F37).addRange(0x1F40, 0x1F45).addRange(0x1F50, 0x1F57).addRange(0x1F60, 0x1F67).addRange(0x1F70, 0x1F7D).addRange(0x1F80, 0x1F87).addRange(0x1F90, 0x1F97).addRange(0x1FA0, 0x1FA7).addRange(0x1FB0, 0x1FB4).addRange(0x1FB6, 0x1FB7).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FC7).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FD7);
    set.addRange(0x1FE0, 0x1FE7).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FF7).addRange(0x2090, 0x209C).addRange(0x210E, 0x210F).addRange(0x213C, 0x213D).addRange(0x2146, 0x2149).addRange(0x2170, 0x217F).addRange(0x24D0, 0x24E9).addRange(0x2C30, 0x2C5F).addRange(0x2C65, 0x2C66).addRange(0x2C73, 0x2C74).addRange(0x2C76, 0x2C7D).addRange(0x2CE3, 0x2CE4).addRange(0x2D00, 0x2D25).addRange(0xA69B, 0xA69D).addRange(0xA72F, 0xA731).addRange(0xA76F, 0xA778).addRange(0xA793, 0xA795).addRange(0xA7F2, 0xA7F4).addRange(0xA7F8, 0xA7FA).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF41, 0xFF5A).addRange(0x10428, 0x1044F).addRange(0x104D8, 0x104FB).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10783, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10CC0, 0x10CF2).addRange(0x10D70, 0x10D85).addRange(0x118C0, 0x118DF).addRange(0x16E60, 0x16E7F).addRange(0x1D41A, 0x1D433).addRange(0x1D44E, 0x1D454).addRange(0x1D456, 0x1D467).addRange(0x1D482, 0x1D49B).addRange(0x1D4B6, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D4CF).addRange(0x1D4EA, 0x1D503).addRange(0x1D51E, 0x1D537).addRange(0x1D552, 0x1D56B).addRange(0x1D586, 0x1D59F);
    set.addRange(0x1D5BA, 0x1D5D3).addRange(0x1D5EE, 0x1D607).addRange(0x1D622, 0x1D63B).addRange(0x1D656, 0x1D66F).addRange(0x1D68A, 0x1D6A5).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6E1).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D71B).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D755).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D78F).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7C9).addRange(0x1DF00, 0x1DF09).addRange(0x1DF0B, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E030, 0x1E06D).addRange(0x1E922, 0x1E943);
    Lowercase.characters = set;
    return Lowercase;
  }

var _Math = {};

var hasRequired_Math;
  function require_Math() {
    if (hasRequired_Math) return _Math;
    hasRequired_Math = 1;
    var set = regenerateExports(0x2B, 0x5E, 0x7C, 0x7E, 0xAC, 0xB1, 0xD7, 0xF7, 0x3D5, 0x2016, 0x2040, 0x2044, 0x2052, 0x20E1, 0x2102, 0x2107, 0x2115, 0x2124, 0x214B, 0x21DD, 0x237C, 0x23B7, 0x23D0, 0x25E2, 0x25E4, 0x2640, 0x2642, 0xFB29, 0xFE68, 0xFF0B, 0xFF3C, 0xFF3E, 0xFF5C, 0xFF5E, 0xFFE2, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E);
    set.addRange(0x3C, 0x3E).addRange(0x3D0, 0x3D2).addRange(0x3F0, 0x3F1).addRange(0x3F4, 0x3F6).addRange(0x606, 0x608).addRange(0x2032, 0x2034).addRange(0x2061, 0x2064).addRange(0x207A, 0x207E).addRange(0x208A, 0x208E).addRange(0x20D0, 0x20DC).addRange(0x20E5, 0x20E6).addRange(0x20EB, 0x20EF).addRange(0x210A, 0x2113).addRange(0x2118, 0x211D).addRange(0x2128, 0x2129).addRange(0x212C, 0x212D).addRange(0x212F, 0x2131).addRange(0x2133, 0x2138).addRange(0x213C, 0x2149).addRange(0x2190, 0x21A7).addRange(0x21A9, 0x21AE).addRange(0x21B0, 0x21B1).addRange(0x21B6, 0x21B7).addRange(0x21BC, 0x21DB).addRange(0x21E4, 0x21E5).addRange(0x21F4, 0x22FF).addRange(0x2308, 0x230B).addRange(0x2320, 0x2321).addRange(0x239B, 0x23B5).addRange(0x23DC, 0x23E2).addRange(0x25A0, 0x25A1).addRange(0x25AE, 0x25B7).addRange(0x25BC, 0x25C1).addRange(0x25C6, 0x25C7).addRange(0x25CA, 0x25CB).addRange(0x25CF, 0x25D3).addRange(0x25E7, 0x25EC).addRange(0x25F8, 0x25FF).addRange(0x2605, 0x2606).addRange(0x2660, 0x2663).addRange(0x266D, 0x266F).addRange(0x27C0, 0x27FF).addRange(0x2900, 0x2AFF).addRange(0x2B30, 0x2B44).addRange(0x2B47, 0x2B4C).addRange(0xFE61, 0xFE66).addRange(0xFF1C, 0xFF1E).addRange(0xFFE9, 0xFFEC).addRange(0x10D8E, 0x10D8F).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C);
    set.addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D7CB).addRange(0x1D7CE, 0x1D7FF).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1EEF0, 0x1EEF1);
    _Math.characters = set;
    return _Math;
  }

var Noncharacter_Code_Point = {};

var hasRequiredNoncharacter_Code_Point;
  function requireNoncharacter_Code_Point() {
    if (hasRequiredNoncharacter_Code_Point) return Noncharacter_Code_Point;
    hasRequiredNoncharacter_Code_Point = 1;
    var set = regenerateExports();
    set.addRange(0xFDD0, 0xFDEF).addRange(0xFFFE, 0xFFFF).addRange(0x1FFFE, 0x1FFFF).addRange(0x2FFFE, 0x2FFFF).addRange(0x3FFFE, 0x3FFFF).addRange(0x4FFFE, 0x4FFFF).addRange(0x5FFFE, 0x5FFFF).addRange(0x6FFFE, 0x6FFFF).addRange(0x7FFFE, 0x7FFFF).addRange(0x8FFFE, 0x8FFFF).addRange(0x9FFFE, 0x9FFFF).addRange(0xAFFFE, 0xAFFFF).addRange(0xBFFFE, 0xBFFFF).addRange(0xCFFFE, 0xCFFFF).addRange(0xDFFFE, 0xDFFFF).addRange(0xEFFFE, 0xEFFFF).addRange(0xFFFFE, 0xFFFFF).addRange(0x10FFFE, 0x10FFFF);
    Noncharacter_Code_Point.characters = set;
    return Noncharacter_Code_Point;
  }

var Pattern_Syntax = {};

var hasRequiredPattern_Syntax;
  function requirePattern_Syntax() {
    if (hasRequiredPattern_Syntax) return Pattern_Syntax;
    hasRequiredPattern_Syntax = 1;
    var set = regenerateExports(0x60, 0xA9, 0xAE, 0xB6, 0xBB, 0xBF, 0xD7, 0xF7, 0x3030);
    set.addRange(0x21, 0x2F).addRange(0x3A, 0x40).addRange(0x5B, 0x5E).addRange(0x7B, 0x7E).addRange(0xA1, 0xA7).addRange(0xAB, 0xAC).addRange(0xB0, 0xB1).addRange(0x2010, 0x2027).addRange(0x2030, 0x203E).addRange(0x2041, 0x2053).addRange(0x2055, 0x205E).addRange(0x2190, 0x245F).addRange(0x2500, 0x2775).addRange(0x2794, 0x2BFF).addRange(0x2E00, 0x2E7F).addRange(0x3001, 0x3003).addRange(0x3008, 0x3020).addRange(0xFD3E, 0xFD3F).addRange(0xFE45, 0xFE46);
    Pattern_Syntax.characters = set;
    return Pattern_Syntax;
  }

var Pattern_White_Space = {};

var hasRequiredPattern_White_Space;
  function requirePattern_White_Space() {
    if (hasRequiredPattern_White_Space) return Pattern_White_Space;
    hasRequiredPattern_White_Space = 1;
    var set = regenerateExports(0x20, 0x85);
    set.addRange(0x9, 0xD).addRange(0x200E, 0x200F).addRange(0x2028, 0x2029);
    Pattern_White_Space.characters = set;
    return Pattern_White_Space;
  }

var Quotation_Mark = {};

var hasRequiredQuotation_Mark;
  function requireQuotation_Mark() {
    if (hasRequiredQuotation_Mark) return Quotation_Mark;
    hasRequiredQuotation_Mark = 1;
    var set = regenerateExports(0x22, 0x27, 0xAB, 0xBB, 0x2E42, 0xFF02, 0xFF07);
    set.addRange(0x2018, 0x201F).addRange(0x2039, 0x203A).addRange(0x300C, 0x300F).addRange(0x301D, 0x301F).addRange(0xFE41, 0xFE44).addRange(0xFF62, 0xFF63);
    Quotation_Mark.characters = set;
    return Quotation_Mark;
  }

var Radical = {};

var hasRequiredRadical;
  function requireRadical() {
    if (hasRequiredRadical) return Radical;
    hasRequiredRadical = 1;
    var set = regenerateExports();
    set.addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5);
    Radical.characters = set;
    return Radical;
  }

var Regional_Indicator = {};

var hasRequiredRegional_Indicator;
  function requireRegional_Indicator() {
    if (hasRequiredRegional_Indicator) return Regional_Indicator;
    hasRequiredRegional_Indicator = 1;
    var set = regenerateExports();
    set.addRange(0x1F1E6, 0x1F1FF);
    Regional_Indicator.characters = set;
    return Regional_Indicator;
  }

var Sentence_Terminal = {};

var hasRequiredSentence_Terminal;
  function requireSentence_Terminal() {
    if (hasRequiredSentence_Terminal) return Sentence_Terminal;
    hasRequiredSentence_Terminal = 1;
    var set = regenerateExports(0x21, 0x2E, 0x3F, 0x589, 0x6D4, 0x7F9, 0x837, 0x839, 0x1362, 0x166E, 0x1803, 0x1809, 0x2024, 0x2E2E, 0x2E3C, 0x3002, 0xA4FF, 0xA6F3, 0xA6F7, 0xA92F, 0xABEB, 0xFE12, 0xFE52, 0xFF01, 0xFF0E, 0xFF1F, 0xFF61, 0x111CD, 0x112A9, 0x11944, 0x11946, 0x16AF5, 0x16B44, 0x16E98, 0x1BC9F, 0x1DA88);
    set.addRange(0x61D, 0x61F).addRange(0x700, 0x702).addRange(0x83D, 0x83E).addRange(0x964, 0x965).addRange(0x104A, 0x104B).addRange(0x1367, 0x1368).addRange(0x1735, 0x1736).addRange(0x17D4, 0x17D5).addRange(0x1944, 0x1945).addRange(0x1AA8, 0x1AAB).addRange(0x1B4E, 0x1B4F).addRange(0x1B5A, 0x1B5B).addRange(0x1B5E, 0x1B5F).addRange(0x1B7D, 0x1B7F).addRange(0x1C3B, 0x1C3C).addRange(0x1C7E, 0x1C7F).addRange(0x203C, 0x203D).addRange(0x2047, 0x2049).addRange(0x2CF9, 0x2CFB).addRange(0x2E53, 0x2E54).addRange(0xA60E, 0xA60F).addRange(0xA876, 0xA877).addRange(0xA8CE, 0xA8CF).addRange(0xA9C8, 0xA9C9).addRange(0xAA5D, 0xAA5F).addRange(0xAAF0, 0xAAF1).addRange(0xFE15, 0xFE16).addRange(0xFE56, 0xFE57).addRange(0x10A56, 0x10A57).addRange(0x10F55, 0x10F59).addRange(0x10F86, 0x10F89).addRange(0x11047, 0x11048).addRange(0x110BE, 0x110C1).addRange(0x11141, 0x11143).addRange(0x111C5, 0x111C6).addRange(0x111DE, 0x111DF).addRange(0x11238, 0x11239).addRange(0x1123B, 0x1123C).addRange(0x113D4, 0x113D5).addRange(0x1144B, 0x1144C).addRange(0x115C2, 0x115C3).addRange(0x115C9, 0x115D7).addRange(0x11641, 0x11642).addRange(0x1173C, 0x1173E).addRange(0x11A42, 0x11A43).addRange(0x11A9B, 0x11A9C).addRange(0x11C41, 0x11C42).addRange(0x11EF7, 0x11EF8).addRange(0x11F43, 0x11F44).addRange(0x16A6E, 0x16A6F).addRange(0x16B37, 0x16B38);
    set.addRange(0x16D6E, 0x16D6F);
    Sentence_Terminal.characters = set;
    return Sentence_Terminal;
  }

var Soft_Dotted = {};

var hasRequiredSoft_Dotted;
  function requireSoft_Dotted() {
    if (hasRequiredSoft_Dotted) return Soft_Dotted;
    hasRequiredSoft_Dotted = 1;
    var set = regenerateExports(0x12F, 0x249, 0x268, 0x29D, 0x2B2, 0x3F3, 0x456, 0x458, 0x1D62, 0x1D96, 0x1DA4, 0x1DA8, 0x1E2D, 0x1ECB, 0x2071, 0x2C7C, 0x1DF1A, 0x1E068);
    set.addRange(0x69, 0x6A).addRange(0x2148, 0x2149).addRange(0x1D422, 0x1D423).addRange(0x1D456, 0x1D457).addRange(0x1D48A, 0x1D48B).addRange(0x1D4BE, 0x1D4BF).addRange(0x1D4F2, 0x1D4F3).addRange(0x1D526, 0x1D527).addRange(0x1D55A, 0x1D55B).addRange(0x1D58E, 0x1D58F).addRange(0x1D5C2, 0x1D5C3).addRange(0x1D5F6, 0x1D5F7).addRange(0x1D62A, 0x1D62B).addRange(0x1D65E, 0x1D65F).addRange(0x1D692, 0x1D693).addRange(0x1E04C, 0x1E04D);
    Soft_Dotted.characters = set;
    return Soft_Dotted;
  }

var Terminal_Punctuation = {};

var hasRequiredTerminal_Punctuation;
  function requireTerminal_Punctuation() {
    if (hasRequiredTerminal_Punctuation) return Terminal_Punctuation;
    hasRequiredTerminal_Punctuation = 1;
    var set = regenerateExports(0x21, 0x2C, 0x2E, 0x3F, 0x37E, 0x387, 0x589, 0x5C3, 0x60C, 0x61B, 0x6D4, 0x70C, 0x85E, 0xF08, 0x166E, 0x17DA, 0x2024, 0x2E2E, 0x2E3C, 0x2E41, 0x2E4C, 0xA92F, 0xAADF, 0xABEB, 0xFE12, 0xFF01, 0xFF0C, 0xFF0E, 0xFF1F, 0xFF61, 0xFF64, 0x1039F, 0x103D0, 0x10857, 0x1091F, 0x111CD, 0x112A9, 0x11944, 0x11946, 0x11C71, 0x16AF5, 0x16B44, 0x1BC9F);
    set.addRange(0x3A, 0x3B).addRange(0x61D, 0x61F).addRange(0x700, 0x70A).addRange(0x7F8, 0x7F9).addRange(0x830, 0x835).addRange(0x837, 0x83E).addRange(0x964, 0x965).addRange(0xE5A, 0xE5B).addRange(0xF0D, 0xF12).addRange(0x104A, 0x104B).addRange(0x1361, 0x1368).addRange(0x16EB, 0x16ED).addRange(0x1735, 0x1736).addRange(0x17D4, 0x17D6).addRange(0x1802, 0x1805).addRange(0x1808, 0x1809).addRange(0x1944, 0x1945).addRange(0x1AA8, 0x1AAB).addRange(0x1B4E, 0x1B4F).addRange(0x1B5A, 0x1B5B).addRange(0x1B5D, 0x1B5F).addRange(0x1B7D, 0x1B7F).addRange(0x1C3B, 0x1C3F).addRange(0x1C7E, 0x1C7F).addRange(0x203C, 0x203D).addRange(0x2047, 0x2049).addRange(0x2CF9, 0x2CFB).addRange(0x2E4E, 0x2E4F).addRange(0x2E53, 0x2E54).addRange(0x3001, 0x3002).addRange(0xA4FE, 0xA4FF).addRange(0xA60D, 0xA60F).addRange(0xA6F3, 0xA6F7).addRange(0xA876, 0xA877).addRange(0xA8CE, 0xA8CF).addRange(0xA9C7, 0xA9C9).addRange(0xAA5D, 0xAA5F).addRange(0xAAF0, 0xAAF1).addRange(0xFE15, 0xFE16).addRange(0xFE50, 0xFE52).addRange(0xFE54, 0xFE57).addRange(0xFF1A, 0xFF1B).addRange(0x10A56, 0x10A57).addRange(0x10AF0, 0x10AF5).addRange(0x10B3A, 0x10B3F).addRange(0x10B99, 0x10B9C).addRange(0x10F55, 0x10F59).addRange(0x10F86, 0x10F89).addRange(0x11047, 0x1104D).addRange(0x110BE, 0x110C1).addRange(0x11141, 0x11143);
    set.addRange(0x111C5, 0x111C6).addRange(0x111DE, 0x111DF).addRange(0x11238, 0x1123C).addRange(0x113D4, 0x113D5).addRange(0x1144B, 0x1144D).addRange(0x1145A, 0x1145B).addRange(0x115C2, 0x115C5).addRange(0x115C9, 0x115D7).addRange(0x11641, 0x11642).addRange(0x1173C, 0x1173E).addRange(0x11A42, 0x11A43).addRange(0x11A9B, 0x11A9C).addRange(0x11AA1, 0x11AA2).addRange(0x11C41, 0x11C43).addRange(0x11EF7, 0x11EF8).addRange(0x11F43, 0x11F44).addRange(0x12470, 0x12474).addRange(0x16A6E, 0x16A6F).addRange(0x16B37, 0x16B39).addRange(0x16D6E, 0x16D6F).addRange(0x16E97, 0x16E98).addRange(0x1DA87, 0x1DA8A);
    Terminal_Punctuation.characters = set;
    return Terminal_Punctuation;
  }

var Unified_Ideograph = {};

var hasRequiredUnified_Ideograph;
  function requireUnified_Ideograph() {
    if (hasRequiredUnified_Ideograph) return Unified_Ideograph;
    hasRequiredUnified_Ideograph = 1;
    var set = regenerateExports(0xFA11, 0xFA1F, 0xFA21);
    set.addRange(0x3400, 0x4DBF).addRange(0x4E00, 0x9FFF).addRange(0xFA0E, 0xFA0F).addRange(0xFA13, 0xFA14).addRange(0xFA23, 0xFA24).addRange(0xFA27, 0xFA29).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF);
    Unified_Ideograph.characters = set;
    return Unified_Ideograph;
  }

var Uppercase = {};

var hasRequiredUppercase;
  function requireUppercase() {
    if (hasRequiredUppercase) return Uppercase;
    hasRequiredUppercase = 1;
    var set = regenerateExports(0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14A, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x17B, 0x17D, 0x184, 0x1A2, 0x1A4, 0x1A9, 0x1AC, 0x1B5, 0x1BC, 0x1C4, 0x1C7, 0x1CA, 0x1CD, 0x1CF, 0x1D1, 0x1D3, 0x1D5, 0x1D7, 0x1D9, 0x1DB, 0x1DE, 0x1E0, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x1EA, 0x1EC, 0x1EE, 0x1F1, 0x1F4, 0x1FA, 0x1FC, 0x1FE, 0x200, 0x202, 0x204, 0x206, 0x208, 0x20A, 0x20C, 0x20E, 0x210, 0x212, 0x214, 0x216, 0x218, 0x21A, 0x21C, 0x21E, 0x220, 0x222, 0x224, 0x226, 0x228, 0x22A, 0x22C, 0x22E, 0x230, 0x232, 0x241, 0x248, 0x24A, 0x24C, 0x24E, 0x370, 0x372, 0x376, 0x37F, 0x386, 0x38C, 0x3CF, 0x3D8, 0x3DA, 0x3DC, 0x3DE, 0x3E0, 0x3E2, 0x3E4, 0x3E6, 0x3E8, 0x3EA, 0x3EC, 0x3EE, 0x3F4, 0x3F7, 0x460, 0x462, 0x464, 0x466, 0x468, 0x46A, 0x46C, 0x46E, 0x470, 0x472, 0x474, 0x476, 0x478, 0x47A, 0x47C, 0x47E, 0x480, 0x48A, 0x48C, 0x48E, 0x490, 0x492, 0x494, 0x496, 0x498, 0x49A, 0x49C, 0x49E, 0x4A0, 0x4A2, 0x4A4, 0x4A6, 0x4A8, 0x4AA, 0x4AC, 0x4AE, 0x4B0, 0x4B2, 0x4B4, 0x4B6, 0x4B8, 0x4BA, 0x4BC, 0x4BE, 0x4C3, 0x4C5, 0x4C7, 0x4C9, 0x4CB, 0x4CD, 0x4D0, 0x4D2, 0x4D4, 0x4D6, 0x4D8, 0x4DA, 0x4DC, 0x4DE, 0x4E0, 0x4E2, 0x4E4, 0x4E6, 0x4E8, 0x4EA, 0x4EC, 0x4EE, 0x4F0, 0x4F2, 0x4F4, 0x4F6, 0x4F8, 0x4FA, 0x4FC, 0x4FE, 0x500, 0x502, 0x504, 0x506, 0x508, 0x50A, 0x50C, 0x50E, 0x510, 0x512, 0x514, 0x516, 0x518, 0x51A, 0x51C, 0x51E, 0x520, 0x522, 0x524, 0x526, 0x528, 0x52A, 0x52C, 0x52E, 0x10C7, 0x10CD, 0x1C89, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1E9E, 0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F59, 0x1F5B, 0x1F5D, 0x1F5F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2145, 0x2183, 0x2C60, 0x2C67, 0x2C69, 0x2C6B, 0x2C72, 0x2C75, 0x2C82, 0x2C84, 0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98, 0x2C9A, 0x2C9C, 0x2C9E, 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC, 0x2CAE, 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, 0x2CC0, 0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, 0x2CD0, 0x2CD2, 0x2CD4, 0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2, 0xA640, 0xA642, 0xA644, 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652, 0xA654, 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, 0xA666, 0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, 0xA688, 0xA68A, 0xA68C, 0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726, 0xA728, 0xA72A, 0xA72C, 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C, 0xA73E, 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, 0xA750, 0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, 0xA760, 0xA762, 0xA764, 0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA779, 0xA77B, 0xA780, 0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A, 0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7B6, 0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C9, 0xA7D0, 0xA7D6, 0xA7D8, 0xA7DA, 0xA7DC, 0xA7F5, 0x1D49C, 0x1D4A2, 0x1D546, 0x1D7CA);
    set.addRange(0x41, 0x5A).addRange(0xC0, 0xD6).addRange(0xD8, 0xDE).addRange(0x178, 0x179).addRange(0x181, 0x182).addRange(0x186, 0x187).addRange(0x189, 0x18B).addRange(0x18E, 0x191).addRange(0x193, 0x194).addRange(0x196, 0x198).addRange(0x19C, 0x19D).addRange(0x19F, 0x1A0).addRange(0x1A6, 0x1A7).addRange(0x1AE, 0x1AF).addRange(0x1B1, 0x1B3).addRange(0x1B7, 0x1B8).addRange(0x1F6, 0x1F8).addRange(0x23A, 0x23B).addRange(0x23D, 0x23E).addRange(0x243, 0x246).addRange(0x388, 0x38A).addRange(0x38E, 0x38F).addRange(0x391, 0x3A1).addRange(0x3A3, 0x3AB).addRange(0x3D2, 0x3D4).addRange(0x3F9, 0x3FA).addRange(0x3FD, 0x42F).addRange(0x4C0, 0x4C1).addRange(0x531, 0x556).addRange(0x10A0, 0x10C5).addRange(0x13A0, 0x13F5).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1F08, 0x1F0F).addRange(0x1F18, 0x1F1D).addRange(0x1F28, 0x1F2F).addRange(0x1F38, 0x1F3F).addRange(0x1F48, 0x1F4D).addRange(0x1F68, 0x1F6F).addRange(0x1FB8, 0x1FBB).addRange(0x1FC8, 0x1FCB).addRange(0x1FD8, 0x1FDB).addRange(0x1FE8, 0x1FEC).addRange(0x1FF8, 0x1FFB).addRange(0x210B, 0x210D).addRange(0x2110, 0x2112).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x2130, 0x2133).addRange(0x213E, 0x213F).addRange(0x2160, 0x216F);
    set.addRange(0x24B6, 0x24CF).addRange(0x2C00, 0x2C2F).addRange(0x2C62, 0x2C64).addRange(0x2C6D, 0x2C70).addRange(0x2C7E, 0x2C80).addRange(0xA77D, 0xA77E).addRange(0xA7AA, 0xA7AE).addRange(0xA7B0, 0xA7B4).addRange(0xA7C4, 0xA7C7).addRange(0xA7CB, 0xA7CC).addRange(0xFF21, 0xFF3A).addRange(0x10400, 0x10427).addRange(0x104B0, 0x104D3).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10C80, 0x10CB2).addRange(0x10D50, 0x10D65).addRange(0x118A0, 0x118BF).addRange(0x16E40, 0x16E5F).addRange(0x1D400, 0x1D419).addRange(0x1D434, 0x1D44D).addRange(0x1D468, 0x1D481).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B5).addRange(0x1D4D0, 0x1D4E9).addRange(0x1D504, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D538, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D56C, 0x1D585).addRange(0x1D5A0, 0x1D5B9).addRange(0x1D5D4, 0x1D5ED).addRange(0x1D608, 0x1D621).addRange(0x1D63C, 0x1D655).addRange(0x1D670, 0x1D689).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6E2, 0x1D6FA).addRange(0x1D71C, 0x1D734).addRange(0x1D756, 0x1D76E).addRange(0x1D790, 0x1D7A8).addRange(0x1E900, 0x1E921).addRange(0x1F130, 0x1F149).addRange(0x1F150, 0x1F169);
    set.addRange(0x1F170, 0x1F189);
    Uppercase.characters = set;
    return Uppercase;
  }

var Variation_Selector = {};

var hasRequiredVariation_Selector;
  function requireVariation_Selector() {
    if (hasRequiredVariation_Selector) return Variation_Selector;
    hasRequiredVariation_Selector = 1;
    var set = regenerateExports(0x180F);
    set.addRange(0x180B, 0x180D).addRange(0xFE00, 0xFE0F).addRange(0xE0100, 0xE01EF);
    Variation_Selector.characters = set;
    return Variation_Selector;
  }

var White_Space = {};

var hasRequiredWhite_Space;
  function requireWhite_Space() {
    if (hasRequiredWhite_Space) return White_Space;
    hasRequiredWhite_Space = 1;
    var set = regenerateExports(0x20, 0x85, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000);
    set.addRange(0x9, 0xD).addRange(0x2000, 0x200A).addRange(0x2028, 0x2029);
    White_Space.characters = set;
    return White_Space;
  }

var XID_Continue = {};

var hasRequiredXID_Continue;
  function requireXID_Continue() {
    if (hasRequiredXID_Continue) return XID_Continue;
    hasRequiredXID_Continue = 1;
    var set = regenerateExports(0x5F, 0xAA, 0xB5, 0xB7, 0xBA, 0x2EC, 0x2EE, 0x37F, 0x38C, 0x559, 0x5BF, 0x5C7, 0x6FF, 0x7FA, 0x7FD, 0x9B2, 0x9D7, 0x9FC, 0x9FE, 0xA3C, 0xA51, 0xA5E, 0xAD0, 0xB71, 0xB9C, 0xBD0, 0xBD7, 0xC5D, 0xDBD, 0xDCA, 0xDD6, 0xE84, 0xEA5, 0xEC6, 0xF00, 0xF35, 0xF37, 0xF39, 0xFC6, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x1AA7, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2054, 0x2071, 0x207F, 0x20E1, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0xA7D3, 0xA82C, 0xA8FB, 0xFB3E, 0xFE71, 0xFE73, 0xFE77, 0xFE79, 0xFE7B, 0xFE7D, 0xFF3F, 0x101FD, 0x102E0, 0x10808, 0x1083C, 0x10A3F, 0x10F27, 0x110C2, 0x11176, 0x111DC, 0x11288, 0x11350, 0x11357, 0x1138B, 0x1138E, 0x113C2, 0x113C5, 0x114C7, 0x11644, 0x11909, 0x11A47, 0x11A9D, 0x11D3A, 0x11FB0, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E14E, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E);
    set.addRange(0x30, 0x39).addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x300, 0x374).addRange(0x376, 0x377).addRange(0x37B, 0x37D).addRange(0x386, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x483, 0x487).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x610, 0x61A).addRange(0x620, 0x669).addRange(0x66E, 0x6D3).addRange(0x6D5, 0x6DC).addRange(0x6DF, 0x6E8).addRange(0x6EA, 0x6FC).addRange(0x710, 0x74A).addRange(0x74D, 0x7B1).addRange(0x7C0, 0x7F5).addRange(0x800, 0x82D).addRange(0x840, 0x85B).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88E).addRange(0x897, 0x8E1).addRange(0x8E3, 0x963).addRange(0x966, 0x96F).addRange(0x971, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BC, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CE).addRange(0x9DC, 0x9DD);
    set.addRange(0x9DF, 0x9E3).addRange(0x9E6, 0x9F1).addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA75).addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABC, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE0, 0xAE3).addRange(0xAE6, 0xAEF).addRange(0xAF9, 0xAFF).addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3C, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB66, 0xB6F).addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9);
    set.addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD).addRange(0xBE6, 0xBEF).addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3C, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC60, 0xC63).addRange(0xC66, 0xC6F).addRange(0xC80, 0xC83).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBC, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCDD, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3).addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4E).addRange(0xD54, 0xD57).addRange(0xD5F, 0xD63).addRange(0xD66, 0xD6F).addRange(0xD7A, 0xD7F).addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF3).addRange(0xE01, 0xE3A).addRange(0xE40, 0xE4E).addRange(0xE50, 0xE59).addRange(0xE81, 0xE82);
    set.addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEC8, 0xECE).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF).addRange(0xF18, 0xF19).addRange(0xF20, 0xF29).addRange(0xF3E, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF84).addRange(0xF86, 0xF97).addRange(0xF99, 0xFBC).addRange(0x1000, 0x1049).addRange(0x1050, 0x109D).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x135D, 0x135F).addRange(0x1369, 0x1371).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8).addRange(0x1700, 0x1715).addRange(0x171F, 0x1734).addRange(0x1740, 0x1753).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773).addRange(0x1780, 0x17D3).addRange(0x17DC, 0x17DD).addRange(0x17E0, 0x17E9);
    set.addRange(0x180B, 0x180D).addRange(0x180F, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1946, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x1A00, 0x1A1B).addRange(0x1A20, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1A7F, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AB0, 0x1ABD).addRange(0x1ABF, 0x1ACE).addRange(0x1B00, 0x1B4C).addRange(0x1B50, 0x1B59).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1BF3).addRange(0x1C00, 0x1C37).addRange(0x1C40, 0x1C49).addRange(0x1C4D, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CFA).addRange(0x1D00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x200C, 0x200D).addRange(0x203F, 0x2040).addRange(0x2090, 0x209C).addRange(0x20D0, 0x20DC);
    set.addRange(0x20E5, 0x20F0).addRange(0x210A, 0x2113).addRange(0x2118, 0x211D).addRange(0x212A, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2160, 0x2188).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D7F, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x2DE0, 0x2DFF).addRange(0x3005, 0x3007).addRange(0x3021, 0x302F).addRange(0x3031, 0x3035).addRange(0x3038, 0x303C).addRange(0x3041, 0x3096).addRange(0x3099, 0x309A).addRange(0x309D, 0x309F).addRange(0x30A1, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA62B).addRange(0xA640, 0xA66F).addRange(0xA674, 0xA67D).addRange(0xA67F, 0xA6F1).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F2, 0xA827).addRange(0xA840, 0xA873).addRange(0xA880, 0xA8C5).addRange(0xA8D0, 0xA8D9).addRange(0xA8E0, 0xA8F7);
    set.addRange(0xA8FD, 0xA92D).addRange(0xA930, 0xA953).addRange(0xA960, 0xA97C).addRange(0xA980, 0xA9C0).addRange(0xA9CF, 0xA9D9).addRange(0xA9E0, 0xA9FE).addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA50, 0xAA59).addRange(0xAA60, 0xAA76).addRange(0xAA7A, 0xAAC2).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEF).addRange(0xAAF2, 0xAAF6).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABEA).addRange(0xABEC, 0xABED).addRange(0xABF0, 0xABF9).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1D, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFC5D).addRange(0xFC64, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDF9).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0xFE33, 0xFE34).addRange(0xFE4D, 0xFE4F).addRange(0xFE7F, 0xFEFC).addRange(0xFF10, 0xFF19).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF65, 0xFFBE);
    set.addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10140, 0x10174).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x10300, 0x1031F).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x1037A).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x103D1, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104A0, 0x104A9).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915);
    set.addRange(0x10920, 0x10939).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A00, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A38, 0x10A3A).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE6).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91).addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D27).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D65).addRange(0x10D69, 0x10D6D).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAC).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC4).addRange(0x10EFC, 0x10F1C).addRange(0x10F30, 0x10F50).addRange(0x10F70, 0x10F85).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11000, 0x11046).addRange(0x11066, 0x11075).addRange(0x1107F, 0x110BA).addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9).addRange(0x11100, 0x11134).addRange(0x11136, 0x1113F).addRange(0x11144, 0x11147).addRange(0x11150, 0x11173).addRange(0x11180, 0x111C4).addRange(0x111C9, 0x111CC).addRange(0x111CE, 0x111DA).addRange(0x11200, 0x11211).addRange(0x11213, 0x11237).addRange(0x1123E, 0x11241).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D);
    set.addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112EA).addRange(0x112F0, 0x112F9).addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133B, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x1135D, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D3).addRange(0x113E1, 0x113E2).addRange(0x11400, 0x1144A).addRange(0x11450, 0x11459).addRange(0x1145E, 0x11461).addRange(0x11480, 0x114C5).addRange(0x114D0, 0x114D9).addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115C0).addRange(0x115D8, 0x115DD).addRange(0x11600, 0x11640).addRange(0x11650, 0x11659).addRange(0x11680, 0x116B8).addRange(0x116C0, 0x116C9).addRange(0x116D0, 0x116E3).addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172B).addRange(0x11730, 0x11739).addRange(0x11740, 0x11746).addRange(0x11800, 0x1183A).addRange(0x118A0, 0x118E9).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x11943).addRange(0x11950, 0x11959).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D7);
    set.addRange(0x119DA, 0x119E1).addRange(0x119E3, 0x119E4).addRange(0x11A00, 0x11A3E).addRange(0x11A50, 0x11A99).addRange(0x11AB0, 0x11AF8).addRange(0x11BC0, 0x11BE0).addRange(0x11BF0, 0x11BF9).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C40).addRange(0x11C50, 0x11C59).addRange(0x11C72, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D47).addRange(0x11D50, 0x11D59).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D98).addRange(0x11DA0, 0x11DA9).addRange(0x11EE0, 0x11EF6).addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F42).addRange(0x11F50, 0x11F5A).addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13440, 0x13455).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x16139).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A70, 0x16ABE).addRange(0x16AC0, 0x16AC9).addRange(0x16AD0, 0x16AED).addRange(0x16AF0, 0x16AF4).addRange(0x16B00, 0x16B36).addRange(0x16B40, 0x16B43).addRange(0x16B50, 0x16B59).addRange(0x16B63, 0x16B77);
    set.addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D6C).addRange(0x16D70, 0x16D79).addRange(0x16E40, 0x16E7F).addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x16FE3, 0x16FE4).addRange(0x16FF0, 0x16FF1).addRange(0x17000, 0x187F7).addRange(0x18800, 0x18CD5).addRange(0x18CFF, 0x18D08).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1BC9D, 0x1BC9E).addRange(0x1CCF0, 0x1CCF9).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D165, 0x1D169).addRange(0x1D16D, 0x1D172).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1D242, 0x1D244).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0);
    set.addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1D7CE, 0x1D7FF).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E130, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E290, 0x1E2AE).addRange(0x1E2C0, 0x1E2F9).addRange(0x1E4D0, 0x1E4F9).addRange(0x1E5D0, 0x1E5FA).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E900, 0x1E94B).addRange(0x1E950, 0x1E959).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89);
    set.addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1FBF0, 0x1FBF9).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF).addRange(0xE0100, 0xE01EF);
    XID_Continue.characters = set;
    return XID_Continue;
  }

var XID_Start = {};

var hasRequiredXID_Start;
  function requireXID_Start() {
    if (hasRequiredXID_Start) return XID_Start;
    hasRequiredXID_Start = 1;
    var set = regenerateExports(0xAA, 0xB5, 0xBA, 0x2EC, 0x2EE, 0x37F, 0x386, 0x38C, 0x559, 0x6D5, 0x6FF, 0x710, 0x7B1, 0x7FA, 0x81A, 0x824, 0x828, 0x93D, 0x950, 0x9B2, 0x9BD, 0x9CE, 0x9FC, 0xA5E, 0xABD, 0xAD0, 0xAF9, 0xB3D, 0xB71, 0xB83, 0xB9C, 0xBD0, 0xC3D, 0xC5D, 0xC80, 0xCBD, 0xD3D, 0xD4E, 0xDBD, 0xE32, 0xE84, 0xEA5, 0xEB2, 0xEBD, 0xEC6, 0xF00, 0x103F, 0x1061, 0x108E, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x17DC, 0x18AA, 0x1AA7, 0x1CFA, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0xA7D3, 0xA8FB, 0xA9CF, 0xAA7A, 0xAAB1, 0xAAC0, 0xAAC2, 0xFB1D, 0xFB3E, 0xFE71, 0xFE73, 0xFE77, 0xFE79, 0xFE7B, 0xFE7D, 0x10808, 0x1083C, 0x10A00, 0x10F27, 0x11075, 0x11144, 0x11147, 0x11176, 0x111DA, 0x111DC, 0x11288, 0x1133D, 0x11350, 0x1138B, 0x1138E, 0x113B7, 0x113D1, 0x113D3, 0x114C7, 0x11644, 0x116B8, 0x11909, 0x1193F, 0x11941, 0x119E1, 0x119E3, 0x11A00, 0x11A3A, 0x11A50, 0x11A9D, 0x11C40, 0x11D46, 0x11D98, 0x11F02, 0x11FB0, 0x16F50, 0x16FE3, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E14E, 0x1E5F0, 0x1E94B, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E);
    set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x370, 0x374).addRange(0x376, 0x377).addRange(0x37B, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x620, 0x64A).addRange(0x66E, 0x66F).addRange(0x671, 0x6D3).addRange(0x6E5, 0x6E6).addRange(0x6EE, 0x6EF).addRange(0x6FA, 0x6FC).addRange(0x712, 0x72F).addRange(0x74D, 0x7A5).addRange(0x7CA, 0x7EA).addRange(0x7F4, 0x7F5).addRange(0x800, 0x815).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88E).addRange(0x8A0, 0x8C9).addRange(0x904, 0x939).addRange(0x958, 0x961).addRange(0x971, 0x980).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E1).addRange(0x9F0, 0x9F1).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33);
    set.addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA59, 0xA5C).addRange(0xA72, 0xA74).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xAE0, 0xAE1).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB61).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xC05, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC58, 0xC5A).addRange(0xC60, 0xC61).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCDD, 0xCDE).addRange(0xCE0, 0xCE1).addRange(0xCF1, 0xCF2).addRange(0xD04, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD54, 0xD56).addRange(0xD5F, 0xD61).addRange(0xD7A, 0xD7F).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6);
    set.addRange(0xE01, 0xE30).addRange(0xE40, 0xE46).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB0).addRange(0xEC0, 0xEC4).addRange(0xEDC, 0xEDF).addRange(0xF40, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF88, 0xF8C).addRange(0x1000, 0x102A).addRange(0x1050, 0x1055).addRange(0x105A, 0x105D).addRange(0x1065, 0x1066).addRange(0x106E, 0x1070).addRange(0x1075, 0x1081).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8).addRange(0x1700, 0x1711).addRange(0x171F, 0x1731).addRange(0x1740, 0x1751).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1780, 0x17B3).addRange(0x1820, 0x1878).addRange(0x1880, 0x18A8).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E);
    set.addRange(0x1950, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x1A00, 0x1A16).addRange(0x1A20, 0x1A54).addRange(0x1B05, 0x1B33).addRange(0x1B45, 0x1B4C).addRange(0x1B83, 0x1BA0).addRange(0x1BAE, 0x1BAF).addRange(0x1BBA, 0x1BE5).addRange(0x1C00, 0x1C23).addRange(0x1C4D, 0x1C4F).addRange(0x1C5A, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF6).addRange(0x1D00, 0x1DBF).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x2090, 0x209C).addRange(0x210A, 0x2113).addRange(0x2118, 0x211D).addRange(0x212A, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2160, 0x2188).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0x2D30, 0x2D67).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE);
    set.addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x3005, 0x3007).addRange(0x3021, 0x3029).addRange(0x3031, 0x3035).addRange(0x3038, 0x303C).addRange(0x3041, 0x3096).addRange(0x309D, 0x309F).addRange(0x30A1, 0x30FA).addRange(0x30FC, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA61F).addRange(0xA62A, 0xA62B).addRange(0xA640, 0xA66E).addRange(0xA67F, 0xA69D).addRange(0xA6A0, 0xA6EF).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F2, 0xA801).addRange(0xA803, 0xA805).addRange(0xA807, 0xA80A).addRange(0xA80C, 0xA822).addRange(0xA840, 0xA873).addRange(0xA882, 0xA8B3).addRange(0xA8F2, 0xA8F7).addRange(0xA8FD, 0xA8FE).addRange(0xA90A, 0xA925).addRange(0xA930, 0xA946).addRange(0xA960, 0xA97C).addRange(0xA984, 0xA9B2).addRange(0xA9E0, 0xA9E4).addRange(0xA9E6, 0xA9EF).addRange(0xA9FA, 0xA9FE).addRange(0xAA00, 0xAA28).addRange(0xAA40, 0xAA42).addRange(0xAA44, 0xAA4B).addRange(0xAA60, 0xAA76);
    set.addRange(0xAA7E, 0xAAAF).addRange(0xAAB5, 0xAAB6).addRange(0xAAB9, 0xAABD).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEA).addRange(0xAAF2, 0xAAF4).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABE2).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1F, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFC5D).addRange(0xFC64, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDF9).addRange(0xFE7F, 0xFEFC).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF66, 0xFF9D).addRange(0xFFA0, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10140, 0x10174).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0);
    set.addRange(0x10300, 0x1031F).addRange(0x1032D, 0x1034A).addRange(0x10350, 0x10375).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x103D1, 0x103D5).addRange(0x10400, 0x1049D).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A10, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE4).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91).addRange(0x10C00, 0x10C48);
    set.addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D23).addRange(0x10D4A, 0x10D65).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC4).addRange(0x10F00, 0x10F1C).addRange(0x10F30, 0x10F45).addRange(0x10F70, 0x10F81).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11003, 0x11037).addRange(0x11071, 0x11072).addRange(0x11083, 0x110AF).addRange(0x110D0, 0x110E8).addRange(0x11103, 0x11126).addRange(0x11150, 0x11172).addRange(0x11183, 0x111B2).addRange(0x111C1, 0x111C4).addRange(0x11200, 0x11211).addRange(0x11213, 0x1122B).addRange(0x1123F, 0x11240).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112DE).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1135D, 0x11361).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x11400, 0x11434).addRange(0x11447, 0x1144A).addRange(0x1145F, 0x11461).addRange(0x11480, 0x114AF).addRange(0x114C4, 0x114C5).addRange(0x11580, 0x115AE).addRange(0x115D8, 0x115DB).addRange(0x11600, 0x1162F).addRange(0x11680, 0x116AA).addRange(0x11700, 0x1171A).addRange(0x11740, 0x11746).addRange(0x11800, 0x1182B).addRange(0x118A0, 0x118DF);
    set.addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x1192F).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D0).addRange(0x11A0B, 0x11A32).addRange(0x11A5C, 0x11A89).addRange(0x11AB0, 0x11AF8).addRange(0x11BC0, 0x11BE0).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C2E).addRange(0x11C72, 0x11C8F).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D30).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D89).addRange(0x11EE0, 0x11EF2).addRange(0x11F04, 0x11F10).addRange(0x11F12, 0x11F33).addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1611D).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A70, 0x16ABE).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B40, 0x16B43).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D6C).addRange(0x16E40, 0x16E7F).addRange(0x16F00, 0x16F4A).addRange(0x16F93, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x17000, 0x187F7).addRange(0x18800, 0x18CD5).addRange(0x18CFF, 0x18D08).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122);
    set.addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E137, 0x1E13D).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E4D0, 0x1E4EB).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E900, 0x1E943).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F);
    set.addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF);
    XID_Start.characters = set;
    return XID_Start;
  }

var Cased_Letter = {};

var hasRequiredCased_Letter;
  function requireCased_Letter() {
    if (hasRequiredCased_Letter) return Cased_Letter;
    hasRequiredCased_Letter = 1;
    var set = regenerateExports(0xB5, 0x37F, 0x386, 0x38C, 0x10C7, 0x10CD, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2139, 0x214E, 0x2D27, 0x2D2D, 0xA7D3, 0xA7FA, 0x1D4A2, 0x1D4BB, 0x1D546);
    set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x1BA).addRange(0x1BC, 0x1BF).addRange(0x1C4, 0x293).addRange(0x295, 0x2AF).addRange(0x370, 0x373).addRange(0x376, 0x377).addRange(0x37B, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FD, 0x10FF).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1D00, 0x1D2B).addRange(0x1D6B, 0x1D77).addRange(0x1D79, 0x1D9A).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x210A, 0x2113).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x212F, 0x2134).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2183, 0x2184);
    set.addRange(0x2C00, 0x2C7B).addRange(0x2C7E, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25).addRange(0xA640, 0xA66D).addRange(0xA680, 0xA69B).addRange(0xA722, 0xA76F).addRange(0xA771, 0xA787).addRange(0xA78B, 0xA78E).addRange(0xA790, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F5, 0xA7F6).addRange(0xAB30, 0xAB5A).addRange(0xAB60, 0xAB68).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0x10400, 0x1044F).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D50, 0x10D65).addRange(0x10D70, 0x10D85).addRange(0x118A0, 0x118DF).addRange(0x16E40, 0x16E7F).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E);
    set.addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF09).addRange(0x1DF0B, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E900, 0x1E943);
    Cased_Letter.characters = set;
    return Cased_Letter;
  }

var Close_Punctuation = {};

var hasRequiredClose_Punctuation;
  function requireClose_Punctuation() {
    if (hasRequiredClose_Punctuation) return Close_Punctuation;
    hasRequiredClose_Punctuation = 1;
    var set = regenerateExports(0x29, 0x5D, 0x7D, 0xF3B, 0xF3D, 0x169C, 0x2046, 0x207E, 0x208E, 0x2309, 0x230B, 0x232A, 0x2769, 0x276B, 0x276D, 0x276F, 0x2771, 0x2773, 0x2775, 0x27C6, 0x27E7, 0x27E9, 0x27EB, 0x27ED, 0x27EF, 0x2984, 0x2986, 0x2988, 0x298A, 0x298C, 0x298E, 0x2990, 0x2992, 0x2994, 0x2996, 0x2998, 0x29D9, 0x29DB, 0x29FD, 0x2E23, 0x2E25, 0x2E27, 0x2E29, 0x2E56, 0x2E58, 0x2E5A, 0x2E5C, 0x3009, 0x300B, 0x300D, 0x300F, 0x3011, 0x3015, 0x3017, 0x3019, 0x301B, 0xFD3E, 0xFE18, 0xFE36, 0xFE38, 0xFE3A, 0xFE3C, 0xFE3E, 0xFE40, 0xFE42, 0xFE44, 0xFE48, 0xFE5A, 0xFE5C, 0xFE5E, 0xFF09, 0xFF3D, 0xFF5D, 0xFF60, 0xFF63);
    set.addRange(0x301E, 0x301F);
    Close_Punctuation.characters = set;
    return Close_Punctuation;
  }

var Connector_Punctuation = {};

var hasRequiredConnector_Punctuation;
  function requireConnector_Punctuation() {
    if (hasRequiredConnector_Punctuation) return Connector_Punctuation;
    hasRequiredConnector_Punctuation = 1;
    var set = regenerateExports(0x5F, 0x2054, 0xFF3F);
    set.addRange(0x203F, 0x2040).addRange(0xFE33, 0xFE34).addRange(0xFE4D, 0xFE4F);
    Connector_Punctuation.characters = set;
    return Connector_Punctuation;
  }

var Control = {};

var hasRequiredControl;
  function requireControl() {
    if (hasRequiredControl) return Control;
    hasRequiredControl = 1;
    var set = regenerateExports();
    set.addRange(0x0, 0x1F).addRange(0x7F, 0x9F);
    Control.characters = set;
    return Control;
  }

var Currency_Symbol = {};

var hasRequiredCurrency_Symbol;
  function requireCurrency_Symbol() {
    if (hasRequiredCurrency_Symbol) return Currency_Symbol;
    hasRequiredCurrency_Symbol = 1;
    var set = regenerateExports(0x24, 0x58F, 0x60B, 0x9FB, 0xAF1, 0xBF9, 0xE3F, 0x17DB, 0xA838, 0xFDFC, 0xFE69, 0xFF04, 0x1E2FF, 0x1ECB0);
    set.addRange(0xA2, 0xA5).addRange(0x7FE, 0x7FF).addRange(0x9F2, 0x9F3).addRange(0x20A0, 0x20C0).addRange(0xFFE0, 0xFFE1).addRange(0xFFE5, 0xFFE6).addRange(0x11FDD, 0x11FE0);
    Currency_Symbol.characters = set;
    return Currency_Symbol;
  }

var Dash_Punctuation = {};

var hasRequiredDash_Punctuation;
  function requireDash_Punctuation() {
    if (hasRequiredDash_Punctuation) return Dash_Punctuation;
    hasRequiredDash_Punctuation = 1;
    var set = regenerateExports(0x2D, 0x58A, 0x5BE, 0x1400, 0x1806, 0x2E17, 0x2E1A, 0x2E40, 0x2E5D, 0x301C, 0x3030, 0x30A0, 0xFE58, 0xFE63, 0xFF0D, 0x10D6E, 0x10EAD);
    set.addRange(0x2010, 0x2015).addRange(0x2E3A, 0x2E3B).addRange(0xFE31, 0xFE32);
    Dash_Punctuation.characters = set;
    return Dash_Punctuation;
  }

var Decimal_Number = {};

var hasRequiredDecimal_Number;
  function requireDecimal_Number() {
    if (hasRequiredDecimal_Number) return Decimal_Number;
    hasRequiredDecimal_Number = 1;
    var set = regenerateExports();
    set.addRange(0x30, 0x39).addRange(0x660, 0x669).addRange(0x6F0, 0x6F9).addRange(0x7C0, 0x7C9).addRange(0x966, 0x96F).addRange(0x9E6, 0x9EF).addRange(0xA66, 0xA6F).addRange(0xAE6, 0xAEF).addRange(0xB66, 0xB6F).addRange(0xBE6, 0xBEF).addRange(0xC66, 0xC6F).addRange(0xCE6, 0xCEF).addRange(0xD66, 0xD6F).addRange(0xDE6, 0xDEF).addRange(0xE50, 0xE59).addRange(0xED0, 0xED9).addRange(0xF20, 0xF29).addRange(0x1040, 0x1049).addRange(0x1090, 0x1099).addRange(0x17E0, 0x17E9).addRange(0x1810, 0x1819).addRange(0x1946, 0x194F).addRange(0x19D0, 0x19D9).addRange(0x1A80, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1B50, 0x1B59).addRange(0x1BB0, 0x1BB9).addRange(0x1C40, 0x1C49).addRange(0x1C50, 0x1C59).addRange(0xA620, 0xA629).addRange(0xA8D0, 0xA8D9).addRange(0xA900, 0xA909).addRange(0xA9D0, 0xA9D9).addRange(0xA9F0, 0xA9F9).addRange(0xAA50, 0xAA59).addRange(0xABF0, 0xABF9).addRange(0xFF10, 0xFF19).addRange(0x104A0, 0x104A9).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D49).addRange(0x11066, 0x1106F).addRange(0x110F0, 0x110F9).addRange(0x11136, 0x1113F).addRange(0x111D0, 0x111D9).addRange(0x112F0, 0x112F9).addRange(0x11450, 0x11459).addRange(0x114D0, 0x114D9).addRange(0x11650, 0x11659).addRange(0x116C0, 0x116C9).addRange(0x116D0, 0x116E3).addRange(0x11730, 0x11739);
    set.addRange(0x118E0, 0x118E9).addRange(0x11950, 0x11959).addRange(0x11BF0, 0x11BF9).addRange(0x11C50, 0x11C59).addRange(0x11D50, 0x11D59).addRange(0x11DA0, 0x11DA9).addRange(0x11F50, 0x11F59).addRange(0x16130, 0x16139).addRange(0x16A60, 0x16A69).addRange(0x16AC0, 0x16AC9).addRange(0x16B50, 0x16B59).addRange(0x16D70, 0x16D79).addRange(0x1CCF0, 0x1CCF9).addRange(0x1D7CE, 0x1D7FF).addRange(0x1E140, 0x1E149).addRange(0x1E2F0, 0x1E2F9).addRange(0x1E4F0, 0x1E4F9).addRange(0x1E5F1, 0x1E5FA).addRange(0x1E950, 0x1E959).addRange(0x1FBF0, 0x1FBF9);
    Decimal_Number.characters = set;
    return Decimal_Number;
  }

var Enclosing_Mark = {};

var hasRequiredEnclosing_Mark;
  function requireEnclosing_Mark() {
    if (hasRequiredEnclosing_Mark) return Enclosing_Mark;
    hasRequiredEnclosing_Mark = 1;
    var set = regenerateExports(0x1ABE);
    set.addRange(0x488, 0x489).addRange(0x20DD, 0x20E0).addRange(0x20E2, 0x20E4).addRange(0xA670, 0xA672);
    Enclosing_Mark.characters = set;
    return Enclosing_Mark;
  }

var Final_Punctuation = {};

var hasRequiredFinal_Punctuation;
  function requireFinal_Punctuation() {
    if (hasRequiredFinal_Punctuation) return Final_Punctuation;
    hasRequiredFinal_Punctuation = 1;
    var set = regenerateExports(0xBB, 0x2019, 0x201D, 0x203A, 0x2E03, 0x2E05, 0x2E0A, 0x2E0D, 0x2E1D, 0x2E21);
    Final_Punctuation.characters = set;
    return Final_Punctuation;
  }

var Format = {};

var hasRequiredFormat;
  function requireFormat() {
    if (hasRequiredFormat) return Format;
    hasRequiredFormat = 1;
    var set = regenerateExports(0xAD, 0x61C, 0x6DD, 0x70F, 0x8E2, 0x180E, 0xFEFF, 0x110BD, 0x110CD, 0xE0001);
    set.addRange(0x600, 0x605).addRange(0x890, 0x891).addRange(0x200B, 0x200F).addRange(0x202A, 0x202E).addRange(0x2060, 0x2064).addRange(0x2066, 0x206F).addRange(0xFFF9, 0xFFFB).addRange(0x13430, 0x1343F).addRange(0x1BCA0, 0x1BCA3).addRange(0x1D173, 0x1D17A).addRange(0xE0020, 0xE007F);
    Format.characters = set;
    return Format;
  }

var Initial_Punctuation = {};

var hasRequiredInitial_Punctuation;
  function requireInitial_Punctuation() {
    if (hasRequiredInitial_Punctuation) return Initial_Punctuation;
    hasRequiredInitial_Punctuation = 1;
    var set = regenerateExports(0xAB, 0x2018, 0x201F, 0x2039, 0x2E02, 0x2E04, 0x2E09, 0x2E0C, 0x2E1C, 0x2E20);
    set.addRange(0x201B, 0x201C);
    Initial_Punctuation.characters = set;
    return Initial_Punctuation;
  }

var Letter_Number = {};

var hasRequiredLetter_Number;
  function requireLetter_Number() {
    if (hasRequiredLetter_Number) return Letter_Number;
    hasRequiredLetter_Number = 1;
    var set = regenerateExports(0x3007, 0x10341, 0x1034A);
    set.addRange(0x16EE, 0x16F0).addRange(0x2160, 0x2182).addRange(0x2185, 0x2188).addRange(0x3021, 0x3029).addRange(0x3038, 0x303A).addRange(0xA6E6, 0xA6EF).addRange(0x10140, 0x10174).addRange(0x103D1, 0x103D5).addRange(0x12400, 0x1246E);
    Letter_Number.characters = set;
    return Letter_Number;
  }

var Letter = {};

var hasRequiredLetter;
  function requireLetter() {
    if (hasRequiredLetter) return Letter;
    hasRequiredLetter = 1;
    var set = regenerateExports(0xAA, 0xB5, 0xBA, 0x2EC, 0x2EE, 0x37F, 0x386, 0x38C, 0x559, 0x6D5, 0x6FF, 0x710, 0x7B1, 0x7FA, 0x81A, 0x824, 0x828, 0x93D, 0x950, 0x9B2, 0x9BD, 0x9CE, 0x9FC, 0xA5E, 0xABD, 0xAD0, 0xAF9, 0xB3D, 0xB71, 0xB83, 0xB9C, 0xBD0, 0xC3D, 0xC5D, 0xC80, 0xCBD, 0xD3D, 0xD4E, 0xDBD, 0xE84, 0xEA5, 0xEBD, 0xEC6, 0xF00, 0x103F, 0x1061, 0x108E, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x17DC, 0x18AA, 0x1AA7, 0x1CFA, 0x1F59, 0x1F5B, 0x1F5D, 0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214E, 0x2D27, 0x2D2D, 0x2D6F, 0x2E2F, 0xA7D3, 0xA8FB, 0xA9CF, 0xAA7A, 0xAAB1, 0xAAC0, 0xAAC2, 0xFB1D, 0xFB3E, 0x10808, 0x1083C, 0x10A00, 0x10F27, 0x11075, 0x11144, 0x11147, 0x11176, 0x111DA, 0x111DC, 0x11288, 0x1133D, 0x11350, 0x1138B, 0x1138E, 0x113B7, 0x113D1, 0x113D3, 0x114C7, 0x11644, 0x116B8, 0x11909, 0x1193F, 0x11941, 0x119E1, 0x119E3, 0x11A00, 0x11A3A, 0x11A50, 0x11A9D, 0x11C40, 0x11D46, 0x11D98, 0x11F02, 0x11FB0, 0x16F50, 0x16FE3, 0x1B132, 0x1B155, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1E14E, 0x1E5F0, 0x1E94B, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E);
    set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x370, 0x374).addRange(0x376, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3F5).addRange(0x3F7, 0x481).addRange(0x48A, 0x52F).addRange(0x531, 0x556).addRange(0x560, 0x588).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x620, 0x64A).addRange(0x66E, 0x66F).addRange(0x671, 0x6D3).addRange(0x6E5, 0x6E6).addRange(0x6EE, 0x6EF).addRange(0x6FA, 0x6FC).addRange(0x712, 0x72F).addRange(0x74D, 0x7A5).addRange(0x7CA, 0x7EA).addRange(0x7F4, 0x7F5).addRange(0x800, 0x815).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88E).addRange(0x8A0, 0x8C9).addRange(0x904, 0x939).addRange(0x958, 0x961).addRange(0x971, 0x980).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E1).addRange(0x9F0, 0x9F1).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33);
    set.addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA59, 0xA5C).addRange(0xA72, 0xA74).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xAE0, 0xAE1).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB61).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xC05, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC58, 0xC5A).addRange(0xC60, 0xC61).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCDD, 0xCDE).addRange(0xCE0, 0xCE1).addRange(0xCF1, 0xCF2).addRange(0xD04, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD54, 0xD56).addRange(0xD5F, 0xD61).addRange(0xD7A, 0xD7F).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6);
    set.addRange(0xE01, 0xE30).addRange(0xE32, 0xE33).addRange(0xE40, 0xE46).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB0).addRange(0xEB2, 0xEB3).addRange(0xEC0, 0xEC4).addRange(0xEDC, 0xEDF).addRange(0xF40, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF88, 0xF8C).addRange(0x1000, 0x102A).addRange(0x1050, 0x1055).addRange(0x105A, 0x105D).addRange(0x1065, 0x1066).addRange(0x106E, 0x1070).addRange(0x1075, 0x1081).addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1380, 0x138F).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16F1, 0x16F8).addRange(0x1700, 0x1711).addRange(0x171F, 0x1731).addRange(0x1740, 0x1751).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1780, 0x17B3).addRange(0x1820, 0x1878).addRange(0x1880, 0x1884);
    set.addRange(0x1887, 0x18A8).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1950, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x1A00, 0x1A16).addRange(0x1A20, 0x1A54).addRange(0x1B05, 0x1B33).addRange(0x1B45, 0x1B4C).addRange(0x1B83, 0x1BA0).addRange(0x1BAE, 0x1BAF).addRange(0x1BBA, 0x1BE5).addRange(0x1C00, 0x1C23).addRange(0x1C4D, 0x1C4F).addRange(0x1C5A, 0x1C7D).addRange(0x1C80, 0x1C8A).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF6).addRange(0x1D00, 0x1DBF).addRange(0x1E00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FBC).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FCC).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FE0, 0x1FEC).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFC).addRange(0x2090, 0x209C).addRange(0x210A, 0x2113).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x212F, 0x2139).addRange(0x213C, 0x213F).addRange(0x2145, 0x2149).addRange(0x2183, 0x2184).addRange(0x2C00, 0x2CE4).addRange(0x2CEB, 0x2CEE).addRange(0x2CF2, 0x2CF3).addRange(0x2D00, 0x2D25);
    set.addRange(0x2D30, 0x2D67).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x3005, 0x3006).addRange(0x3031, 0x3035).addRange(0x303B, 0x303C).addRange(0x3041, 0x3096).addRange(0x309D, 0x309F).addRange(0x30A1, 0x30FA).addRange(0x30FC, 0x30FF).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA48C).addRange(0xA4D0, 0xA4FD).addRange(0xA500, 0xA60C).addRange(0xA610, 0xA61F).addRange(0xA62A, 0xA62B).addRange(0xA640, 0xA66E).addRange(0xA67F, 0xA69D).addRange(0xA6A0, 0xA6E5).addRange(0xA717, 0xA71F).addRange(0xA722, 0xA788).addRange(0xA78B, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F2, 0xA801).addRange(0xA803, 0xA805).addRange(0xA807, 0xA80A).addRange(0xA80C, 0xA822).addRange(0xA840, 0xA873).addRange(0xA882, 0xA8B3).addRange(0xA8F2, 0xA8F7).addRange(0xA8FD, 0xA8FE).addRange(0xA90A, 0xA925).addRange(0xA930, 0xA946).addRange(0xA960, 0xA97C).addRange(0xA984, 0xA9B2).addRange(0xA9E0, 0xA9E4).addRange(0xA9E6, 0xA9EF).addRange(0xA9FA, 0xA9FE).addRange(0xAA00, 0xAA28);
    set.addRange(0xAA40, 0xAA42).addRange(0xAA44, 0xAA4B).addRange(0xAA60, 0xAA76).addRange(0xAA7E, 0xAAAF).addRange(0xAAB5, 0xAAB6).addRange(0xAAB9, 0xAABD).addRange(0xAADB, 0xAADD).addRange(0xAAE0, 0xAAEA).addRange(0xAAF2, 0xAAF4).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB69).addRange(0xAB70, 0xABE2).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFB1F, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFB).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0xFF66, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10280, 0x1029C);
    set.addRange(0x102A0, 0x102D0).addRange(0x10300, 0x1031F).addRange(0x1032D, 0x10340).addRange(0x10342, 0x10349).addRange(0x10350, 0x10375).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x10400, 0x1049D).addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A10, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE4).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91);
    set.addRange(0x10C00, 0x10C48).addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10D00, 0x10D23).addRange(0x10D4A, 0x10D65).addRange(0x10D6F, 0x10D85).addRange(0x10E80, 0x10EA9).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC4).addRange(0x10F00, 0x10F1C).addRange(0x10F30, 0x10F45).addRange(0x10F70, 0x10F81).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11003, 0x11037).addRange(0x11071, 0x11072).addRange(0x11083, 0x110AF).addRange(0x110D0, 0x110E8).addRange(0x11103, 0x11126).addRange(0x11150, 0x11172).addRange(0x11183, 0x111B2).addRange(0x111C1, 0x111C4).addRange(0x11200, 0x11211).addRange(0x11213, 0x1122B).addRange(0x1123F, 0x11240).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112DE).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1135D, 0x11361).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x11400, 0x11434).addRange(0x11447, 0x1144A).addRange(0x1145F, 0x11461).addRange(0x11480, 0x114AF).addRange(0x114C4, 0x114C5).addRange(0x11580, 0x115AE).addRange(0x115D8, 0x115DB).addRange(0x11600, 0x1162F).addRange(0x11680, 0x116AA).addRange(0x11700, 0x1171A).addRange(0x11740, 0x11746).addRange(0x11800, 0x1182B);
    set.addRange(0x118A0, 0x118DF).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x1192F).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D0).addRange(0x11A0B, 0x11A32).addRange(0x11A5C, 0x11A89).addRange(0x11AB0, 0x11AF8).addRange(0x11BC0, 0x11BE0).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C2E).addRange(0x11C72, 0x11C8F).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D30).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D89).addRange(0x11EE0, 0x11EF2).addRange(0x11F04, 0x11F10).addRange(0x11F12, 0x11F33).addRange(0x12000, 0x12399).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1611D).addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A70, 0x16ABE).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B40, 0x16B43).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D40, 0x16D6C).addRange(0x16E40, 0x16E7F).addRange(0x16F00, 0x16F4A).addRange(0x16F93, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x17000, 0x187F7).addRange(0x18800, 0x18CD5).addRange(0x18CFF, 0x18D08).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B000, 0x1B122);
    set.addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6FA).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D734).addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D76E).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D7A8).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7CB).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E030, 0x1E06D).addRange(0x1E100, 0x1E12C).addRange(0x1E137, 0x1E13D).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E4D0, 0x1E4EB).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1E900, 0x1E943).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F);
    set.addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF);
    Letter.characters = set;
    return Letter;
  }

var Line_Separator = {};

var hasRequiredLine_Separator;
  function requireLine_Separator() {
    if (hasRequiredLine_Separator) return Line_Separator;
    hasRequiredLine_Separator = 1;
    var set = regenerateExports(0x2028);
    Line_Separator.characters = set;
    return Line_Separator;
  }

var Lowercase_Letter = {};

var hasRequiredLowercase_Letter;
  function requireLowercase_Letter() {
    if (hasRequiredLowercase_Letter) return Lowercase_Letter;
    hasRequiredLowercase_Letter = 1;
    var set = regenerateExports(0xB5, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x183, 0x185, 0x188, 0x192, 0x195, 0x19E, 0x1A1, 0x1A3, 0x1A5, 0x1A8, 0x1AD, 0x1B0, 0x1B4, 0x1B6, 0x1C6, 0x1C9, 0x1CC, 0x1CE, 0x1D0, 0x1D2, 0x1D4, 0x1D6, 0x1D8, 0x1DA, 0x1DF, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x1E9, 0x1EB, 0x1ED, 0x1F3, 0x1F5, 0x1F9, 0x1FB, 0x1FD, 0x1FF, 0x201, 0x203, 0x205, 0x207, 0x209, 0x20B, 0x20D, 0x20F, 0x211, 0x213, 0x215, 0x217, 0x219, 0x21B, 0x21D, 0x21F, 0x221, 0x223, 0x225, 0x227, 0x229, 0x22B, 0x22D, 0x22F, 0x231, 0x23C, 0x242, 0x247, 0x249, 0x24B, 0x24D, 0x371, 0x373, 0x377, 0x390, 0x3D9, 0x3DB, 0x3DD, 0x3DF, 0x3E1, 0x3E3, 0x3E5, 0x3E7, 0x3E9, 0x3EB, 0x3ED, 0x3F5, 0x3F8, 0x461, 0x463, 0x465, 0x467, 0x469, 0x46B, 0x46D, 0x46F, 0x471, 0x473, 0x475, 0x477, 0x479, 0x47B, 0x47D, 0x47F, 0x481, 0x48B, 0x48D, 0x48F, 0x491, 0x493, 0x495, 0x497, 0x499, 0x49B, 0x49D, 0x49F, 0x4A1, 0x4A3, 0x4A5, 0x4A7, 0x4A9, 0x4AB, 0x4AD, 0x4AF, 0x4B1, 0x4B3, 0x4B5, 0x4B7, 0x4B9, 0x4BB, 0x4BD, 0x4BF, 0x4C2, 0x4C4, 0x4C6, 0x4C8, 0x4CA, 0x4CC, 0x4D1, 0x4D3, 0x4D5, 0x4D7, 0x4D9, 0x4DB, 0x4DD, 0x4DF, 0x4E1, 0x4E3, 0x4E5, 0x4E7, 0x4E9, 0x4EB, 0x4ED, 0x4EF, 0x4F1, 0x4F3, 0x4F5, 0x4F7, 0x4F9, 0x4FB, 0x4FD, 0x4FF, 0x501, 0x503, 0x505, 0x507, 0x509, 0x50B, 0x50D, 0x50F, 0x511, 0x513, 0x515, 0x517, 0x519, 0x51B, 0x51D, 0x51F, 0x521, 0x523, 0x525, 0x527, 0x529, 0x52B, 0x52D, 0x52F, 0x1C8A, 0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1E9F, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9, 0x1EFB, 0x1EFD, 0x1FBE, 0x210A, 0x2113, 0x212F, 0x2134, 0x2139, 0x214E, 0x2184, 0x2C61, 0x2C68, 0x2C6A, 0x2C6C, 0x2C71, 0x2C81, 0x2C83, 0x2C85, 0x2C87, 0x2C89, 0x2C8B, 0x2C8D, 0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1, 0x2CA3, 0x2CA5, 0x2CA7, 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5, 0x2CB7, 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, 0x2CC9, 0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, 0x2CD9, 0x2CDB, 0x2CDD, 0x2CDF, 0x2CE1, 0x2CEC, 0x2CEE, 0x2CF3, 0x2D27, 0x2D2D, 0xA641, 0xA643, 0xA645, 0xA647, 0xA649, 0xA64B, 0xA64D, 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B, 0xA65D, 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA66D, 0xA681, 0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, 0xA691, 0xA693, 0xA695, 0xA697, 0xA699, 0xA69B, 0xA723, 0xA725, 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA733, 0xA735, 0xA737, 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745, 0xA747, 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, 0xA759, 0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D, 0xA76F, 0xA77A, 0xA77C, 0xA77F, 0xA781, 0xA783, 0xA785, 0xA787, 0xA78C, 0xA78E, 0xA791, 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, 0xA7A7, 0xA7A9, 0xA7AF, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3, 0xA7C8, 0xA7CA, 0xA7CD, 0xA7D1, 0xA7D3, 0xA7D5, 0xA7D7, 0xA7D9, 0xA7DB, 0xA7F6, 0xA7FA, 0x1D4BB, 0x1D7CB);
    set.addRange(0x61, 0x7A).addRange(0xDF, 0xF6).addRange(0xF8, 0xFF).addRange(0x137, 0x138).addRange(0x148, 0x149).addRange(0x17E, 0x180).addRange(0x18C, 0x18D).addRange(0x199, 0x19B).addRange(0x1AA, 0x1AB).addRange(0x1B9, 0x1BA).addRange(0x1BD, 0x1BF).addRange(0x1DC, 0x1DD).addRange(0x1EF, 0x1F0).addRange(0x233, 0x239).addRange(0x23F, 0x240).addRange(0x24F, 0x293).addRange(0x295, 0x2AF).addRange(0x37B, 0x37D).addRange(0x3AC, 0x3CE).addRange(0x3D0, 0x3D1).addRange(0x3D5, 0x3D7).addRange(0x3EF, 0x3F3).addRange(0x3FB, 0x3FC).addRange(0x430, 0x45F).addRange(0x4CE, 0x4CF).addRange(0x560, 0x588).addRange(0x10D0, 0x10FA).addRange(0x10FD, 0x10FF).addRange(0x13F8, 0x13FD).addRange(0x1C80, 0x1C88).addRange(0x1D00, 0x1D2B).addRange(0x1D6B, 0x1D77).addRange(0x1D79, 0x1D9A).addRange(0x1E95, 0x1E9D).addRange(0x1EFF, 0x1F07).addRange(0x1F10, 0x1F15).addRange(0x1F20, 0x1F27).addRange(0x1F30, 0x1F37).addRange(0x1F40, 0x1F45).addRange(0x1F50, 0x1F57).addRange(0x1F60, 0x1F67).addRange(0x1F70, 0x1F7D).addRange(0x1F80, 0x1F87).addRange(0x1F90, 0x1F97).addRange(0x1FA0, 0x1FA7).addRange(0x1FB0, 0x1FB4).addRange(0x1FB6, 0x1FB7).addRange(0x1FC2, 0x1FC4).addRange(0x1FC6, 0x1FC7).addRange(0x1FD0, 0x1FD3).addRange(0x1FD6, 0x1FD7);
    set.addRange(0x1FE0, 0x1FE7).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FF7).addRange(0x210E, 0x210F).addRange(0x213C, 0x213D).addRange(0x2146, 0x2149).addRange(0x2C30, 0x2C5F).addRange(0x2C65, 0x2C66).addRange(0x2C73, 0x2C74).addRange(0x2C76, 0x2C7B).addRange(0x2CE3, 0x2CE4).addRange(0x2D00, 0x2D25).addRange(0xA72F, 0xA731).addRange(0xA771, 0xA778).addRange(0xA793, 0xA795).addRange(0xAB30, 0xAB5A).addRange(0xAB60, 0xAB68).addRange(0xAB70, 0xABBF).addRange(0xFB00, 0xFB06).addRange(0xFB13, 0xFB17).addRange(0xFF41, 0xFF5A).addRange(0x10428, 0x1044F).addRange(0x104D8, 0x104FB).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC).addRange(0x10CC0, 0x10CF2).addRange(0x10D70, 0x10D85).addRange(0x118C0, 0x118DF).addRange(0x16E60, 0x16E7F).addRange(0x1D41A, 0x1D433).addRange(0x1D44E, 0x1D454).addRange(0x1D456, 0x1D467).addRange(0x1D482, 0x1D49B).addRange(0x1D4B6, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D4CF).addRange(0x1D4EA, 0x1D503).addRange(0x1D51E, 0x1D537).addRange(0x1D552, 0x1D56B).addRange(0x1D586, 0x1D59F).addRange(0x1D5BA, 0x1D5D3).addRange(0x1D5EE, 0x1D607).addRange(0x1D622, 0x1D63B).addRange(0x1D656, 0x1D66F).addRange(0x1D68A, 0x1D6A5).addRange(0x1D6C2, 0x1D6DA).addRange(0x1D6DC, 0x1D6E1).addRange(0x1D6FC, 0x1D714).addRange(0x1D716, 0x1D71B);
    set.addRange(0x1D736, 0x1D74E).addRange(0x1D750, 0x1D755).addRange(0x1D770, 0x1D788).addRange(0x1D78A, 0x1D78F).addRange(0x1D7AA, 0x1D7C2).addRange(0x1D7C4, 0x1D7C9).addRange(0x1DF00, 0x1DF09).addRange(0x1DF0B, 0x1DF1E).addRange(0x1DF25, 0x1DF2A).addRange(0x1E922, 0x1E943);
    Lowercase_Letter.characters = set;
    return Lowercase_Letter;
  }

var Mark = {};

var hasRequiredMark;
  function requireMark() {
    if (hasRequiredMark) return Mark;
    hasRequiredMark = 1;
    var set = regenerateExports(0x5BF, 0x5C7, 0x670, 0x711, 0x7FD, 0x9BC, 0x9D7, 0x9FE, 0xA3C, 0xA51, 0xA75, 0xABC, 0xB3C, 0xB82, 0xBD7, 0xC3C, 0xCBC, 0xCF3, 0xD57, 0xDCA, 0xDD6, 0xE31, 0xEB1, 0xF35, 0xF37, 0xF39, 0xFC6, 0x108F, 0x17DD, 0x180F, 0x18A9, 0x1A7F, 0x1CED, 0x1CF4, 0x2D7F, 0xA802, 0xA806, 0xA80B, 0xA82C, 0xA8FF, 0xA9E5, 0xAA43, 0xAAB0, 0xAAC1, 0xFB1E, 0x101FD, 0x102E0, 0x10A3F, 0x11070, 0x110C2, 0x11173, 0x1123E, 0x11241, 0x11357, 0x113C2, 0x113C5, 0x113D2, 0x1145E, 0x11940, 0x119E4, 0x11A47, 0x11D3A, 0x11D47, 0x11F03, 0x11F5A, 0x13440, 0x16F4F, 0x16FE4, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E2AE);
    set.addRange(0x300, 0x36F).addRange(0x483, 0x489).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x610, 0x61A).addRange(0x64B, 0x65F).addRange(0x6D6, 0x6DC).addRange(0x6DF, 0x6E4).addRange(0x6E7, 0x6E8).addRange(0x6EA, 0x6ED).addRange(0x730, 0x74A).addRange(0x7A6, 0x7B0).addRange(0x7EB, 0x7F3).addRange(0x816, 0x819).addRange(0x81B, 0x823).addRange(0x825, 0x827).addRange(0x829, 0x82D).addRange(0x859, 0x85B).addRange(0x897, 0x89F).addRange(0x8CA, 0x8E1).addRange(0x8E3, 0x903).addRange(0x93A, 0x93C).addRange(0x93E, 0x94F).addRange(0x951, 0x957).addRange(0x962, 0x963).addRange(0x981, 0x983).addRange(0x9BE, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CD).addRange(0x9E2, 0x9E3).addRange(0xA01, 0xA03).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA70, 0xA71).addRange(0xA81, 0xA83).addRange(0xABE, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE2, 0xAE3).addRange(0xAFA, 0xAFF).addRange(0xB01, 0xB03).addRange(0xB3E, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB62, 0xB63).addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD);
    set.addRange(0xC00, 0xC04).addRange(0xC3E, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC62, 0xC63).addRange(0xC81, 0xC83).addRange(0xCBE, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCE2, 0xCE3).addRange(0xD00, 0xD03).addRange(0xD3B, 0xD3C).addRange(0xD3E, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4D).addRange(0xD62, 0xD63).addRange(0xD81, 0xD83).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDF2, 0xDF3).addRange(0xE34, 0xE3A).addRange(0xE47, 0xE4E).addRange(0xEB4, 0xEBC).addRange(0xEC8, 0xECE).addRange(0xF18, 0xF19).addRange(0xF3E, 0xF3F).addRange(0xF71, 0xF84).addRange(0xF86, 0xF87).addRange(0xF8D, 0xF97).addRange(0xF99, 0xFBC).addRange(0x102B, 0x103E).addRange(0x1056, 0x1059).addRange(0x105E, 0x1060).addRange(0x1062, 0x1064).addRange(0x1067, 0x106D).addRange(0x1071, 0x1074).addRange(0x1082, 0x108D).addRange(0x109A, 0x109D).addRange(0x135D, 0x135F).addRange(0x1712, 0x1715).addRange(0x1732, 0x1734).addRange(0x1752, 0x1753).addRange(0x1772, 0x1773).addRange(0x17B4, 0x17D3).addRange(0x180B, 0x180D).addRange(0x1885, 0x1886).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1A17, 0x1A1B);
    set.addRange(0x1A55, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1AB0, 0x1ACE).addRange(0x1B00, 0x1B04).addRange(0x1B34, 0x1B44).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1B82).addRange(0x1BA1, 0x1BAD).addRange(0x1BE6, 0x1BF3).addRange(0x1C24, 0x1C37).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CE8).addRange(0x1CF7, 0x1CF9).addRange(0x1DC0, 0x1DFF).addRange(0x20D0, 0x20F0).addRange(0x2CEF, 0x2CF1).addRange(0x2DE0, 0x2DFF).addRange(0x302A, 0x302F).addRange(0x3099, 0x309A).addRange(0xA66F, 0xA672).addRange(0xA674, 0xA67D).addRange(0xA69E, 0xA69F).addRange(0xA6F0, 0xA6F1).addRange(0xA823, 0xA827).addRange(0xA880, 0xA881).addRange(0xA8B4, 0xA8C5).addRange(0xA8E0, 0xA8F1).addRange(0xA926, 0xA92D).addRange(0xA947, 0xA953).addRange(0xA980, 0xA983).addRange(0xA9B3, 0xA9C0).addRange(0xAA29, 0xAA36).addRange(0xAA4C, 0xAA4D).addRange(0xAA7B, 0xAA7D).addRange(0xAAB2, 0xAAB4).addRange(0xAAB7, 0xAAB8).addRange(0xAABE, 0xAABF).addRange(0xAAEB, 0xAAEF).addRange(0xAAF5, 0xAAF6).addRange(0xABE3, 0xABEA).addRange(0xABEC, 0xABED).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0x10376, 0x1037A).addRange(0x10A01, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A0F).addRange(0x10A38, 0x10A3A).addRange(0x10AE5, 0x10AE6).addRange(0x10D24, 0x10D27).addRange(0x10D69, 0x10D6D);
    set.addRange(0x10EAB, 0x10EAC).addRange(0x10EFC, 0x10EFF).addRange(0x10F46, 0x10F50).addRange(0x10F82, 0x10F85).addRange(0x11000, 0x11002).addRange(0x11038, 0x11046).addRange(0x11073, 0x11074).addRange(0x1107F, 0x11082).addRange(0x110B0, 0x110BA).addRange(0x11100, 0x11102).addRange(0x11127, 0x11134).addRange(0x11145, 0x11146).addRange(0x11180, 0x11182).addRange(0x111B3, 0x111C0).addRange(0x111C9, 0x111CC).addRange(0x111CE, 0x111CF).addRange(0x1122C, 0x11237).addRange(0x112DF, 0x112EA).addRange(0x11300, 0x11303).addRange(0x1133B, 0x1133C).addRange(0x1133E, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x11362, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x113B8, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D0).addRange(0x113E1, 0x113E2).addRange(0x11435, 0x11446).addRange(0x114B0, 0x114C3).addRange(0x115AF, 0x115B5).addRange(0x115B8, 0x115C0).addRange(0x115DC, 0x115DD).addRange(0x11630, 0x11640).addRange(0x116AB, 0x116B7).addRange(0x1171D, 0x1172B).addRange(0x1182C, 0x1183A).addRange(0x11930, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x1193E).addRange(0x11942, 0x11943).addRange(0x119D1, 0x119D7).addRange(0x119DA, 0x119E0).addRange(0x11A01, 0x11A0A).addRange(0x11A33, 0x11A39).addRange(0x11A3B, 0x11A3E).addRange(0x11A51, 0x11A5B).addRange(0x11A8A, 0x11A99).addRange(0x11C2F, 0x11C36);
    set.addRange(0x11C38, 0x11C3F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6).addRange(0x11D31, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D45).addRange(0x11D8A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D97).addRange(0x11EF3, 0x11EF6).addRange(0x11F00, 0x11F01).addRange(0x11F34, 0x11F3A).addRange(0x11F3E, 0x11F42).addRange(0x13447, 0x13455).addRange(0x1611E, 0x1612F).addRange(0x16AF0, 0x16AF4).addRange(0x16B30, 0x16B36).addRange(0x16F51, 0x16F87).addRange(0x16F8F, 0x16F92).addRange(0x16FF0, 0x16FF1).addRange(0x1BC9D, 0x1BC9E).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D165, 0x1D169).addRange(0x1D16D, 0x1D172).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1D242, 0x1D244).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E130, 0x1E136).addRange(0x1E2EC, 0x1E2EF).addRange(0x1E4EC, 0x1E4EF).addRange(0x1E5EE, 0x1E5EF).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E944, 0x1E94A).addRange(0xE0100, 0xE01EF);
    Mark.characters = set;
    return Mark;
  }

var Math_Symbol = {};

var hasRequiredMath_Symbol;
  function requireMath_Symbol() {
    if (hasRequiredMath_Symbol) return Math_Symbol;
    hasRequiredMath_Symbol = 1;
    var set = regenerateExports(0x2B, 0x7C, 0x7E, 0xAC, 0xB1, 0xD7, 0xF7, 0x3F6, 0x2044, 0x2052, 0x2118, 0x214B, 0x21A0, 0x21A3, 0x21A6, 0x21AE, 0x21D2, 0x21D4, 0x237C, 0x25B7, 0x25C1, 0x266F, 0xFB29, 0xFE62, 0xFF0B, 0xFF5C, 0xFF5E, 0xFFE2, 0x1D6C1, 0x1D6DB, 0x1D6FB, 0x1D715, 0x1D735, 0x1D74F, 0x1D76F, 0x1D789, 0x1D7A9, 0x1D7C3);
    set.addRange(0x3C, 0x3E).addRange(0x606, 0x608).addRange(0x207A, 0x207C).addRange(0x208A, 0x208C).addRange(0x2140, 0x2144).addRange(0x2190, 0x2194).addRange(0x219A, 0x219B).addRange(0x21CE, 0x21CF).addRange(0x21F4, 0x22FF).addRange(0x2320, 0x2321).addRange(0x239B, 0x23B3).addRange(0x23DC, 0x23E1).addRange(0x25F8, 0x25FF).addRange(0x27C0, 0x27C4).addRange(0x27C7, 0x27E5).addRange(0x27F0, 0x27FF).addRange(0x2900, 0x2982).addRange(0x2999, 0x29D7).addRange(0x29DC, 0x29FB).addRange(0x29FE, 0x2AFF).addRange(0x2B30, 0x2B44).addRange(0x2B47, 0x2B4C).addRange(0xFE64, 0xFE66).addRange(0xFF1C, 0xFF1E).addRange(0xFFE9, 0xFFEC).addRange(0x10D8E, 0x10D8F).addRange(0x1EEF0, 0x1EEF1);
    Math_Symbol.characters = set;
    return Math_Symbol;
  }

var Modifier_Letter = {};

var hasRequiredModifier_Letter;
  function requireModifier_Letter() {
    if (hasRequiredModifier_Letter) return Modifier_Letter;
    hasRequiredModifier_Letter = 1;
    var set = regenerateExports(0x2EC, 0x2EE, 0x374, 0x37A, 0x559, 0x640, 0x7FA, 0x81A, 0x824, 0x828, 0x8C9, 0x971, 0xE46, 0xEC6, 0x10FC, 0x17D7, 0x1843, 0x1AA7, 0x1D78, 0x2071, 0x207F, 0x2D6F, 0x2E2F, 0x3005, 0x303B, 0xA015, 0xA60C, 0xA67F, 0xA770, 0xA788, 0xA9CF, 0xA9E6, 0xAA70, 0xAADD, 0xAB69, 0xFF70, 0x10D4E, 0x10D6F, 0x16FE3, 0x1E4EB, 0x1E94B);
    set.addRange(0x2B0, 0x2C1).addRange(0x2C6, 0x2D1).addRange(0x2E0, 0x2E4).addRange(0x6E5, 0x6E6).addRange(0x7F4, 0x7F5).addRange(0x1C78, 0x1C7D).addRange(0x1D2C, 0x1D6A).addRange(0x1D9B, 0x1DBF).addRange(0x2090, 0x209C).addRange(0x2C7C, 0x2C7D).addRange(0x3031, 0x3035).addRange(0x309D, 0x309E).addRange(0x30FC, 0x30FE).addRange(0xA4F8, 0xA4FD).addRange(0xA69C, 0xA69D).addRange(0xA717, 0xA71F).addRange(0xA7F2, 0xA7F4).addRange(0xA7F8, 0xA7F9).addRange(0xAAF3, 0xAAF4).addRange(0xAB5C, 0xAB5F).addRange(0xFF9E, 0xFF9F).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x16B40, 0x16B43).addRange(0x16D40, 0x16D42).addRange(0x16D6B, 0x16D6C).addRange(0x16F93, 0x16F9F).addRange(0x16FE0, 0x16FE1).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1E030, 0x1E06D).addRange(0x1E137, 0x1E13D);
    Modifier_Letter.characters = set;
    return Modifier_Letter;
  }

var Modifier_Symbol = {};

var hasRequiredModifier_Symbol;
  function requireModifier_Symbol() {
    if (hasRequiredModifier_Symbol) return Modifier_Symbol;
    hasRequiredModifier_Symbol = 1;
    var set = regenerateExports(0x5E, 0x60, 0xA8, 0xAF, 0xB4, 0xB8, 0x2ED, 0x375, 0x888, 0x1FBD, 0xAB5B, 0xFF3E, 0xFF40, 0xFFE3);
    set.addRange(0x2C2, 0x2C5).addRange(0x2D2, 0x2DF).addRange(0x2E5, 0x2EB).addRange(0x2EF, 0x2FF).addRange(0x384, 0x385).addRange(0x1FBF, 0x1FC1).addRange(0x1FCD, 0x1FCF).addRange(0x1FDD, 0x1FDF).addRange(0x1FED, 0x1FEF).addRange(0x1FFD, 0x1FFE).addRange(0x309B, 0x309C).addRange(0xA700, 0xA716).addRange(0xA720, 0xA721).addRange(0xA789, 0xA78A).addRange(0xAB6A, 0xAB6B).addRange(0xFBB2, 0xFBC2).addRange(0x1F3FB, 0x1F3FF);
    Modifier_Symbol.characters = set;
    return Modifier_Symbol;
  }

var Nonspacing_Mark = {};

var hasRequiredNonspacing_Mark;
  function requireNonspacing_Mark() {
    if (hasRequiredNonspacing_Mark) return Nonspacing_Mark;
    hasRequiredNonspacing_Mark = 1;
    var set = regenerateExports(0x5BF, 0x5C7, 0x670, 0x711, 0x7FD, 0x93A, 0x93C, 0x94D, 0x981, 0x9BC, 0x9CD, 0x9FE, 0xA3C, 0xA51, 0xA75, 0xABC, 0xACD, 0xB01, 0xB3C, 0xB3F, 0xB4D, 0xB82, 0xBC0, 0xBCD, 0xC00, 0xC04, 0xC3C, 0xC81, 0xCBC, 0xCBF, 0xCC6, 0xD4D, 0xD81, 0xDCA, 0xDD6, 0xE31, 0xEB1, 0xF35, 0xF37, 0xF39, 0xFC6, 0x1082, 0x108D, 0x109D, 0x17C6, 0x17DD, 0x180F, 0x18A9, 0x1932, 0x1A1B, 0x1A56, 0x1A60, 0x1A62, 0x1A7F, 0x1B34, 0x1B3C, 0x1B42, 0x1BE6, 0x1BED, 0x1CED, 0x1CF4, 0x20E1, 0x2D7F, 0xA66F, 0xA802, 0xA806, 0xA80B, 0xA82C, 0xA8FF, 0xA9B3, 0xA9E5, 0xAA43, 0xAA4C, 0xAA7C, 0xAAB0, 0xAAC1, 0xAAF6, 0xABE5, 0xABE8, 0xABED, 0xFB1E, 0x101FD, 0x102E0, 0x10A3F, 0x11001, 0x11070, 0x110C2, 0x11173, 0x111CF, 0x11234, 0x1123E, 0x11241, 0x112DF, 0x11340, 0x113CE, 0x113D0, 0x113D2, 0x11446, 0x1145E, 0x114BA, 0x1163D, 0x116AB, 0x116AD, 0x116B7, 0x1171D, 0x1171F, 0x1193E, 0x11943, 0x119E0, 0x11A47, 0x11C3F, 0x11D3A, 0x11D47, 0x11D95, 0x11D97, 0x11F40, 0x11F42, 0x11F5A, 0x13440, 0x16F4F, 0x16FE4, 0x1DA75, 0x1DA84, 0x1E08F, 0x1E2AE);
    set.addRange(0x300, 0x36F).addRange(0x483, 0x487).addRange(0x591, 0x5BD).addRange(0x5C1, 0x5C2).addRange(0x5C4, 0x5C5).addRange(0x610, 0x61A).addRange(0x64B, 0x65F).addRange(0x6D6, 0x6DC).addRange(0x6DF, 0x6E4).addRange(0x6E7, 0x6E8).addRange(0x6EA, 0x6ED).addRange(0x730, 0x74A).addRange(0x7A6, 0x7B0).addRange(0x7EB, 0x7F3).addRange(0x816, 0x819).addRange(0x81B, 0x823).addRange(0x825, 0x827).addRange(0x829, 0x82D).addRange(0x859, 0x85B).addRange(0x897, 0x89F).addRange(0x8CA, 0x8E1).addRange(0x8E3, 0x902).addRange(0x941, 0x948).addRange(0x951, 0x957).addRange(0x962, 0x963).addRange(0x9C1, 0x9C4).addRange(0x9E2, 0x9E3).addRange(0xA01, 0xA02).addRange(0xA41, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA70, 0xA71).addRange(0xA81, 0xA82).addRange(0xAC1, 0xAC5).addRange(0xAC7, 0xAC8).addRange(0xAE2, 0xAE3).addRange(0xAFA, 0xAFF).addRange(0xB41, 0xB44).addRange(0xB55, 0xB56).addRange(0xB62, 0xB63).addRange(0xC3E, 0xC40).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC62, 0xC63).addRange(0xCCC, 0xCCD).addRange(0xCE2, 0xCE3).addRange(0xD00, 0xD01).addRange(0xD3B, 0xD3C).addRange(0xD41, 0xD44).addRange(0xD62, 0xD63);
    set.addRange(0xDD2, 0xDD4).addRange(0xE34, 0xE3A).addRange(0xE47, 0xE4E).addRange(0xEB4, 0xEBC).addRange(0xEC8, 0xECE).addRange(0xF18, 0xF19).addRange(0xF71, 0xF7E).addRange(0xF80, 0xF84).addRange(0xF86, 0xF87).addRange(0xF8D, 0xF97).addRange(0xF99, 0xFBC).addRange(0x102D, 0x1030).addRange(0x1032, 0x1037).addRange(0x1039, 0x103A).addRange(0x103D, 0x103E).addRange(0x1058, 0x1059).addRange(0x105E, 0x1060).addRange(0x1071, 0x1074).addRange(0x1085, 0x1086).addRange(0x135D, 0x135F).addRange(0x1712, 0x1714).addRange(0x1732, 0x1733).addRange(0x1752, 0x1753).addRange(0x1772, 0x1773).addRange(0x17B4, 0x17B5).addRange(0x17B7, 0x17BD).addRange(0x17C9, 0x17D3).addRange(0x180B, 0x180D).addRange(0x1885, 0x1886).addRange(0x1920, 0x1922).addRange(0x1927, 0x1928).addRange(0x1939, 0x193B).addRange(0x1A17, 0x1A18).addRange(0x1A58, 0x1A5E).addRange(0x1A65, 0x1A6C).addRange(0x1A73, 0x1A7C).addRange(0x1AB0, 0x1ABD).addRange(0x1ABF, 0x1ACE).addRange(0x1B00, 0x1B03).addRange(0x1B36, 0x1B3A).addRange(0x1B6B, 0x1B73).addRange(0x1B80, 0x1B81).addRange(0x1BA2, 0x1BA5).addRange(0x1BA8, 0x1BA9).addRange(0x1BAB, 0x1BAD).addRange(0x1BE8, 0x1BE9).addRange(0x1BEF, 0x1BF1).addRange(0x1C2C, 0x1C33).addRange(0x1C36, 0x1C37).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CE0);
    set.addRange(0x1CE2, 0x1CE8).addRange(0x1CF8, 0x1CF9).addRange(0x1DC0, 0x1DFF).addRange(0x20D0, 0x20DC).addRange(0x20E5, 0x20F0).addRange(0x2CEF, 0x2CF1).addRange(0x2DE0, 0x2DFF).addRange(0x302A, 0x302D).addRange(0x3099, 0x309A).addRange(0xA674, 0xA67D).addRange(0xA69E, 0xA69F).addRange(0xA6F0, 0xA6F1).addRange(0xA825, 0xA826).addRange(0xA8C4, 0xA8C5).addRange(0xA8E0, 0xA8F1).addRange(0xA926, 0xA92D).addRange(0xA947, 0xA951).addRange(0xA980, 0xA982).addRange(0xA9B6, 0xA9B9).addRange(0xA9BC, 0xA9BD).addRange(0xAA29, 0xAA2E).addRange(0xAA31, 0xAA32).addRange(0xAA35, 0xAA36).addRange(0xAAB2, 0xAAB4).addRange(0xAAB7, 0xAAB8).addRange(0xAABE, 0xAABF).addRange(0xAAEC, 0xAAED).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2F).addRange(0x10376, 0x1037A).addRange(0x10A01, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A0F).addRange(0x10A38, 0x10A3A).addRange(0x10AE5, 0x10AE6).addRange(0x10D24, 0x10D27).addRange(0x10D69, 0x10D6D).addRange(0x10EAB, 0x10EAC).addRange(0x10EFC, 0x10EFF).addRange(0x10F46, 0x10F50).addRange(0x10F82, 0x10F85).addRange(0x11038, 0x11046).addRange(0x11073, 0x11074).addRange(0x1107F, 0x11081).addRange(0x110B3, 0x110B6).addRange(0x110B9, 0x110BA).addRange(0x11100, 0x11102).addRange(0x11127, 0x1112B).addRange(0x1112D, 0x11134).addRange(0x11180, 0x11181).addRange(0x111B6, 0x111BE);
    set.addRange(0x111C9, 0x111CC).addRange(0x1122F, 0x11231).addRange(0x11236, 0x11237).addRange(0x112E3, 0x112EA).addRange(0x11300, 0x11301).addRange(0x1133B, 0x1133C).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x113BB, 0x113C0).addRange(0x113E1, 0x113E2).addRange(0x11438, 0x1143F).addRange(0x11442, 0x11444).addRange(0x114B3, 0x114B8).addRange(0x114BF, 0x114C0).addRange(0x114C2, 0x114C3).addRange(0x115B2, 0x115B5).addRange(0x115BC, 0x115BD).addRange(0x115BF, 0x115C0).addRange(0x115DC, 0x115DD).addRange(0x11633, 0x1163A).addRange(0x1163F, 0x11640).addRange(0x116B0, 0x116B5).addRange(0x11722, 0x11725).addRange(0x11727, 0x1172B).addRange(0x1182F, 0x11837).addRange(0x11839, 0x1183A).addRange(0x1193B, 0x1193C).addRange(0x119D4, 0x119D7).addRange(0x119DA, 0x119DB).addRange(0x11A01, 0x11A0A).addRange(0x11A33, 0x11A38).addRange(0x11A3B, 0x11A3E).addRange(0x11A51, 0x11A56).addRange(0x11A59, 0x11A5B).addRange(0x11A8A, 0x11A96).addRange(0x11A98, 0x11A99).addRange(0x11C30, 0x11C36).addRange(0x11C38, 0x11C3D).addRange(0x11C92, 0x11CA7).addRange(0x11CAA, 0x11CB0).addRange(0x11CB2, 0x11CB3).addRange(0x11CB5, 0x11CB6).addRange(0x11D31, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D45).addRange(0x11D90, 0x11D91).addRange(0x11EF3, 0x11EF4).addRange(0x11F00, 0x11F01).addRange(0x11F36, 0x11F3A).addRange(0x13447, 0x13455).addRange(0x1611E, 0x16129);
    set.addRange(0x1612D, 0x1612F).addRange(0x16AF0, 0x16AF4).addRange(0x16B30, 0x16B36).addRange(0x16F8F, 0x16F92).addRange(0x1BC9D, 0x1BC9E).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D167, 0x1D169).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0x1D242, 0x1D244).addRange(0x1DA00, 0x1DA36).addRange(0x1DA3B, 0x1DA6C).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A).addRange(0x1E130, 0x1E136).addRange(0x1E2EC, 0x1E2EF).addRange(0x1E4EC, 0x1E4EF).addRange(0x1E5EE, 0x1E5EF).addRange(0x1E8D0, 0x1E8D6).addRange(0x1E944, 0x1E94A).addRange(0xE0100, 0xE01EF);
    Nonspacing_Mark.characters = set;
    return Nonspacing_Mark;
  }

var _Number = {};

var hasRequired_Number;
  function require_Number() {
    if (hasRequired_Number) return _Number;
    hasRequired_Number = 1;
    var set = regenerateExports(0xB9, 0x2070, 0x2CFD, 0x3007, 0x10341, 0x1034A);
    set.addRange(0x30, 0x39).addRange(0xB2, 0xB3).addRange(0xBC, 0xBE).addRange(0x660, 0x669).addRange(0x6F0, 0x6F9).addRange(0x7C0, 0x7C9).addRange(0x966, 0x96F).addRange(0x9E6, 0x9EF).addRange(0x9F4, 0x9F9).addRange(0xA66, 0xA6F).addRange(0xAE6, 0xAEF).addRange(0xB66, 0xB6F).addRange(0xB72, 0xB77).addRange(0xBE6, 0xBF2).addRange(0xC66, 0xC6F).addRange(0xC78, 0xC7E).addRange(0xCE6, 0xCEF).addRange(0xD58, 0xD5E).addRange(0xD66, 0xD78).addRange(0xDE6, 0xDEF).addRange(0xE50, 0xE59).addRange(0xED0, 0xED9).addRange(0xF20, 0xF33).addRange(0x1040, 0x1049).addRange(0x1090, 0x1099).addRange(0x1369, 0x137C).addRange(0x16EE, 0x16F0).addRange(0x17E0, 0x17E9).addRange(0x17F0, 0x17F9).addRange(0x1810, 0x1819).addRange(0x1946, 0x194F).addRange(0x19D0, 0x19DA).addRange(0x1A80, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1B50, 0x1B59).addRange(0x1BB0, 0x1BB9).addRange(0x1C40, 0x1C49).addRange(0x1C50, 0x1C59).addRange(0x2074, 0x2079).addRange(0x2080, 0x2089).addRange(0x2150, 0x2182).addRange(0x2185, 0x2189).addRange(0x2460, 0x249B).addRange(0x24EA, 0x24FF).addRange(0x2776, 0x2793).addRange(0x3021, 0x3029).addRange(0x3038, 0x303A).addRange(0x3192, 0x3195).addRange(0x3220, 0x3229).addRange(0x3248, 0x324F).addRange(0x3251, 0x325F);
    set.addRange(0x3280, 0x3289).addRange(0x32B1, 0x32BF).addRange(0xA620, 0xA629).addRange(0xA6E6, 0xA6EF).addRange(0xA830, 0xA835).addRange(0xA8D0, 0xA8D9).addRange(0xA900, 0xA909).addRange(0xA9D0, 0xA9D9).addRange(0xA9F0, 0xA9F9).addRange(0xAA50, 0xAA59).addRange(0xABF0, 0xABF9).addRange(0xFF10, 0xFF19).addRange(0x10107, 0x10133).addRange(0x10140, 0x10178).addRange(0x1018A, 0x1018B).addRange(0x102E1, 0x102FB).addRange(0x10320, 0x10323).addRange(0x103D1, 0x103D5).addRange(0x104A0, 0x104A9).addRange(0x10858, 0x1085F).addRange(0x10879, 0x1087F).addRange(0x108A7, 0x108AF).addRange(0x108FB, 0x108FF).addRange(0x10916, 0x1091B).addRange(0x109BC, 0x109BD).addRange(0x109C0, 0x109CF).addRange(0x109D2, 0x109FF).addRange(0x10A40, 0x10A48).addRange(0x10A7D, 0x10A7E).addRange(0x10A9D, 0x10A9F).addRange(0x10AEB, 0x10AEF).addRange(0x10B58, 0x10B5F).addRange(0x10B78, 0x10B7F).addRange(0x10BA9, 0x10BAF).addRange(0x10CFA, 0x10CFF).addRange(0x10D30, 0x10D39).addRange(0x10D40, 0x10D49).addRange(0x10E60, 0x10E7E).addRange(0x10F1D, 0x10F26).addRange(0x10F51, 0x10F54).addRange(0x10FC5, 0x10FCB).addRange(0x11052, 0x1106F).addRange(0x110F0, 0x110F9).addRange(0x11136, 0x1113F).addRange(0x111D0, 0x111D9).addRange(0x111E1, 0x111F4).addRange(0x112F0, 0x112F9).addRange(0x11450, 0x11459).addRange(0x114D0, 0x114D9).addRange(0x11650, 0x11659).addRange(0x116C0, 0x116C9);
    set.addRange(0x116D0, 0x116E3).addRange(0x11730, 0x1173B).addRange(0x118E0, 0x118F2).addRange(0x11950, 0x11959).addRange(0x11BF0, 0x11BF9).addRange(0x11C50, 0x11C6C).addRange(0x11D50, 0x11D59).addRange(0x11DA0, 0x11DA9).addRange(0x11F50, 0x11F59).addRange(0x11FC0, 0x11FD4).addRange(0x12400, 0x1246E).addRange(0x16130, 0x16139).addRange(0x16A60, 0x16A69).addRange(0x16AC0, 0x16AC9).addRange(0x16B50, 0x16B59).addRange(0x16B5B, 0x16B61).addRange(0x16D70, 0x16D79).addRange(0x16E80, 0x16E96).addRange(0x1CCF0, 0x1CCF9).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D360, 0x1D378).addRange(0x1D7CE, 0x1D7FF).addRange(0x1E140, 0x1E149).addRange(0x1E2F0, 0x1E2F9).addRange(0x1E4F0, 0x1E4F9).addRange(0x1E5F1, 0x1E5FA).addRange(0x1E8C7, 0x1E8CF).addRange(0x1E950, 0x1E959).addRange(0x1EC71, 0x1ECAB).addRange(0x1ECAD, 0x1ECAF).addRange(0x1ECB1, 0x1ECB4).addRange(0x1ED01, 0x1ED2D).addRange(0x1ED2F, 0x1ED3D).addRange(0x1F100, 0x1F10C).addRange(0x1FBF0, 0x1FBF9);
    _Number.characters = set;
    return _Number;
  }

var Open_Punctuation = {};

var hasRequiredOpen_Punctuation;
  function requireOpen_Punctuation() {
    if (hasRequiredOpen_Punctuation) return Open_Punctuation;
    hasRequiredOpen_Punctuation = 1;
    var set = regenerateExports(0x28, 0x5B, 0x7B, 0xF3A, 0xF3C, 0x169B, 0x201A, 0x201E, 0x2045, 0x207D, 0x208D, 0x2308, 0x230A, 0x2329, 0x2768, 0x276A, 0x276C, 0x276E, 0x2770, 0x2772, 0x2774, 0x27C5, 0x27E6, 0x27E8, 0x27EA, 0x27EC, 0x27EE, 0x2983, 0x2985, 0x2987, 0x2989, 0x298B, 0x298D, 0x298F, 0x2991, 0x2993, 0x2995, 0x2997, 0x29D8, 0x29DA, 0x29FC, 0x2E22, 0x2E24, 0x2E26, 0x2E28, 0x2E42, 0x2E55, 0x2E57, 0x2E59, 0x2E5B, 0x3008, 0x300A, 0x300C, 0x300E, 0x3010, 0x3014, 0x3016, 0x3018, 0x301A, 0x301D, 0xFD3F, 0xFE17, 0xFE35, 0xFE37, 0xFE39, 0xFE3B, 0xFE3D, 0xFE3F, 0xFE41, 0xFE43, 0xFE47, 0xFE59, 0xFE5B, 0xFE5D, 0xFF08, 0xFF3B, 0xFF5B, 0xFF5F, 0xFF62);
    Open_Punctuation.characters = set;
    return Open_Punctuation;
  }

var Other_Letter = {};

var hasRequiredOther_Letter;
  function requireOther_Letter() {
    if (hasRequiredOther_Letter) return Other_Letter;
    hasRequiredOther_Letter = 1;
    var set = regenerateExports(0xAA, 0xBA, 0x1BB, 0x294, 0x6D5, 0x6FF, 0x710, 0x7B1, 0x93D, 0x950, 0x9B2, 0x9BD, 0x9CE, 0x9FC, 0xA5E, 0xABD, 0xAD0, 0xAF9, 0xB3D, 0xB71, 0xB83, 0xB9C, 0xBD0, 0xC3D, 0xC5D, 0xC80, 0xCBD, 0xD3D, 0xD4E, 0xDBD, 0xE84, 0xEA5, 0xEBD, 0xF00, 0x103F, 0x1061, 0x108E, 0x1258, 0x12C0, 0x17DC, 0x18AA, 0x1CFA, 0x3006, 0x303C, 0x309F, 0x30FF, 0xA66E, 0xA78F, 0xA7F7, 0xA8FB, 0xAA7A, 0xAAB1, 0xAAC0, 0xAAC2, 0xAAF2, 0xFB1D, 0xFB3E, 0x10808, 0x1083C, 0x10A00, 0x10D4F, 0x10F27, 0x11075, 0x11144, 0x11147, 0x11176, 0x111DA, 0x111DC, 0x11288, 0x1133D, 0x11350, 0x1138B, 0x1138E, 0x113B7, 0x113D1, 0x113D3, 0x114C7, 0x11644, 0x116B8, 0x11909, 0x1193F, 0x11941, 0x119E1, 0x119E3, 0x11A00, 0x11A3A, 0x11A50, 0x11A9D, 0x11C40, 0x11D46, 0x11D98, 0x11F02, 0x11FB0, 0x16F50, 0x1B132, 0x1B155, 0x1DF0A, 0x1E14E, 0x1E5F0, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E);
    set.addRange(0x1C0, 0x1C3).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F2).addRange(0x620, 0x63F).addRange(0x641, 0x64A).addRange(0x66E, 0x66F).addRange(0x671, 0x6D3).addRange(0x6EE, 0x6EF).addRange(0x6FA, 0x6FC).addRange(0x712, 0x72F).addRange(0x74D, 0x7A5).addRange(0x7CA, 0x7EA).addRange(0x800, 0x815).addRange(0x840, 0x858).addRange(0x860, 0x86A).addRange(0x870, 0x887).addRange(0x889, 0x88E).addRange(0x8A0, 0x8C8).addRange(0x904, 0x939).addRange(0x958, 0x961).addRange(0x972, 0x980).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E1).addRange(0x9F0, 0x9F1).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA59, 0xA5C).addRange(0xA72, 0xA74).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xAE0, 0xAE1).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39);
    set.addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB61).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xC05, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC58, 0xC5A).addRange(0xC60, 0xC61).addRange(0xC85, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCDD, 0xCDE).addRange(0xCE0, 0xCE1).addRange(0xCF1, 0xCF2).addRange(0xD04, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD3A).addRange(0xD54, 0xD56).addRange(0xD5F, 0xD61).addRange(0xD7A, 0xD7F).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xE01, 0xE30).addRange(0xE32, 0xE33).addRange(0xE40, 0xE45).addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEB0).addRange(0xEB2, 0xEB3).addRange(0xEC0, 0xEC4).addRange(0xEDC, 0xEDF).addRange(0xF40, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF88, 0xF8C).addRange(0x1000, 0x102A).addRange(0x1050, 0x1055).addRange(0x105A, 0x105D).addRange(0x1065, 0x1066);
    set.addRange(0x106E, 0x1070).addRange(0x1075, 0x1081).addRange(0x1100, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x1380, 0x138F).addRange(0x1401, 0x166C).addRange(0x166F, 0x167F).addRange(0x1681, 0x169A).addRange(0x16A0, 0x16EA).addRange(0x16F1, 0x16F8).addRange(0x1700, 0x1711).addRange(0x171F, 0x1731).addRange(0x1740, 0x1751).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1780, 0x17B3).addRange(0x1820, 0x1842).addRange(0x1844, 0x1878).addRange(0x1880, 0x1884).addRange(0x1887, 0x18A8).addRange(0x18B0, 0x18F5).addRange(0x1900, 0x191E).addRange(0x1950, 0x196D).addRange(0x1970, 0x1974).addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x1A00, 0x1A16).addRange(0x1A20, 0x1A54).addRange(0x1B05, 0x1B33).addRange(0x1B45, 0x1B4C).addRange(0x1B83, 0x1BA0).addRange(0x1BAE, 0x1BAF).addRange(0x1BBA, 0x1BE5).addRange(0x1C00, 0x1C23).addRange(0x1C4D, 0x1C4F).addRange(0x1C5A, 0x1C77).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF6);
    set.addRange(0x2135, 0x2138).addRange(0x2D30, 0x2D67).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0x3041, 0x3096).addRange(0x30A1, 0x30FA).addRange(0x3105, 0x312F).addRange(0x3131, 0x318E).addRange(0x31A0, 0x31BF).addRange(0x31F0, 0x31FF).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0xA014).addRange(0xA016, 0xA48C).addRange(0xA4D0, 0xA4F7).addRange(0xA500, 0xA60B).addRange(0xA610, 0xA61F).addRange(0xA62A, 0xA62B).addRange(0xA6A0, 0xA6E5).addRange(0xA7FB, 0xA801).addRange(0xA803, 0xA805).addRange(0xA807, 0xA80A).addRange(0xA80C, 0xA822).addRange(0xA840, 0xA873).addRange(0xA882, 0xA8B3).addRange(0xA8F2, 0xA8F7).addRange(0xA8FD, 0xA8FE).addRange(0xA90A, 0xA925).addRange(0xA930, 0xA946).addRange(0xA960, 0xA97C).addRange(0xA984, 0xA9B2).addRange(0xA9E0, 0xA9E4).addRange(0xA9E7, 0xA9EF).addRange(0xA9FA, 0xA9FE).addRange(0xAA00, 0xAA28).addRange(0xAA40, 0xAA42).addRange(0xAA44, 0xAA4B).addRange(0xAA60, 0xAA6F).addRange(0xAA71, 0xAA76).addRange(0xAA7E, 0xAAAF).addRange(0xAAB5, 0xAAB6).addRange(0xAAB9, 0xAABD).addRange(0xAADB, 0xAADC).addRange(0xAAE0, 0xAAEA).addRange(0xAB01, 0xAB06);
    set.addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0xABC0, 0xABE2).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFB1F, 0xFB28).addRange(0xFB2A, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFBB1).addRange(0xFBD3, 0xFD3D).addRange(0xFD50, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFB).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0xFF66, 0xFF6F).addRange(0xFF71, 0xFF9D).addRange(0xFFA0, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC).addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10280, 0x1029C).addRange(0x102A0, 0x102D0).addRange(0x10300, 0x1031F).addRange(0x1032D, 0x10340).addRange(0x10342, 0x10349).addRange(0x10350, 0x10375).addRange(0x10380, 0x1039D).addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103CF).addRange(0x10450, 0x1049D).addRange(0x10500, 0x10527).addRange(0x10530, 0x10563).addRange(0x105C0, 0x105F3).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755);
    set.addRange(0x10760, 0x10767).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838).addRange(0x1083F, 0x10855).addRange(0x10860, 0x10876).addRange(0x10880, 0x1089E).addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x10900, 0x10915).addRange(0x10920, 0x10939).addRange(0x10980, 0x109B7).addRange(0x109BE, 0x109BF).addRange(0x10A10, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A60, 0x10A7C).addRange(0x10A80, 0x10A9C).addRange(0x10AC0, 0x10AC7).addRange(0x10AC9, 0x10AE4).addRange(0x10B00, 0x10B35).addRange(0x10B40, 0x10B55).addRange(0x10B60, 0x10B72).addRange(0x10B80, 0x10B91).addRange(0x10C00, 0x10C48).addRange(0x10D00, 0x10D23).addRange(0x10D4A, 0x10D4D).addRange(0x10E80, 0x10EA9).addRange(0x10EB0, 0x10EB1).addRange(0x10EC2, 0x10EC4).addRange(0x10F00, 0x10F1C).addRange(0x10F30, 0x10F45).addRange(0x10F70, 0x10F81).addRange(0x10FB0, 0x10FC4).addRange(0x10FE0, 0x10FF6).addRange(0x11003, 0x11037).addRange(0x11071, 0x11072).addRange(0x11083, 0x110AF).addRange(0x110D0, 0x110E8).addRange(0x11103, 0x11126).addRange(0x11150, 0x11172).addRange(0x11183, 0x111B2).addRange(0x111C1, 0x111C4).addRange(0x11200, 0x11211).addRange(0x11213, 0x1122B).addRange(0x1123F, 0x11240).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A8).addRange(0x112B0, 0x112DE);
    set.addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1135D, 0x11361).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x11400, 0x11434).addRange(0x11447, 0x1144A).addRange(0x1145F, 0x11461).addRange(0x11480, 0x114AF).addRange(0x114C4, 0x114C5).addRange(0x11580, 0x115AE).addRange(0x115D8, 0x115DB).addRange(0x11600, 0x1162F).addRange(0x11680, 0x116AA).addRange(0x11700, 0x1171A).addRange(0x11740, 0x11746).addRange(0x11800, 0x1182B).addRange(0x118FF, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x1192F).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D0).addRange(0x11A0B, 0x11A32).addRange(0x11A5C, 0x11A89).addRange(0x11AB0, 0x11AF8).addRange(0x11BC0, 0x11BE0).addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C2E).addRange(0x11C72, 0x11C8F).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D30).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D89).addRange(0x11EE0, 0x11EF2).addRange(0x11F04, 0x11F10).addRange(0x11F12, 0x11F33).addRange(0x12000, 0x12399).addRange(0x12480, 0x12543).addRange(0x12F90, 0x12FF0).addRange(0x13000, 0x1342F).addRange(0x13441, 0x13446).addRange(0x13460, 0x143FA).addRange(0x14400, 0x14646).addRange(0x16100, 0x1611D);
    set.addRange(0x16800, 0x16A38).addRange(0x16A40, 0x16A5E).addRange(0x16A70, 0x16ABE).addRange(0x16AD0, 0x16AED).addRange(0x16B00, 0x16B2F).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F).addRange(0x16D43, 0x16D6A).addRange(0x16F00, 0x16F4A).addRange(0x17000, 0x187F7).addRange(0x18800, 0x18CD5).addRange(0x18CFF, 0x18D08).addRange(0x1B000, 0x1B122).addRange(0x1B150, 0x1B152).addRange(0x1B164, 0x1B167).addRange(0x1B170, 0x1B2FB).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1E100, 0x1E12C).addRange(0x1E290, 0x1E2AD).addRange(0x1E2C0, 0x1E2EB).addRange(0x1E4D0, 0x1E4EA).addRange(0x1E5D0, 0x1E5ED).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE).addRange(0x1E800, 0x1E8C4).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1);
    set.addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF);
    Other_Letter.characters = set;
    return Other_Letter;
  }

var Other_Number = {};

var hasRequiredOther_Number;
  function requireOther_Number() {
    if (hasRequiredOther_Number) return Other_Number;
    hasRequiredOther_Number = 1;
    var set = regenerateExports(0xB9, 0x19DA, 0x2070, 0x2189, 0x2CFD);
    set.addRange(0xB2, 0xB3).addRange(0xBC, 0xBE).addRange(0x9F4, 0x9F9).addRange(0xB72, 0xB77).addRange(0xBF0, 0xBF2).addRange(0xC78, 0xC7E).addRange(0xD58, 0xD5E).addRange(0xD70, 0xD78).addRange(0xF2A, 0xF33).addRange(0x1369, 0x137C).addRange(0x17F0, 0x17F9).addRange(0x2074, 0x2079).addRange(0x2080, 0x2089).addRange(0x2150, 0x215F).addRange(0x2460, 0x249B).addRange(0x24EA, 0x24FF).addRange(0x2776, 0x2793).addRange(0x3192, 0x3195).addRange(0x3220, 0x3229).addRange(0x3248, 0x324F).addRange(0x3251, 0x325F).addRange(0x3280, 0x3289).addRange(0x32B1, 0x32BF).addRange(0xA830, 0xA835).addRange(0x10107, 0x10133).addRange(0x10175, 0x10178).addRange(0x1018A, 0x1018B).addRange(0x102E1, 0x102FB).addRange(0x10320, 0x10323).addRange(0x10858, 0x1085F).addRange(0x10879, 0x1087F).addRange(0x108A7, 0x108AF).addRange(0x108FB, 0x108FF).addRange(0x10916, 0x1091B).addRange(0x109BC, 0x109BD).addRange(0x109C0, 0x109CF).addRange(0x109D2, 0x109FF).addRange(0x10A40, 0x10A48).addRange(0x10A7D, 0x10A7E).addRange(0x10A9D, 0x10A9F).addRange(0x10AEB, 0x10AEF).addRange(0x10B58, 0x10B5F).addRange(0x10B78, 0x10B7F).addRange(0x10BA9, 0x10BAF).addRange(0x10CFA, 0x10CFF).addRange(0x10E60, 0x10E7E).addRange(0x10F1D, 0x10F26).addRange(0x10F51, 0x10F54).addRange(0x10FC5, 0x10FCB).addRange(0x11052, 0x11065).addRange(0x111E1, 0x111F4);
    set.addRange(0x1173A, 0x1173B).addRange(0x118EA, 0x118F2).addRange(0x11C5A, 0x11C6C).addRange(0x11FC0, 0x11FD4).addRange(0x16B5B, 0x16B61).addRange(0x16E80, 0x16E96).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D360, 0x1D378).addRange(0x1E8C7, 0x1E8CF).addRange(0x1EC71, 0x1ECAB).addRange(0x1ECAD, 0x1ECAF).addRange(0x1ECB1, 0x1ECB4).addRange(0x1ED01, 0x1ED2D).addRange(0x1ED2F, 0x1ED3D).addRange(0x1F100, 0x1F10C);
    Other_Number.characters = set;
    return Other_Number;
  }

var Other_Punctuation = {};

var hasRequiredOther_Punctuation;
  function requireOther_Punctuation() {
    if (hasRequiredOther_Punctuation) return Other_Punctuation;
    hasRequiredOther_Punctuation = 1;
    var set = regenerateExports(0x2A, 0x2C, 0x5C, 0xA1, 0xA7, 0xBF, 0x37E, 0x387, 0x589, 0x5C0, 0x5C3, 0x5C6, 0x61B, 0x6D4, 0x85E, 0x970, 0x9FD, 0xA76, 0xAF0, 0xC77, 0xC84, 0xDF4, 0xE4F, 0xF14, 0xF85, 0x10FB, 0x166E, 0x1CD3, 0x2053, 0x2D70, 0x2E0B, 0x2E1B, 0x2E41, 0x303D, 0x30FB, 0xA673, 0xA67E, 0xA8FC, 0xA95F, 0xABEB, 0xFE19, 0xFE30, 0xFE68, 0xFF0A, 0xFF0C, 0xFF3C, 0xFF61, 0x1039F, 0x103D0, 0x1056F, 0x10857, 0x1091F, 0x1093F, 0x10A7F, 0x111CD, 0x111DB, 0x112A9, 0x1145D, 0x114C6, 0x116B9, 0x1183B, 0x119E2, 0x11BE1, 0x11FFF, 0x16AF5, 0x16B44, 0x16FE2, 0x1BC9F, 0x1E5FF);
    set.addRange(0x21, 0x23).addRange(0x25, 0x27).addRange(0x2E, 0x2F).addRange(0x3A, 0x3B).addRange(0x3F, 0x40).addRange(0xB6, 0xB7).addRange(0x55A, 0x55F).addRange(0x5F3, 0x5F4).addRange(0x609, 0x60A).addRange(0x60C, 0x60D).addRange(0x61D, 0x61F).addRange(0x66A, 0x66D).addRange(0x700, 0x70D).addRange(0x7F7, 0x7F9).addRange(0x830, 0x83E).addRange(0x964, 0x965).addRange(0xE5A, 0xE5B).addRange(0xF04, 0xF12).addRange(0xFD0, 0xFD4).addRange(0xFD9, 0xFDA).addRange(0x104A, 0x104F).addRange(0x1360, 0x1368).addRange(0x16EB, 0x16ED).addRange(0x1735, 0x1736).addRange(0x17D4, 0x17D6).addRange(0x17D8, 0x17DA).addRange(0x1800, 0x1805).addRange(0x1807, 0x180A).addRange(0x1944, 0x1945).addRange(0x1A1E, 0x1A1F).addRange(0x1AA0, 0x1AA6).addRange(0x1AA8, 0x1AAD).addRange(0x1B4E, 0x1B4F).addRange(0x1B5A, 0x1B60).addRange(0x1B7D, 0x1B7F).addRange(0x1BFC, 0x1BFF).addRange(0x1C3B, 0x1C3F).addRange(0x1C7E, 0x1C7F).addRange(0x1CC0, 0x1CC7).addRange(0x2016, 0x2017).addRange(0x2020, 0x2027).addRange(0x2030, 0x2038).addRange(0x203B, 0x203E).addRange(0x2041, 0x2043).addRange(0x2047, 0x2051).addRange(0x2055, 0x205E).addRange(0x2CF9, 0x2CFC).addRange(0x2CFE, 0x2CFF).addRange(0x2E00, 0x2E01).addRange(0x2E06, 0x2E08).addRange(0x2E0E, 0x2E16);
    set.addRange(0x2E18, 0x2E19).addRange(0x2E1E, 0x2E1F).addRange(0x2E2A, 0x2E2E).addRange(0x2E30, 0x2E39).addRange(0x2E3C, 0x2E3F).addRange(0x2E43, 0x2E4F).addRange(0x2E52, 0x2E54).addRange(0x3001, 0x3003).addRange(0xA4FE, 0xA4FF).addRange(0xA60D, 0xA60F).addRange(0xA6F2, 0xA6F7).addRange(0xA874, 0xA877).addRange(0xA8CE, 0xA8CF).addRange(0xA8F8, 0xA8FA).addRange(0xA92E, 0xA92F).addRange(0xA9C1, 0xA9CD).addRange(0xA9DE, 0xA9DF).addRange(0xAA5C, 0xAA5F).addRange(0xAADE, 0xAADF).addRange(0xAAF0, 0xAAF1).addRange(0xFE10, 0xFE16).addRange(0xFE45, 0xFE46).addRange(0xFE49, 0xFE4C).addRange(0xFE50, 0xFE52).addRange(0xFE54, 0xFE57).addRange(0xFE5F, 0xFE61).addRange(0xFE6A, 0xFE6B).addRange(0xFF01, 0xFF03).addRange(0xFF05, 0xFF07).addRange(0xFF0E, 0xFF0F).addRange(0xFF1A, 0xFF1B).addRange(0xFF1F, 0xFF20).addRange(0xFF64, 0xFF65).addRange(0x10100, 0x10102).addRange(0x10A50, 0x10A58).addRange(0x10AF0, 0x10AF6).addRange(0x10B39, 0x10B3F).addRange(0x10B99, 0x10B9C).addRange(0x10F55, 0x10F59).addRange(0x10F86, 0x10F89).addRange(0x11047, 0x1104D).addRange(0x110BB, 0x110BC).addRange(0x110BE, 0x110C1).addRange(0x11140, 0x11143).addRange(0x11174, 0x11175).addRange(0x111C5, 0x111C8).addRange(0x111DD, 0x111DF).addRange(0x11238, 0x1123D).addRange(0x113D4, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x1144B, 0x1144F);
    set.addRange(0x1145A, 0x1145B).addRange(0x115C1, 0x115D7).addRange(0x11641, 0x11643).addRange(0x11660, 0x1166C).addRange(0x1173C, 0x1173E).addRange(0x11944, 0x11946).addRange(0x11A3F, 0x11A46).addRange(0x11A9A, 0x11A9C).addRange(0x11A9E, 0x11AA2).addRange(0x11B00, 0x11B09).addRange(0x11C41, 0x11C45).addRange(0x11C70, 0x11C71).addRange(0x11EF7, 0x11EF8).addRange(0x11F43, 0x11F4F).addRange(0x12470, 0x12474).addRange(0x12FF1, 0x12FF2).addRange(0x16A6E, 0x16A6F).addRange(0x16B37, 0x16B3B).addRange(0x16D6D, 0x16D6F).addRange(0x16E97, 0x16E9A).addRange(0x1DA87, 0x1DA8B).addRange(0x1E95E, 0x1E95F);
    Other_Punctuation.characters = set;
    return Other_Punctuation;
  }

var Other_Symbol = {};

var hasRequiredOther_Symbol;
  function requireOther_Symbol() {
    if (hasRequiredOther_Symbol) return Other_Symbol;
    hasRequiredOther_Symbol = 1;
    var set = regenerateExports(0xA6, 0xA9, 0xAE, 0xB0, 0x482, 0x6DE, 0x6E9, 0x7F6, 0x9FA, 0xB70, 0xBFA, 0xC7F, 0xD4F, 0xD79, 0xF13, 0xF34, 0xF36, 0xF38, 0x166D, 0x1940, 0x2114, 0x2125, 0x2127, 0x2129, 0x212E, 0x214A, 0x214F, 0x21D3, 0x3004, 0x3020, 0x31EF, 0x3250, 0xA839, 0xFDCF, 0xFFE4, 0xFFE8, 0x101A0, 0x10AC8, 0x1173F, 0x16B45, 0x1BC9C, 0x1D245, 0x1E14F, 0x1ECAC, 0x1ED2E, 0x1F7F0);
    set.addRange(0x58D, 0x58E).addRange(0x60E, 0x60F).addRange(0x6FD, 0x6FE).addRange(0xBF3, 0xBF8).addRange(0xF01, 0xF03).addRange(0xF15, 0xF17).addRange(0xF1A, 0xF1F).addRange(0xFBE, 0xFC5).addRange(0xFC7, 0xFCC).addRange(0xFCE, 0xFCF).addRange(0xFD5, 0xFD8).addRange(0x109E, 0x109F).addRange(0x1390, 0x1399).addRange(0x19DE, 0x19FF).addRange(0x1B61, 0x1B6A).addRange(0x1B74, 0x1B7C).addRange(0x2100, 0x2101).addRange(0x2103, 0x2106).addRange(0x2108, 0x2109).addRange(0x2116, 0x2117).addRange(0x211E, 0x2123).addRange(0x213A, 0x213B).addRange(0x214C, 0x214D).addRange(0x218A, 0x218B).addRange(0x2195, 0x2199).addRange(0x219C, 0x219F).addRange(0x21A1, 0x21A2).addRange(0x21A4, 0x21A5).addRange(0x21A7, 0x21AD).addRange(0x21AF, 0x21CD).addRange(0x21D0, 0x21D1).addRange(0x21D5, 0x21F3).addRange(0x2300, 0x2307).addRange(0x230C, 0x231F).addRange(0x2322, 0x2328).addRange(0x232B, 0x237B).addRange(0x237D, 0x239A).addRange(0x23B4, 0x23DB).addRange(0x23E2, 0x2429).addRange(0x2440, 0x244A).addRange(0x249C, 0x24E9).addRange(0x2500, 0x25B6).addRange(0x25B8, 0x25C0).addRange(0x25C2, 0x25F7).addRange(0x2600, 0x266E).addRange(0x2670, 0x2767).addRange(0x2794, 0x27BF).addRange(0x2800, 0x28FF).addRange(0x2B00, 0x2B2F).addRange(0x2B45, 0x2B46).addRange(0x2B4D, 0x2B73);
    set.addRange(0x2B76, 0x2B95).addRange(0x2B97, 0x2BFF).addRange(0x2CE5, 0x2CEA).addRange(0x2E50, 0x2E51).addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x2FF0, 0x2FFF).addRange(0x3012, 0x3013).addRange(0x3036, 0x3037).addRange(0x303E, 0x303F).addRange(0x3190, 0x3191).addRange(0x3196, 0x319F).addRange(0x31C0, 0x31E5).addRange(0x3200, 0x321E).addRange(0x322A, 0x3247).addRange(0x3260, 0x327F).addRange(0x328A, 0x32B0).addRange(0x32C0, 0x33FF).addRange(0x4DC0, 0x4DFF).addRange(0xA490, 0xA4C6).addRange(0xA828, 0xA82B).addRange(0xA836, 0xA837).addRange(0xAA77, 0xAA79).addRange(0xFD40, 0xFD4F).addRange(0xFDFD, 0xFDFF).addRange(0xFFED, 0xFFEE).addRange(0xFFFC, 0xFFFD).addRange(0x10137, 0x1013F).addRange(0x10179, 0x10189).addRange(0x1018C, 0x1018E).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FC).addRange(0x10877, 0x10878).addRange(0x11FD5, 0x11FDC).addRange(0x11FE1, 0x11FF1).addRange(0x16B3C, 0x16B3F).addRange(0x1CC00, 0x1CCEF).addRange(0x1CD00, 0x1CEB3).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D164).addRange(0x1D16A, 0x1D16C).addRange(0x1D183, 0x1D184).addRange(0x1D18C, 0x1D1A9).addRange(0x1D1AE, 0x1D1EA).addRange(0x1D200, 0x1D241).addRange(0x1D300, 0x1D356).addRange(0x1D800, 0x1D9FF).addRange(0x1DA37, 0x1DA3A);
    set.addRange(0x1DA6D, 0x1DA74).addRange(0x1DA76, 0x1DA83).addRange(0x1DA85, 0x1DA86).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093).addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF).addRange(0x1F0D1, 0x1F0F5).addRange(0x1F10D, 0x1F1AD).addRange(0x1F1E6, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F250, 0x1F251).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F3FA).addRange(0x1F400, 0x1F6D7).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F776).addRange(0x1F77B, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F900, 0x1FA53).addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA89).addRange(0x1FA8F, 0x1FAC6).addRange(0x1FACE, 0x1FADC).addRange(0x1FADF, 0x1FAE9).addRange(0x1FAF0, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBEF);
    Other_Symbol.characters = set;
    return Other_Symbol;
  }

var Other = {};

var hasRequiredOther;
  function requireOther() {
    if (hasRequiredOther) return Other;
    hasRequiredOther = 1;
    var set = regenerateExports(0xAD, 0x38B, 0x38D, 0x3A2, 0x530, 0x590, 0x61C, 0x6DD, 0x83F, 0x85F, 0x8E2, 0x984, 0x9A9, 0x9B1, 0x9DE, 0xA04, 0xA29, 0xA31, 0xA34, 0xA37, 0xA3D, 0xA5D, 0xA84, 0xA8E, 0xA92, 0xAA9, 0xAB1, 0xAB4, 0xAC6, 0xACA, 0xB00, 0xB04, 0xB29, 0xB31, 0xB34, 0xB5E, 0xB84, 0xB91, 0xB9B, 0xB9D, 0xBC9, 0xC0D, 0xC11, 0xC29, 0xC45, 0xC49, 0xC57, 0xC8D, 0xC91, 0xCA9, 0xCB4, 0xCC5, 0xCC9, 0xCDF, 0xCF0, 0xD0D, 0xD11, 0xD45, 0xD49, 0xD80, 0xD84, 0xDB2, 0xDBC, 0xDD5, 0xDD7, 0xE83, 0xE85, 0xE8B, 0xEA4, 0xEA6, 0xEC5, 0xEC7, 0xECF, 0xF48, 0xF98, 0xFBD, 0xFCD, 0x10C6, 0x1249, 0x1257, 0x1259, 0x1289, 0x12B1, 0x12BF, 0x12C1, 0x12D7, 0x1311, 0x176D, 0x1771, 0x180E, 0x191F, 0x1A5F, 0x1B4D, 0x1F58, 0x1F5A, 0x1F5C, 0x1F5E, 0x1FB5, 0x1FC5, 0x1FDC, 0x1FF5, 0x1FFF, 0x208F, 0x2B96, 0x2D26, 0x2DA7, 0x2DAF, 0x2DB7, 0x2DBF, 0x2DC7, 0x2DCF, 0x2DD7, 0x2DDF, 0x2E9A, 0x3040, 0x3130, 0x318F, 0x321F, 0xA7D2, 0xA7D4, 0xA9CE, 0xA9FF, 0xAB27, 0xAB2F, 0xFB37, 0xFB3D, 0xFB3F, 0xFB42, 0xFB45, 0xFE53, 0xFE67, 0xFE75, 0xFFE7, 0x1000C, 0x10027, 0x1003B, 0x1003E, 0x1018F, 0x1039E, 0x1057B, 0x1058B, 0x10593, 0x10596, 0x105A2, 0x105B2, 0x105BA, 0x10786, 0x107B1, 0x10809, 0x10836, 0x10856, 0x108F3, 0x10A04, 0x10A14, 0x10A18, 0x10E7F, 0x10EAA, 0x110BD, 0x11135, 0x111E0, 0x11212, 0x11287, 0x11289, 0x1128E, 0x1129E, 0x11304, 0x11329, 0x11331, 0x11334, 0x1133A, 0x1138A, 0x1138F, 0x113B6, 0x113C1, 0x113C6, 0x113CB, 0x113D6, 0x1145C, 0x11914, 0x11917, 0x11936, 0x11C09, 0x11C37, 0x11CA8, 0x11D07, 0x11D0A, 0x11D3B, 0x11D3E, 0x11D66, 0x11D69, 0x11D8F, 0x11D92, 0x11F11, 0x1246F, 0x16A5F, 0x16ABF, 0x16B5A, 0x16B62, 0x1AFF4, 0x1AFFC, 0x1AFFF, 0x1D455, 0x1D49D, 0x1D4AD, 0x1D4BA, 0x1D4BC, 0x1D4C4, 0x1D506, 0x1D515, 0x1D51D, 0x1D53A, 0x1D53F, 0x1D545, 0x1D551, 0x1DAA0, 0x1E007, 0x1E022, 0x1E025, 0x1E7E7, 0x1E7EC, 0x1E7EF, 0x1E7FF, 0x1EE04, 0x1EE20, 0x1EE23, 0x1EE28, 0x1EE33, 0x1EE38, 0x1EE3A, 0x1EE48, 0x1EE4A, 0x1EE4C, 0x1EE50, 0x1EE53, 0x1EE58, 0x1EE5A, 0x1EE5C, 0x1EE5E, 0x1EE60, 0x1EE63, 0x1EE6B, 0x1EE73, 0x1EE78, 0x1EE7D, 0x1EE7F, 0x1EE8A, 0x1EEA4, 0x1EEAA, 0x1F0C0, 0x1F0D0, 0x1FB93);
    set.addRange(0x0, 0x1F).addRange(0x7F, 0x9F).addRange(0x378, 0x379).addRange(0x380, 0x383).addRange(0x557, 0x558).addRange(0x58B, 0x58C).addRange(0x5C8, 0x5CF).addRange(0x5EB, 0x5EE).addRange(0x5F5, 0x605).addRange(0x70E, 0x70F).addRange(0x74B, 0x74C).addRange(0x7B2, 0x7BF).addRange(0x7FB, 0x7FC).addRange(0x82E, 0x82F).addRange(0x85C, 0x85D).addRange(0x86B, 0x86F).addRange(0x88F, 0x896).addRange(0x98D, 0x98E).addRange(0x991, 0x992).addRange(0x9B3, 0x9B5).addRange(0x9BA, 0x9BB).addRange(0x9C5, 0x9C6).addRange(0x9C9, 0x9CA).addRange(0x9CF, 0x9D6).addRange(0x9D8, 0x9DB).addRange(0x9E4, 0x9E5).addRange(0x9FF, 0xA00).addRange(0xA0B, 0xA0E).addRange(0xA11, 0xA12).addRange(0xA3A, 0xA3B).addRange(0xA43, 0xA46).addRange(0xA49, 0xA4A).addRange(0xA4E, 0xA50).addRange(0xA52, 0xA58).addRange(0xA5F, 0xA65).addRange(0xA77, 0xA80).addRange(0xABA, 0xABB).addRange(0xACE, 0xACF).addRange(0xAD1, 0xADF).addRange(0xAE4, 0xAE5).addRange(0xAF2, 0xAF8).addRange(0xB0D, 0xB0E).addRange(0xB11, 0xB12).addRange(0xB3A, 0xB3B).addRange(0xB45, 0xB46).addRange(0xB49, 0xB4A).addRange(0xB4E, 0xB54).addRange(0xB58, 0xB5B).addRange(0xB64, 0xB65).addRange(0xB78, 0xB81).addRange(0xB8B, 0xB8D);
    set.addRange(0xB96, 0xB98).addRange(0xBA0, 0xBA2).addRange(0xBA5, 0xBA7).addRange(0xBAB, 0xBAD).addRange(0xBBA, 0xBBD).addRange(0xBC3, 0xBC5).addRange(0xBCE, 0xBCF).addRange(0xBD1, 0xBD6).addRange(0xBD8, 0xBE5).addRange(0xBFB, 0xBFF).addRange(0xC3A, 0xC3B).addRange(0xC4E, 0xC54).addRange(0xC5B, 0xC5C).addRange(0xC5E, 0xC5F).addRange(0xC64, 0xC65).addRange(0xC70, 0xC76).addRange(0xCBA, 0xCBB).addRange(0xCCE, 0xCD4).addRange(0xCD7, 0xCDC).addRange(0xCE4, 0xCE5).addRange(0xCF4, 0xCFF).addRange(0xD50, 0xD53).addRange(0xD64, 0xD65).addRange(0xD97, 0xD99).addRange(0xDBE, 0xDBF).addRange(0xDC7, 0xDC9).addRange(0xDCB, 0xDCE).addRange(0xDE0, 0xDE5).addRange(0xDF0, 0xDF1).addRange(0xDF5, 0xE00).addRange(0xE3B, 0xE3E).addRange(0xE5C, 0xE80).addRange(0xEBE, 0xEBF).addRange(0xEDA, 0xEDB).addRange(0xEE0, 0xEFF).addRange(0xF6D, 0xF70).addRange(0xFDB, 0xFFF).addRange(0x10C8, 0x10CC).addRange(0x10CE, 0x10CF).addRange(0x124E, 0x124F).addRange(0x125E, 0x125F).addRange(0x128E, 0x128F).addRange(0x12B6, 0x12B7).addRange(0x12C6, 0x12C7).addRange(0x1316, 0x1317).addRange(0x135B, 0x135C).addRange(0x137D, 0x137F).addRange(0x139A, 0x139F).addRange(0x13F6, 0x13F7).addRange(0x13FE, 0x13FF).addRange(0x169D, 0x169F);
    set.addRange(0x16F9, 0x16FF).addRange(0x1716, 0x171E).addRange(0x1737, 0x173F).addRange(0x1754, 0x175F).addRange(0x1774, 0x177F).addRange(0x17DE, 0x17DF).addRange(0x17EA, 0x17EF).addRange(0x17FA, 0x17FF).addRange(0x181A, 0x181F).addRange(0x1879, 0x187F).addRange(0x18AB, 0x18AF).addRange(0x18F6, 0x18FF).addRange(0x192C, 0x192F).addRange(0x193C, 0x193F).addRange(0x1941, 0x1943).addRange(0x196E, 0x196F).addRange(0x1975, 0x197F).addRange(0x19AC, 0x19AF).addRange(0x19CA, 0x19CF).addRange(0x19DB, 0x19DD).addRange(0x1A1C, 0x1A1D).addRange(0x1A7D, 0x1A7E).addRange(0x1A8A, 0x1A8F).addRange(0x1A9A, 0x1A9F).addRange(0x1AAE, 0x1AAF).addRange(0x1ACF, 0x1AFF).addRange(0x1BF4, 0x1BFB).addRange(0x1C38, 0x1C3A).addRange(0x1C4A, 0x1C4C).addRange(0x1C8B, 0x1C8F).addRange(0x1CBB, 0x1CBC).addRange(0x1CC8, 0x1CCF).addRange(0x1CFB, 0x1CFF).addRange(0x1F16, 0x1F17).addRange(0x1F1E, 0x1F1F).addRange(0x1F46, 0x1F47).addRange(0x1F4E, 0x1F4F).addRange(0x1F7E, 0x1F7F).addRange(0x1FD4, 0x1FD5).addRange(0x1FF0, 0x1FF1).addRange(0x200B, 0x200F).addRange(0x202A, 0x202E).addRange(0x2060, 0x206F).addRange(0x2072, 0x2073).addRange(0x209D, 0x209F).addRange(0x20C1, 0x20CF).addRange(0x20F1, 0x20FF).addRange(0x218C, 0x218F).addRange(0x242A, 0x243F).addRange(0x244B, 0x245F).addRange(0x2B74, 0x2B75);
    set.addRange(0x2CF4, 0x2CF8).addRange(0x2D28, 0x2D2C).addRange(0x2D2E, 0x2D2F).addRange(0x2D68, 0x2D6E).addRange(0x2D71, 0x2D7E).addRange(0x2D97, 0x2D9F).addRange(0x2E5E, 0x2E7F).addRange(0x2EF4, 0x2EFF).addRange(0x2FD6, 0x2FEF).addRange(0x3097, 0x3098).addRange(0x3100, 0x3104).addRange(0x31E6, 0x31EE).addRange(0xA48D, 0xA48F).addRange(0xA4C7, 0xA4CF).addRange(0xA62C, 0xA63F).addRange(0xA6F8, 0xA6FF).addRange(0xA7CE, 0xA7CF).addRange(0xA7DD, 0xA7F1).addRange(0xA82D, 0xA82F).addRange(0xA83A, 0xA83F).addRange(0xA878, 0xA87F).addRange(0xA8C6, 0xA8CD).addRange(0xA8DA, 0xA8DF).addRange(0xA954, 0xA95E).addRange(0xA97D, 0xA97F).addRange(0xA9DA, 0xA9DD).addRange(0xAA37, 0xAA3F).addRange(0xAA4E, 0xAA4F).addRange(0xAA5A, 0xAA5B).addRange(0xAAC3, 0xAADA).addRange(0xAAF7, 0xAB00).addRange(0xAB07, 0xAB08).addRange(0xAB0F, 0xAB10).addRange(0xAB17, 0xAB1F).addRange(0xAB6C, 0xAB6F).addRange(0xABEE, 0xABEF).addRange(0xABFA, 0xABFF).addRange(0xD7A4, 0xD7AF).addRange(0xD7C7, 0xD7CA).addRange(0xD7FC, 0xF8FF).addRange(0xFA6E, 0xFA6F).addRange(0xFADA, 0xFAFF).addRange(0xFB07, 0xFB12).addRange(0xFB18, 0xFB1C).addRange(0xFBC3, 0xFBD2).addRange(0xFD90, 0xFD91).addRange(0xFDC8, 0xFDCE).addRange(0xFDD0, 0xFDEF).addRange(0xFE1A, 0xFE1F).addRange(0xFE6C, 0xFE6F).addRange(0xFEFD, 0xFF00);
    set.addRange(0xFFBF, 0xFFC1).addRange(0xFFC8, 0xFFC9).addRange(0xFFD0, 0xFFD1).addRange(0xFFD8, 0xFFD9).addRange(0xFFDD, 0xFFDF).addRange(0xFFEF, 0xFFFB).addRange(0xFFFE, 0xFFFF).addRange(0x1004E, 0x1004F).addRange(0x1005E, 0x1007F).addRange(0x100FB, 0x100FF).addRange(0x10103, 0x10106).addRange(0x10134, 0x10136).addRange(0x1019D, 0x1019F).addRange(0x101A1, 0x101CF).addRange(0x101FE, 0x1027F).addRange(0x1029D, 0x1029F).addRange(0x102D1, 0x102DF).addRange(0x102FC, 0x102FF).addRange(0x10324, 0x1032C).addRange(0x1034B, 0x1034F).addRange(0x1037B, 0x1037F).addRange(0x103C4, 0x103C7).addRange(0x103D6, 0x103FF).addRange(0x1049E, 0x1049F).addRange(0x104AA, 0x104AF).addRange(0x104D4, 0x104D7).addRange(0x104FC, 0x104FF).addRange(0x10528, 0x1052F).addRange(0x10564, 0x1056E).addRange(0x105BD, 0x105BF).addRange(0x105F4, 0x105FF).addRange(0x10737, 0x1073F).addRange(0x10756, 0x1075F).addRange(0x10768, 0x1077F).addRange(0x107BB, 0x107FF).addRange(0x10806, 0x10807).addRange(0x10839, 0x1083B).addRange(0x1083D, 0x1083E).addRange(0x1089F, 0x108A6).addRange(0x108B0, 0x108DF).addRange(0x108F6, 0x108FA).addRange(0x1091C, 0x1091E).addRange(0x1093A, 0x1093E).addRange(0x10940, 0x1097F).addRange(0x109B8, 0x109BB).addRange(0x109D0, 0x109D1).addRange(0x10A07, 0x10A0B).addRange(0x10A36, 0x10A37).addRange(0x10A3B, 0x10A3E).addRange(0x10A49, 0x10A4F).addRange(0x10A59, 0x10A5F);
    set.addRange(0x10AA0, 0x10ABF).addRange(0x10AE7, 0x10AEA).addRange(0x10AF7, 0x10AFF).addRange(0x10B36, 0x10B38).addRange(0x10B56, 0x10B57).addRange(0x10B73, 0x10B77).addRange(0x10B92, 0x10B98).addRange(0x10B9D, 0x10BA8).addRange(0x10BB0, 0x10BFF).addRange(0x10C49, 0x10C7F).addRange(0x10CB3, 0x10CBF).addRange(0x10CF3, 0x10CF9).addRange(0x10D28, 0x10D2F).addRange(0x10D3A, 0x10D3F).addRange(0x10D66, 0x10D68).addRange(0x10D86, 0x10D8D).addRange(0x10D90, 0x10E5F).addRange(0x10EAE, 0x10EAF).addRange(0x10EB2, 0x10EC1).addRange(0x10EC5, 0x10EFB).addRange(0x10F28, 0x10F2F).addRange(0x10F5A, 0x10F6F).addRange(0x10F8A, 0x10FAF).addRange(0x10FCC, 0x10FDF).addRange(0x10FF7, 0x10FFF).addRange(0x1104E, 0x11051).addRange(0x11076, 0x1107E).addRange(0x110C3, 0x110CF).addRange(0x110E9, 0x110EF).addRange(0x110FA, 0x110FF).addRange(0x11148, 0x1114F).addRange(0x11177, 0x1117F).addRange(0x111F5, 0x111FF).addRange(0x11242, 0x1127F).addRange(0x112AA, 0x112AF).addRange(0x112EB, 0x112EF).addRange(0x112FA, 0x112FF).addRange(0x1130D, 0x1130E).addRange(0x11311, 0x11312).addRange(0x11345, 0x11346).addRange(0x11349, 0x1134A).addRange(0x1134E, 0x1134F).addRange(0x11351, 0x11356).addRange(0x11358, 0x1135C).addRange(0x11364, 0x11365).addRange(0x1136D, 0x1136F).addRange(0x11375, 0x1137F).addRange(0x1138C, 0x1138D).addRange(0x113C3, 0x113C4).addRange(0x113D9, 0x113E0).addRange(0x113E3, 0x113FF);
    set.addRange(0x11462, 0x1147F).addRange(0x114C8, 0x114CF).addRange(0x114DA, 0x1157F).addRange(0x115B6, 0x115B7).addRange(0x115DE, 0x115FF).addRange(0x11645, 0x1164F).addRange(0x1165A, 0x1165F).addRange(0x1166D, 0x1167F).addRange(0x116BA, 0x116BF).addRange(0x116CA, 0x116CF).addRange(0x116E4, 0x116FF).addRange(0x1171B, 0x1171C).addRange(0x1172C, 0x1172F).addRange(0x11747, 0x117FF).addRange(0x1183C, 0x1189F).addRange(0x118F3, 0x118FE).addRange(0x11907, 0x11908).addRange(0x1190A, 0x1190B).addRange(0x11939, 0x1193A).addRange(0x11947, 0x1194F).addRange(0x1195A, 0x1199F).addRange(0x119A8, 0x119A9).addRange(0x119D8, 0x119D9).addRange(0x119E5, 0x119FF).addRange(0x11A48, 0x11A4F).addRange(0x11AA3, 0x11AAF).addRange(0x11AF9, 0x11AFF).addRange(0x11B0A, 0x11BBF).addRange(0x11BE2, 0x11BEF).addRange(0x11BFA, 0x11BFF).addRange(0x11C46, 0x11C4F).addRange(0x11C6D, 0x11C6F).addRange(0x11C90, 0x11C91).addRange(0x11CB7, 0x11CFF).addRange(0x11D37, 0x11D39).addRange(0x11D48, 0x11D4F).addRange(0x11D5A, 0x11D5F).addRange(0x11D99, 0x11D9F).addRange(0x11DAA, 0x11EDF).addRange(0x11EF9, 0x11EFF).addRange(0x11F3B, 0x11F3D).addRange(0x11F5B, 0x11FAF).addRange(0x11FB1, 0x11FBF).addRange(0x11FF2, 0x11FFE).addRange(0x1239A, 0x123FF).addRange(0x12475, 0x1247F).addRange(0x12544, 0x12F8F).addRange(0x12FF3, 0x12FFF).addRange(0x13430, 0x1343F).addRange(0x13456, 0x1345F).addRange(0x143FB, 0x143FF);
    set.addRange(0x14647, 0x160FF).addRange(0x1613A, 0x167FF).addRange(0x16A39, 0x16A3F).addRange(0x16A6A, 0x16A6D).addRange(0x16ACA, 0x16ACF).addRange(0x16AEE, 0x16AEF).addRange(0x16AF6, 0x16AFF).addRange(0x16B46, 0x16B4F).addRange(0x16B78, 0x16B7C).addRange(0x16B90, 0x16D3F).addRange(0x16D7A, 0x16E3F).addRange(0x16E9B, 0x16EFF).addRange(0x16F4B, 0x16F4E).addRange(0x16F88, 0x16F8E).addRange(0x16FA0, 0x16FDF).addRange(0x16FE5, 0x16FEF).addRange(0x16FF2, 0x16FFF).addRange(0x187F8, 0x187FF).addRange(0x18CD6, 0x18CFE).addRange(0x18D09, 0x1AFEF).addRange(0x1B123, 0x1B131).addRange(0x1B133, 0x1B14F).addRange(0x1B153, 0x1B154).addRange(0x1B156, 0x1B163).addRange(0x1B168, 0x1B16F).addRange(0x1B2FC, 0x1BBFF).addRange(0x1BC6B, 0x1BC6F).addRange(0x1BC7D, 0x1BC7F).addRange(0x1BC89, 0x1BC8F).addRange(0x1BC9A, 0x1BC9B).addRange(0x1BCA0, 0x1CBFF).addRange(0x1CCFA, 0x1CCFF).addRange(0x1CEB4, 0x1CEFF).addRange(0x1CF2E, 0x1CF2F).addRange(0x1CF47, 0x1CF4F).addRange(0x1CFC4, 0x1CFFF).addRange(0x1D0F6, 0x1D0FF).addRange(0x1D127, 0x1D128).addRange(0x1D173, 0x1D17A).addRange(0x1D1EB, 0x1D1FF).addRange(0x1D246, 0x1D2BF).addRange(0x1D2D4, 0x1D2DF).addRange(0x1D2F4, 0x1D2FF).addRange(0x1D357, 0x1D35F).addRange(0x1D379, 0x1D3FF).addRange(0x1D4A0, 0x1D4A1).addRange(0x1D4A3, 0x1D4A4).addRange(0x1D4A7, 0x1D4A8).addRange(0x1D50B, 0x1D50C).addRange(0x1D547, 0x1D549).addRange(0x1D6A6, 0x1D6A7);
    set.addRange(0x1D7CC, 0x1D7CD).addRange(0x1DA8C, 0x1DA9A).addRange(0x1DAB0, 0x1DEFF).addRange(0x1DF1F, 0x1DF24).addRange(0x1DF2B, 0x1DFFF).addRange(0x1E019, 0x1E01A).addRange(0x1E02B, 0x1E02F).addRange(0x1E06E, 0x1E08E).addRange(0x1E090, 0x1E0FF).addRange(0x1E12D, 0x1E12F).addRange(0x1E13E, 0x1E13F).addRange(0x1E14A, 0x1E14D).addRange(0x1E150, 0x1E28F).addRange(0x1E2AF, 0x1E2BF).addRange(0x1E2FA, 0x1E2FE).addRange(0x1E300, 0x1E4CF).addRange(0x1E4FA, 0x1E5CF).addRange(0x1E5FB, 0x1E5FE).addRange(0x1E600, 0x1E7DF).addRange(0x1E8C5, 0x1E8C6).addRange(0x1E8D7, 0x1E8FF).addRange(0x1E94C, 0x1E94F).addRange(0x1E95A, 0x1E95D).addRange(0x1E960, 0x1EC70).addRange(0x1ECB5, 0x1ED00).addRange(0x1ED3E, 0x1EDFF).addRange(0x1EE25, 0x1EE26).addRange(0x1EE3C, 0x1EE41).addRange(0x1EE43, 0x1EE46).addRange(0x1EE55, 0x1EE56).addRange(0x1EE65, 0x1EE66).addRange(0x1EE9C, 0x1EEA0).addRange(0x1EEBC, 0x1EEEF).addRange(0x1EEF2, 0x1EFFF).addRange(0x1F02C, 0x1F02F).addRange(0x1F094, 0x1F09F).addRange(0x1F0AF, 0x1F0B0).addRange(0x1F0F6, 0x1F0FF).addRange(0x1F1AE, 0x1F1E5).addRange(0x1F203, 0x1F20F).addRange(0x1F23C, 0x1F23F).addRange(0x1F249, 0x1F24F).addRange(0x1F252, 0x1F25F).addRange(0x1F266, 0x1F2FF).addRange(0x1F6D8, 0x1F6DB).addRange(0x1F6ED, 0x1F6EF).addRange(0x1F6FD, 0x1F6FF).addRange(0x1F777, 0x1F77A).addRange(0x1F7DA, 0x1F7DF).addRange(0x1F7EC, 0x1F7EF).addRange(0x1F7F1, 0x1F7FF);
    set.addRange(0x1F80C, 0x1F80F).addRange(0x1F848, 0x1F84F).addRange(0x1F85A, 0x1F85F).addRange(0x1F888, 0x1F88F).addRange(0x1F8AE, 0x1F8AF).addRange(0x1F8BC, 0x1F8BF).addRange(0x1F8C2, 0x1F8FF).addRange(0x1FA54, 0x1FA5F).addRange(0x1FA6E, 0x1FA6F).addRange(0x1FA7D, 0x1FA7F).addRange(0x1FA8A, 0x1FA8E).addRange(0x1FAC7, 0x1FACD).addRange(0x1FADD, 0x1FADE).addRange(0x1FAEA, 0x1FAEF).addRange(0x1FAF9, 0x1FAFF).addRange(0x1FBFA, 0x1FFFF).addRange(0x2A6E0, 0x2A6FF).addRange(0x2B73A, 0x2B73F).addRange(0x2B81E, 0x2B81F).addRange(0x2CEA2, 0x2CEAF).addRange(0x2EBE1, 0x2EBEF).addRange(0x2EE5E, 0x2F7FF).addRange(0x2FA1E, 0x2FFFF).addRange(0x3134B, 0x3134F).addRange(0x323B0, 0xE00FF).addRange(0xE01F0, 0x10FFFF);
    Other.characters = set;
    return Other;
  }

var Paragraph_Separator = {};

var hasRequiredParagraph_Separator;
  function requireParagraph_Separator() {
    if (hasRequiredParagraph_Separator) return Paragraph_Separator;
    hasRequiredParagraph_Separator = 1;
    var set = regenerateExports(0x2029);
    Paragraph_Separator.characters = set;
    return Paragraph_Separator;
  }

var Private_Use = {};

var hasRequiredPrivate_Use;
  function requirePrivate_Use() {
    if (hasRequiredPrivate_Use) return Private_Use;
    hasRequiredPrivate_Use = 1;
    var set = regenerateExports();
    set.addRange(0xE000, 0xF8FF).addRange(0xF0000, 0xFFFFD).addRange(0x100000, 0x10FFFD);
    Private_Use.characters = set;
    return Private_Use;
  }

var Punctuation = {};

var hasRequiredPunctuation;
  function requirePunctuation() {
    if (hasRequiredPunctuation) return Punctuation;
    hasRequiredPunctuation = 1;
    var set = regenerateExports(0x5F, 0x7B, 0x7D, 0xA1, 0xA7, 0xAB, 0xBB, 0xBF, 0x37E, 0x387, 0x5BE, 0x5C0, 0x5C3, 0x5C6, 0x61B, 0x6D4, 0x85E, 0x970, 0x9FD, 0xA76, 0xAF0, 0xC77, 0xC84, 0xDF4, 0xE4F, 0xF14, 0xF85, 0x10FB, 0x1400, 0x166E, 0x1CD3, 0x2D70, 0x3030, 0x303D, 0x30A0, 0x30FB, 0xA673, 0xA67E, 0xA8FC, 0xA95F, 0xABEB, 0xFE63, 0xFE68, 0xFF3F, 0xFF5B, 0xFF5D, 0x1039F, 0x103D0, 0x1056F, 0x10857, 0x1091F, 0x1093F, 0x10A7F, 0x10D6E, 0x10EAD, 0x111CD, 0x111DB, 0x112A9, 0x1145D, 0x114C6, 0x116B9, 0x1183B, 0x119E2, 0x11BE1, 0x11FFF, 0x16AF5, 0x16B44, 0x16FE2, 0x1BC9F, 0x1E5FF);
    set.addRange(0x21, 0x23).addRange(0x25, 0x2A).addRange(0x2C, 0x2F).addRange(0x3A, 0x3B).addRange(0x3F, 0x40).addRange(0x5B, 0x5D).addRange(0xB6, 0xB7).addRange(0x55A, 0x55F).addRange(0x589, 0x58A).addRange(0x5F3, 0x5F4).addRange(0x609, 0x60A).addRange(0x60C, 0x60D).addRange(0x61D, 0x61F).addRange(0x66A, 0x66D).addRange(0x700, 0x70D).addRange(0x7F7, 0x7F9).addRange(0x830, 0x83E).addRange(0x964, 0x965).addRange(0xE5A, 0xE5B).addRange(0xF04, 0xF12).addRange(0xF3A, 0xF3D).addRange(0xFD0, 0xFD4).addRange(0xFD9, 0xFDA).addRange(0x104A, 0x104F).addRange(0x1360, 0x1368).addRange(0x169B, 0x169C).addRange(0x16EB, 0x16ED).addRange(0x1735, 0x1736).addRange(0x17D4, 0x17D6).addRange(0x17D8, 0x17DA).addRange(0x1800, 0x180A).addRange(0x1944, 0x1945).addRange(0x1A1E, 0x1A1F).addRange(0x1AA0, 0x1AA6).addRange(0x1AA8, 0x1AAD).addRange(0x1B4E, 0x1B4F).addRange(0x1B5A, 0x1B60).addRange(0x1B7D, 0x1B7F).addRange(0x1BFC, 0x1BFF).addRange(0x1C3B, 0x1C3F).addRange(0x1C7E, 0x1C7F).addRange(0x1CC0, 0x1CC7).addRange(0x2010, 0x2027).addRange(0x2030, 0x2043).addRange(0x2045, 0x2051).addRange(0x2053, 0x205E).addRange(0x207D, 0x207E).addRange(0x208D, 0x208E).addRange(0x2308, 0x230B).addRange(0x2329, 0x232A).addRange(0x2768, 0x2775);
    set.addRange(0x27C5, 0x27C6).addRange(0x27E6, 0x27EF).addRange(0x2983, 0x2998).addRange(0x29D8, 0x29DB).addRange(0x29FC, 0x29FD).addRange(0x2CF9, 0x2CFC).addRange(0x2CFE, 0x2CFF).addRange(0x2E00, 0x2E2E).addRange(0x2E30, 0x2E4F).addRange(0x2E52, 0x2E5D).addRange(0x3001, 0x3003).addRange(0x3008, 0x3011).addRange(0x3014, 0x301F).addRange(0xA4FE, 0xA4FF).addRange(0xA60D, 0xA60F).addRange(0xA6F2, 0xA6F7).addRange(0xA874, 0xA877).addRange(0xA8CE, 0xA8CF).addRange(0xA8F8, 0xA8FA).addRange(0xA92E, 0xA92F).addRange(0xA9C1, 0xA9CD).addRange(0xA9DE, 0xA9DF).addRange(0xAA5C, 0xAA5F).addRange(0xAADE, 0xAADF).addRange(0xAAF0, 0xAAF1).addRange(0xFD3E, 0xFD3F).addRange(0xFE10, 0xFE19).addRange(0xFE30, 0xFE52).addRange(0xFE54, 0xFE61).addRange(0xFE6A, 0xFE6B).addRange(0xFF01, 0xFF03).addRange(0xFF05, 0xFF0A).addRange(0xFF0C, 0xFF0F).addRange(0xFF1A, 0xFF1B).addRange(0xFF1F, 0xFF20).addRange(0xFF3B, 0xFF3D).addRange(0xFF5F, 0xFF65).addRange(0x10100, 0x10102).addRange(0x10A50, 0x10A58).addRange(0x10AF0, 0x10AF6).addRange(0x10B39, 0x10B3F).addRange(0x10B99, 0x10B9C).addRange(0x10F55, 0x10F59).addRange(0x10F86, 0x10F89).addRange(0x11047, 0x1104D).addRange(0x110BB, 0x110BC).addRange(0x110BE, 0x110C1).addRange(0x11140, 0x11143).addRange(0x11174, 0x11175).addRange(0x111C5, 0x111C8).addRange(0x111DD, 0x111DF);
    set.addRange(0x11238, 0x1123D).addRange(0x113D4, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x1144B, 0x1144F).addRange(0x1145A, 0x1145B).addRange(0x115C1, 0x115D7).addRange(0x11641, 0x11643).addRange(0x11660, 0x1166C).addRange(0x1173C, 0x1173E).addRange(0x11944, 0x11946).addRange(0x11A3F, 0x11A46).addRange(0x11A9A, 0x11A9C).addRange(0x11A9E, 0x11AA2).addRange(0x11B00, 0x11B09).addRange(0x11C41, 0x11C45).addRange(0x11C70, 0x11C71).addRange(0x11EF7, 0x11EF8).addRange(0x11F43, 0x11F4F).addRange(0x12470, 0x12474).addRange(0x12FF1, 0x12FF2).addRange(0x16A6E, 0x16A6F).addRange(0x16B37, 0x16B3B).addRange(0x16D6D, 0x16D6F).addRange(0x16E97, 0x16E9A).addRange(0x1DA87, 0x1DA8B).addRange(0x1E95E, 0x1E95F);
    Punctuation.characters = set;
    return Punctuation;
  }

var Separator = {};

var hasRequiredSeparator;
  function requireSeparator() {
    if (hasRequiredSeparator) return Separator;
    hasRequiredSeparator = 1;
    var set = regenerateExports(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000);
    set.addRange(0x2000, 0x200A).addRange(0x2028, 0x2029);
    Separator.characters = set;
    return Separator;
  }

var Space_Separator = {};

var hasRequiredSpace_Separator;
  function requireSpace_Separator() {
    if (hasRequiredSpace_Separator) return Space_Separator;
    hasRequiredSpace_Separator = 1;
    var set = regenerateExports(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000);
    set.addRange(0x2000, 0x200A);
    Space_Separator.characters = set;
    return Space_Separator;
  }

var Spacing_Mark = {};

var hasRequiredSpacing_Mark;
  function requireSpacing_Mark() {
    if (hasRequiredSpacing_Mark) return Spacing_Mark;
    hasRequiredSpacing_Mark = 1;
    var set = regenerateExports(0x903, 0x93B, 0x9D7, 0xA03, 0xA83, 0xAC9, 0xB3E, 0xB40, 0xB57, 0xBD7, 0xCBE, 0xCF3, 0xD57, 0xF7F, 0x1031, 0x1038, 0x108F, 0x1715, 0x1734, 0x17B6, 0x1A55, 0x1A57, 0x1A61, 0x1B04, 0x1B35, 0x1B3B, 0x1B82, 0x1BA1, 0x1BAA, 0x1BE7, 0x1BEE, 0x1CE1, 0x1CF7, 0xA827, 0xA983, 0xAA4D, 0xAA7B, 0xAA7D, 0xAAEB, 0xAAF5, 0xABEC, 0x11000, 0x11002, 0x11082, 0x1112C, 0x11182, 0x111CE, 0x11235, 0x11357, 0x113C2, 0x113C5, 0x113CF, 0x11445, 0x114B9, 0x114C1, 0x115BE, 0x1163E, 0x116AC, 0x116B6, 0x1171E, 0x11726, 0x11838, 0x1193D, 0x11940, 0x11942, 0x119E4, 0x11A39, 0x11A97, 0x11C2F, 0x11C3E, 0x11CA9, 0x11CB1, 0x11CB4, 0x11D96, 0x11F03, 0x11F41);
    set.addRange(0x93E, 0x940).addRange(0x949, 0x94C).addRange(0x94E, 0x94F).addRange(0x982, 0x983).addRange(0x9BE, 0x9C0).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CC).addRange(0xA3E, 0xA40).addRange(0xABE, 0xAC0).addRange(0xACB, 0xACC).addRange(0xB02, 0xB03).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4C).addRange(0xBBE, 0xBBF).addRange(0xBC1, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCC).addRange(0xC01, 0xC03).addRange(0xC41, 0xC44).addRange(0xC82, 0xC83).addRange(0xCC0, 0xCC4).addRange(0xCC7, 0xCC8).addRange(0xCCA, 0xCCB).addRange(0xCD5, 0xCD6).addRange(0xD02, 0xD03).addRange(0xD3E, 0xD40).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4C).addRange(0xD82, 0xD83).addRange(0xDCF, 0xDD1).addRange(0xDD8, 0xDDF).addRange(0xDF2, 0xDF3).addRange(0xF3E, 0xF3F).addRange(0x102B, 0x102C).addRange(0x103B, 0x103C).addRange(0x1056, 0x1057).addRange(0x1062, 0x1064).addRange(0x1067, 0x106D).addRange(0x1083, 0x1084).addRange(0x1087, 0x108C).addRange(0x109A, 0x109C).addRange(0x17BE, 0x17C5).addRange(0x17C7, 0x17C8).addRange(0x1923, 0x1926).addRange(0x1929, 0x192B).addRange(0x1930, 0x1931).addRange(0x1933, 0x1938).addRange(0x1A19, 0x1A1A).addRange(0x1A63, 0x1A64).addRange(0x1A6D, 0x1A72).addRange(0x1B3D, 0x1B41);
    set.addRange(0x1B43, 0x1B44).addRange(0x1BA6, 0x1BA7).addRange(0x1BEA, 0x1BEC).addRange(0x1BF2, 0x1BF3).addRange(0x1C24, 0x1C2B).addRange(0x1C34, 0x1C35).addRange(0x302E, 0x302F).addRange(0xA823, 0xA824).addRange(0xA880, 0xA881).addRange(0xA8B4, 0xA8C3).addRange(0xA952, 0xA953).addRange(0xA9B4, 0xA9B5).addRange(0xA9BA, 0xA9BB).addRange(0xA9BE, 0xA9C0).addRange(0xAA2F, 0xAA30).addRange(0xAA33, 0xAA34).addRange(0xAAEE, 0xAAEF).addRange(0xABE3, 0xABE4).addRange(0xABE6, 0xABE7).addRange(0xABE9, 0xABEA).addRange(0x110B0, 0x110B2).addRange(0x110B7, 0x110B8).addRange(0x11145, 0x11146).addRange(0x111B3, 0x111B5).addRange(0x111BF, 0x111C0).addRange(0x1122C, 0x1122E).addRange(0x11232, 0x11233).addRange(0x112E0, 0x112E2).addRange(0x11302, 0x11303).addRange(0x1133E, 0x1133F).addRange(0x11341, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x11362, 0x11363).addRange(0x113B8, 0x113BA).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113CD).addRange(0x11435, 0x11437).addRange(0x11440, 0x11441).addRange(0x114B0, 0x114B2).addRange(0x114BB, 0x114BE).addRange(0x115AF, 0x115B1).addRange(0x115B8, 0x115BB).addRange(0x11630, 0x11632).addRange(0x1163B, 0x1163C).addRange(0x116AE, 0x116AF).addRange(0x11720, 0x11721).addRange(0x1182C, 0x1182E).addRange(0x11930, 0x11935).addRange(0x11937, 0x11938).addRange(0x119D1, 0x119D3);
    set.addRange(0x119DC, 0x119DF).addRange(0x11A57, 0x11A58).addRange(0x11D8A, 0x11D8E).addRange(0x11D93, 0x11D94).addRange(0x11EF5, 0x11EF6).addRange(0x11F34, 0x11F35).addRange(0x11F3E, 0x11F3F).addRange(0x1612A, 0x1612C).addRange(0x16F51, 0x16F87).addRange(0x16FF0, 0x16FF1).addRange(0x1D165, 0x1D166).addRange(0x1D16D, 0x1D172);
    Spacing_Mark.characters = set;
    return Spacing_Mark;
  }

var Surrogate = {};

var hasRequiredSurrogate;
  function requireSurrogate() {
    if (hasRequiredSurrogate) return Surrogate;
    hasRequiredSurrogate = 1;
    var set = regenerateExports();
    set.addRange(0xD800, 0xDFFF);
    Surrogate.characters = set;
    return Surrogate;
  }

var _Symbol = {};

var hasRequired_Symbol;
  function require_Symbol() {
    if (hasRequired_Symbol) return _Symbol;
    hasRequired_Symbol = 1;
    var set = regenerateExports(0x24, 0x2B, 0x5E, 0x60, 0x7C, 0x7E, 0xAC, 0xB4, 0xB8, 0xD7, 0xF7, 0x2ED, 0x375, 0x3F6, 0x482, 0x60B, 0x6DE, 0x6E9, 0x7F6, 0x888, 0xAF1, 0xB70, 0xC7F, 0xD4F, 0xD79, 0xE3F, 0xF13, 0xF34, 0xF36, 0xF38, 0x166D, 0x17DB, 0x1940, 0x1FBD, 0x2044, 0x2052, 0x2114, 0x2125, 0x2127, 0x2129, 0x212E, 0x214F, 0x3004, 0x3020, 0x31EF, 0x3250, 0xAB5B, 0xFB29, 0xFDCF, 0xFE62, 0xFE69, 0xFF04, 0xFF0B, 0xFF3E, 0xFF40, 0xFF5C, 0xFF5E, 0x101A0, 0x10AC8, 0x1173F, 0x16B45, 0x1BC9C, 0x1D245, 0x1D6C1, 0x1D6DB, 0x1D6FB, 0x1D715, 0x1D735, 0x1D74F, 0x1D76F, 0x1D789, 0x1D7A9, 0x1D7C3, 0x1E14F, 0x1E2FF, 0x1ECAC, 0x1ECB0, 0x1ED2E, 0x1F7F0);
    set.addRange(0x3C, 0x3E).addRange(0xA2, 0xA6).addRange(0xA8, 0xA9).addRange(0xAE, 0xB1).addRange(0x2C2, 0x2C5).addRange(0x2D2, 0x2DF).addRange(0x2E5, 0x2EB).addRange(0x2EF, 0x2FF).addRange(0x384, 0x385).addRange(0x58D, 0x58F).addRange(0x606, 0x608).addRange(0x60E, 0x60F).addRange(0x6FD, 0x6FE).addRange(0x7FE, 0x7FF).addRange(0x9F2, 0x9F3).addRange(0x9FA, 0x9FB).addRange(0xBF3, 0xBFA).addRange(0xF01, 0xF03).addRange(0xF15, 0xF17).addRange(0xF1A, 0xF1F).addRange(0xFBE, 0xFC5).addRange(0xFC7, 0xFCC).addRange(0xFCE, 0xFCF).addRange(0xFD5, 0xFD8).addRange(0x109E, 0x109F).addRange(0x1390, 0x1399).addRange(0x19DE, 0x19FF).addRange(0x1B61, 0x1B6A).addRange(0x1B74, 0x1B7C).addRange(0x1FBF, 0x1FC1).addRange(0x1FCD, 0x1FCF).addRange(0x1FDD, 0x1FDF).addRange(0x1FED, 0x1FEF).addRange(0x1FFD, 0x1FFE).addRange(0x207A, 0x207C).addRange(0x208A, 0x208C).addRange(0x20A0, 0x20C0).addRange(0x2100, 0x2101).addRange(0x2103, 0x2106).addRange(0x2108, 0x2109).addRange(0x2116, 0x2118).addRange(0x211E, 0x2123).addRange(0x213A, 0x213B).addRange(0x2140, 0x2144).addRange(0x214A, 0x214D).addRange(0x218A, 0x218B).addRange(0x2190, 0x2307).addRange(0x230C, 0x2328).addRange(0x232B, 0x2429).addRange(0x2440, 0x244A).addRange(0x249C, 0x24E9);
    set.addRange(0x2500, 0x2767).addRange(0x2794, 0x27C4).addRange(0x27C7, 0x27E5).addRange(0x27F0, 0x2982).addRange(0x2999, 0x29D7).addRange(0x29DC, 0x29FB).addRange(0x29FE, 0x2B73).addRange(0x2B76, 0x2B95).addRange(0x2B97, 0x2BFF).addRange(0x2CE5, 0x2CEA).addRange(0x2E50, 0x2E51).addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x2FF0, 0x2FFF).addRange(0x3012, 0x3013).addRange(0x3036, 0x3037).addRange(0x303E, 0x303F).addRange(0x309B, 0x309C).addRange(0x3190, 0x3191).addRange(0x3196, 0x319F).addRange(0x31C0, 0x31E5).addRange(0x3200, 0x321E).addRange(0x322A, 0x3247).addRange(0x3260, 0x327F).addRange(0x328A, 0x32B0).addRange(0x32C0, 0x33FF).addRange(0x4DC0, 0x4DFF).addRange(0xA490, 0xA4C6).addRange(0xA700, 0xA716).addRange(0xA720, 0xA721).addRange(0xA789, 0xA78A).addRange(0xA828, 0xA82B).addRange(0xA836, 0xA839).addRange(0xAA77, 0xAA79).addRange(0xAB6A, 0xAB6B).addRange(0xFBB2, 0xFBC2).addRange(0xFD40, 0xFD4F).addRange(0xFDFC, 0xFDFF).addRange(0xFE64, 0xFE66).addRange(0xFF1C, 0xFF1E).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFFC, 0xFFFD).addRange(0x10137, 0x1013F).addRange(0x10179, 0x10189).addRange(0x1018C, 0x1018E).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FC).addRange(0x10877, 0x10878).addRange(0x10D8E, 0x10D8F);
    set.addRange(0x11FD5, 0x11FF1).addRange(0x16B3C, 0x16B3F).addRange(0x1CC00, 0x1CCEF).addRange(0x1CD00, 0x1CEB3).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D164).addRange(0x1D16A, 0x1D16C).addRange(0x1D183, 0x1D184).addRange(0x1D18C, 0x1D1A9).addRange(0x1D1AE, 0x1D1EA).addRange(0x1D200, 0x1D241).addRange(0x1D300, 0x1D356).addRange(0x1D800, 0x1D9FF).addRange(0x1DA37, 0x1DA3A).addRange(0x1DA6D, 0x1DA74).addRange(0x1DA76, 0x1DA83).addRange(0x1DA85, 0x1DA86).addRange(0x1EEF0, 0x1EEF1).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093).addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF).addRange(0x1F0D1, 0x1F0F5).addRange(0x1F10D, 0x1F1AD).addRange(0x1F1E6, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F250, 0x1F251).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F6D7).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F776).addRange(0x1F77B, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F900, 0x1FA53).addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA89).addRange(0x1FA8F, 0x1FAC6).addRange(0x1FACE, 0x1FADC);
    set.addRange(0x1FADF, 0x1FAE9).addRange(0x1FAF0, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBEF);
    _Symbol.characters = set;
    return _Symbol;
  }

var Titlecase_Letter = {};

var hasRequiredTitlecase_Letter;
  function requireTitlecase_Letter() {
    if (hasRequiredTitlecase_Letter) return Titlecase_Letter;
    hasRequiredTitlecase_Letter = 1;
    var set = regenerateExports(0x1C5, 0x1C8, 0x1CB, 0x1F2, 0x1FBC, 0x1FCC, 0x1FFC);
    set.addRange(0x1F88, 0x1F8F).addRange(0x1F98, 0x1F9F).addRange(0x1FA8, 0x1FAF);
    Titlecase_Letter.characters = set;
    return Titlecase_Letter;
  }

var Unassigned = {};

var hasRequiredUnassigned;
  function requireUnassigned() {
    if (hasRequiredUnassigned) return Unassigned;
    hasRequiredUnassigned = 1;
    var set = regenerateExports(0x38B, 0x38D, 0x3A2, 0x530, 0x590, 0x70E, 0x83F, 0x85F, 0x88F, 0x984, 0x9A9, 0x9B1, 0x9DE, 0xA04, 0xA29, 0xA31, 0xA34, 0xA37, 0xA3D, 0xA5D, 0xA84, 0xA8E, 0xA92, 0xAA9, 0xAB1, 0xAB4, 0xAC6, 0xACA, 0xB00, 0xB04, 0xB29, 0xB31, 0xB34, 0xB5E, 0xB84, 0xB91, 0xB9B, 0xB9D, 0xBC9, 0xC0D, 0xC11, 0xC29, 0xC45, 0xC49, 0xC57, 0xC8D, 0xC91, 0xCA9, 0xCB4, 0xCC5, 0xCC9, 0xCDF, 0xCF0, 0xD0D, 0xD11, 0xD45, 0xD49, 0xD80, 0xD84, 0xDB2, 0xDBC, 0xDD5, 0xDD7, 0xE83, 0xE85, 0xE8B, 0xEA4, 0xEA6, 0xEC5, 0xEC7, 0xECF, 0xF48, 0xF98, 0xFBD, 0xFCD, 0x10C6, 0x1249, 0x1257, 0x1259, 0x1289, 0x12B1, 0x12BF, 0x12C1, 0x12D7, 0x1311, 0x176D, 0x1771, 0x191F, 0x1A5F, 0x1B4D, 0x1F58, 0x1F5A, 0x1F5C, 0x1F5E, 0x1FB5, 0x1FC5, 0x1FDC, 0x1FF5, 0x1FFF, 0x2065, 0x208F, 0x2B96, 0x2D26, 0x2DA7, 0x2DAF, 0x2DB7, 0x2DBF, 0x2DC7, 0x2DCF, 0x2DD7, 0x2DDF, 0x2E9A, 0x3040, 0x3130, 0x318F, 0x321F, 0xA7D2, 0xA7D4, 0xA9CE, 0xA9FF, 0xAB27, 0xAB2F, 0xFB37, 0xFB3D, 0xFB3F, 0xFB42, 0xFB45, 0xFE53, 0xFE67, 0xFE75, 0xFF00, 0xFFE7, 0x1000C, 0x10027, 0x1003B, 0x1003E, 0x1018F, 0x1039E, 0x1057B, 0x1058B, 0x10593, 0x10596, 0x105A2, 0x105B2, 0x105BA, 0x10786, 0x107B1, 0x10809, 0x10836, 0x10856, 0x108F3, 0x10A04, 0x10A14, 0x10A18, 0x10E7F, 0x10EAA, 0x11135, 0x111E0, 0x11212, 0x11287, 0x11289, 0x1128E, 0x1129E, 0x11304, 0x11329, 0x11331, 0x11334, 0x1133A, 0x1138A, 0x1138F, 0x113B6, 0x113C1, 0x113C6, 0x113CB, 0x113D6, 0x1145C, 0x11914, 0x11917, 0x11936, 0x11C09, 0x11C37, 0x11CA8, 0x11D07, 0x11D0A, 0x11D3B, 0x11D3E, 0x11D66, 0x11D69, 0x11D8F, 0x11D92, 0x11F11, 0x1246F, 0x16A5F, 0x16ABF, 0x16B5A, 0x16B62, 0x1AFF4, 0x1AFFC, 0x1AFFF, 0x1D455, 0x1D49D, 0x1D4AD, 0x1D4BA, 0x1D4BC, 0x1D4C4, 0x1D506, 0x1D515, 0x1D51D, 0x1D53A, 0x1D53F, 0x1D545, 0x1D551, 0x1DAA0, 0x1E007, 0x1E022, 0x1E025, 0x1E7E7, 0x1E7EC, 0x1E7EF, 0x1E7FF, 0x1EE04, 0x1EE20, 0x1EE23, 0x1EE28, 0x1EE33, 0x1EE38, 0x1EE3A, 0x1EE48, 0x1EE4A, 0x1EE4C, 0x1EE50, 0x1EE53, 0x1EE58, 0x1EE5A, 0x1EE5C, 0x1EE5E, 0x1EE60, 0x1EE63, 0x1EE6B, 0x1EE73, 0x1EE78, 0x1EE7D, 0x1EE7F, 0x1EE8A, 0x1EEA4, 0x1EEAA, 0x1F0C0, 0x1F0D0, 0x1FB93);
    set.addRange(0x378, 0x379).addRange(0x380, 0x383).addRange(0x557, 0x558).addRange(0x58B, 0x58C).addRange(0x5C8, 0x5CF).addRange(0x5EB, 0x5EE).addRange(0x5F5, 0x5FF).addRange(0x74B, 0x74C).addRange(0x7B2, 0x7BF).addRange(0x7FB, 0x7FC).addRange(0x82E, 0x82F).addRange(0x85C, 0x85D).addRange(0x86B, 0x86F).addRange(0x892, 0x896).addRange(0x98D, 0x98E).addRange(0x991, 0x992).addRange(0x9B3, 0x9B5).addRange(0x9BA, 0x9BB).addRange(0x9C5, 0x9C6).addRange(0x9C9, 0x9CA).addRange(0x9CF, 0x9D6).addRange(0x9D8, 0x9DB).addRange(0x9E4, 0x9E5).addRange(0x9FF, 0xA00).addRange(0xA0B, 0xA0E).addRange(0xA11, 0xA12).addRange(0xA3A, 0xA3B).addRange(0xA43, 0xA46).addRange(0xA49, 0xA4A).addRange(0xA4E, 0xA50).addRange(0xA52, 0xA58).addRange(0xA5F, 0xA65).addRange(0xA77, 0xA80).addRange(0xABA, 0xABB).addRange(0xACE, 0xACF).addRange(0xAD1, 0xADF).addRange(0xAE4, 0xAE5).addRange(0xAF2, 0xAF8).addRange(0xB0D, 0xB0E).addRange(0xB11, 0xB12).addRange(0xB3A, 0xB3B).addRange(0xB45, 0xB46).addRange(0xB49, 0xB4A).addRange(0xB4E, 0xB54).addRange(0xB58, 0xB5B).addRange(0xB64, 0xB65).addRange(0xB78, 0xB81).addRange(0xB8B, 0xB8D).addRange(0xB96, 0xB98).addRange(0xBA0, 0xBA2).addRange(0xBA5, 0xBA7);
    set.addRange(0xBAB, 0xBAD).addRange(0xBBA, 0xBBD).addRange(0xBC3, 0xBC5).addRange(0xBCE, 0xBCF).addRange(0xBD1, 0xBD6).addRange(0xBD8, 0xBE5).addRange(0xBFB, 0xBFF).addRange(0xC3A, 0xC3B).addRange(0xC4E, 0xC54).addRange(0xC5B, 0xC5C).addRange(0xC5E, 0xC5F).addRange(0xC64, 0xC65).addRange(0xC70, 0xC76).addRange(0xCBA, 0xCBB).addRange(0xCCE, 0xCD4).addRange(0xCD7, 0xCDC).addRange(0xCE4, 0xCE5).addRange(0xCF4, 0xCFF).addRange(0xD50, 0xD53).addRange(0xD64, 0xD65).addRange(0xD97, 0xD99).addRange(0xDBE, 0xDBF).addRange(0xDC7, 0xDC9).addRange(0xDCB, 0xDCE).addRange(0xDE0, 0xDE5).addRange(0xDF0, 0xDF1).addRange(0xDF5, 0xE00).addRange(0xE3B, 0xE3E).addRange(0xE5C, 0xE80).addRange(0xEBE, 0xEBF).addRange(0xEDA, 0xEDB).addRange(0xEE0, 0xEFF).addRange(0xF6D, 0xF70).addRange(0xFDB, 0xFFF).addRange(0x10C8, 0x10CC).addRange(0x10CE, 0x10CF).addRange(0x124E, 0x124F).addRange(0x125E, 0x125F).addRange(0x128E, 0x128F).addRange(0x12B6, 0x12B7).addRange(0x12C6, 0x12C7).addRange(0x1316, 0x1317).addRange(0x135B, 0x135C).addRange(0x137D, 0x137F).addRange(0x139A, 0x139F).addRange(0x13F6, 0x13F7).addRange(0x13FE, 0x13FF).addRange(0x169D, 0x169F).addRange(0x16F9, 0x16FF).addRange(0x1716, 0x171E).addRange(0x1737, 0x173F);
    set.addRange(0x1754, 0x175F).addRange(0x1774, 0x177F).addRange(0x17DE, 0x17DF).addRange(0x17EA, 0x17EF).addRange(0x17FA, 0x17FF).addRange(0x181A, 0x181F).addRange(0x1879, 0x187F).addRange(0x18AB, 0x18AF).addRange(0x18F6, 0x18FF).addRange(0x192C, 0x192F).addRange(0x193C, 0x193F).addRange(0x1941, 0x1943).addRange(0x196E, 0x196F).addRange(0x1975, 0x197F).addRange(0x19AC, 0x19AF).addRange(0x19CA, 0x19CF).addRange(0x19DB, 0x19DD).addRange(0x1A1C, 0x1A1D).addRange(0x1A7D, 0x1A7E).addRange(0x1A8A, 0x1A8F).addRange(0x1A9A, 0x1A9F).addRange(0x1AAE, 0x1AAF).addRange(0x1ACF, 0x1AFF).addRange(0x1BF4, 0x1BFB).addRange(0x1C38, 0x1C3A).addRange(0x1C4A, 0x1C4C).addRange(0x1C8B, 0x1C8F).addRange(0x1CBB, 0x1CBC).addRange(0x1CC8, 0x1CCF).addRange(0x1CFB, 0x1CFF).addRange(0x1F16, 0x1F17).addRange(0x1F1E, 0x1F1F).addRange(0x1F46, 0x1F47).addRange(0x1F4E, 0x1F4F).addRange(0x1F7E, 0x1F7F).addRange(0x1FD4, 0x1FD5).addRange(0x1FF0, 0x1FF1).addRange(0x2072, 0x2073).addRange(0x209D, 0x209F).addRange(0x20C1, 0x20CF).addRange(0x20F1, 0x20FF).addRange(0x218C, 0x218F).addRange(0x242A, 0x243F).addRange(0x244B, 0x245F).addRange(0x2B74, 0x2B75).addRange(0x2CF4, 0x2CF8).addRange(0x2D28, 0x2D2C).addRange(0x2D2E, 0x2D2F).addRange(0x2D68, 0x2D6E).addRange(0x2D71, 0x2D7E).addRange(0x2D97, 0x2D9F);
    set.addRange(0x2E5E, 0x2E7F).addRange(0x2EF4, 0x2EFF).addRange(0x2FD6, 0x2FEF).addRange(0x3097, 0x3098).addRange(0x3100, 0x3104).addRange(0x31E6, 0x31EE).addRange(0xA48D, 0xA48F).addRange(0xA4C7, 0xA4CF).addRange(0xA62C, 0xA63F).addRange(0xA6F8, 0xA6FF).addRange(0xA7CE, 0xA7CF).addRange(0xA7DD, 0xA7F1).addRange(0xA82D, 0xA82F).addRange(0xA83A, 0xA83F).addRange(0xA878, 0xA87F).addRange(0xA8C6, 0xA8CD).addRange(0xA8DA, 0xA8DF).addRange(0xA954, 0xA95E).addRange(0xA97D, 0xA97F).addRange(0xA9DA, 0xA9DD).addRange(0xAA37, 0xAA3F).addRange(0xAA4E, 0xAA4F).addRange(0xAA5A, 0xAA5B).addRange(0xAAC3, 0xAADA).addRange(0xAAF7, 0xAB00).addRange(0xAB07, 0xAB08).addRange(0xAB0F, 0xAB10).addRange(0xAB17, 0xAB1F).addRange(0xAB6C, 0xAB6F).addRange(0xABEE, 0xABEF).addRange(0xABFA, 0xABFF).addRange(0xD7A4, 0xD7AF).addRange(0xD7C7, 0xD7CA).addRange(0xD7FC, 0xD7FF).addRange(0xFA6E, 0xFA6F).addRange(0xFADA, 0xFAFF).addRange(0xFB07, 0xFB12).addRange(0xFB18, 0xFB1C).addRange(0xFBC3, 0xFBD2).addRange(0xFD90, 0xFD91).addRange(0xFDC8, 0xFDCE).addRange(0xFDD0, 0xFDEF).addRange(0xFE1A, 0xFE1F).addRange(0xFE6C, 0xFE6F).addRange(0xFEFD, 0xFEFE).addRange(0xFFBF, 0xFFC1).addRange(0xFFC8, 0xFFC9).addRange(0xFFD0, 0xFFD1).addRange(0xFFD8, 0xFFD9).addRange(0xFFDD, 0xFFDF).addRange(0xFFEF, 0xFFF8);
    set.addRange(0xFFFE, 0xFFFF).addRange(0x1004E, 0x1004F).addRange(0x1005E, 0x1007F).addRange(0x100FB, 0x100FF).addRange(0x10103, 0x10106).addRange(0x10134, 0x10136).addRange(0x1019D, 0x1019F).addRange(0x101A1, 0x101CF).addRange(0x101FE, 0x1027F).addRange(0x1029D, 0x1029F).addRange(0x102D1, 0x102DF).addRange(0x102FC, 0x102FF).addRange(0x10324, 0x1032C).addRange(0x1034B, 0x1034F).addRange(0x1037B, 0x1037F).addRange(0x103C4, 0x103C7).addRange(0x103D6, 0x103FF).addRange(0x1049E, 0x1049F).addRange(0x104AA, 0x104AF).addRange(0x104D4, 0x104D7).addRange(0x104FC, 0x104FF).addRange(0x10528, 0x1052F).addRange(0x10564, 0x1056E).addRange(0x105BD, 0x105BF).addRange(0x105F4, 0x105FF).addRange(0x10737, 0x1073F).addRange(0x10756, 0x1075F).addRange(0x10768, 0x1077F).addRange(0x107BB, 0x107FF).addRange(0x10806, 0x10807).addRange(0x10839, 0x1083B).addRange(0x1083D, 0x1083E).addRange(0x1089F, 0x108A6).addRange(0x108B0, 0x108DF).addRange(0x108F6, 0x108FA).addRange(0x1091C, 0x1091E).addRange(0x1093A, 0x1093E).addRange(0x10940, 0x1097F).addRange(0x109B8, 0x109BB).addRange(0x109D0, 0x109D1).addRange(0x10A07, 0x10A0B).addRange(0x10A36, 0x10A37).addRange(0x10A3B, 0x10A3E).addRange(0x10A49, 0x10A4F).addRange(0x10A59, 0x10A5F).addRange(0x10AA0, 0x10ABF).addRange(0x10AE7, 0x10AEA).addRange(0x10AF7, 0x10AFF).addRange(0x10B36, 0x10B38).addRange(0x10B56, 0x10B57).addRange(0x10B73, 0x10B77);
    set.addRange(0x10B92, 0x10B98).addRange(0x10B9D, 0x10BA8).addRange(0x10BB0, 0x10BFF).addRange(0x10C49, 0x10C7F).addRange(0x10CB3, 0x10CBF).addRange(0x10CF3, 0x10CF9).addRange(0x10D28, 0x10D2F).addRange(0x10D3A, 0x10D3F).addRange(0x10D66, 0x10D68).addRange(0x10D86, 0x10D8D).addRange(0x10D90, 0x10E5F).addRange(0x10EAE, 0x10EAF).addRange(0x10EB2, 0x10EC1).addRange(0x10EC5, 0x10EFB).addRange(0x10F28, 0x10F2F).addRange(0x10F5A, 0x10F6F).addRange(0x10F8A, 0x10FAF).addRange(0x10FCC, 0x10FDF).addRange(0x10FF7, 0x10FFF).addRange(0x1104E, 0x11051).addRange(0x11076, 0x1107E).addRange(0x110C3, 0x110CC).addRange(0x110CE, 0x110CF).addRange(0x110E9, 0x110EF).addRange(0x110FA, 0x110FF).addRange(0x11148, 0x1114F).addRange(0x11177, 0x1117F).addRange(0x111F5, 0x111FF).addRange(0x11242, 0x1127F).addRange(0x112AA, 0x112AF).addRange(0x112EB, 0x112EF).addRange(0x112FA, 0x112FF).addRange(0x1130D, 0x1130E).addRange(0x11311, 0x11312).addRange(0x11345, 0x11346).addRange(0x11349, 0x1134A).addRange(0x1134E, 0x1134F).addRange(0x11351, 0x11356).addRange(0x11358, 0x1135C).addRange(0x11364, 0x11365).addRange(0x1136D, 0x1136F).addRange(0x11375, 0x1137F).addRange(0x1138C, 0x1138D).addRange(0x113C3, 0x113C4).addRange(0x113D9, 0x113E0).addRange(0x113E3, 0x113FF).addRange(0x11462, 0x1147F).addRange(0x114C8, 0x114CF).addRange(0x114DA, 0x1157F).addRange(0x115B6, 0x115B7).addRange(0x115DE, 0x115FF);
    set.addRange(0x11645, 0x1164F).addRange(0x1165A, 0x1165F).addRange(0x1166D, 0x1167F).addRange(0x116BA, 0x116BF).addRange(0x116CA, 0x116CF).addRange(0x116E4, 0x116FF).addRange(0x1171B, 0x1171C).addRange(0x1172C, 0x1172F).addRange(0x11747, 0x117FF).addRange(0x1183C, 0x1189F).addRange(0x118F3, 0x118FE).addRange(0x11907, 0x11908).addRange(0x1190A, 0x1190B).addRange(0x11939, 0x1193A).addRange(0x11947, 0x1194F).addRange(0x1195A, 0x1199F).addRange(0x119A8, 0x119A9).addRange(0x119D8, 0x119D9).addRange(0x119E5, 0x119FF).addRange(0x11A48, 0x11A4F).addRange(0x11AA3, 0x11AAF).addRange(0x11AF9, 0x11AFF).addRange(0x11B0A, 0x11BBF).addRange(0x11BE2, 0x11BEF).addRange(0x11BFA, 0x11BFF).addRange(0x11C46, 0x11C4F).addRange(0x11C6D, 0x11C6F).addRange(0x11C90, 0x11C91).addRange(0x11CB7, 0x11CFF).addRange(0x11D37, 0x11D39).addRange(0x11D48, 0x11D4F).addRange(0x11D5A, 0x11D5F).addRange(0x11D99, 0x11D9F).addRange(0x11DAA, 0x11EDF).addRange(0x11EF9, 0x11EFF).addRange(0x11F3B, 0x11F3D).addRange(0x11F5B, 0x11FAF).addRange(0x11FB1, 0x11FBF).addRange(0x11FF2, 0x11FFE).addRange(0x1239A, 0x123FF).addRange(0x12475, 0x1247F).addRange(0x12544, 0x12F8F).addRange(0x12FF3, 0x12FFF).addRange(0x13456, 0x1345F).addRange(0x143FB, 0x143FF).addRange(0x14647, 0x160FF).addRange(0x1613A, 0x167FF).addRange(0x16A39, 0x16A3F).addRange(0x16A6A, 0x16A6D).addRange(0x16ACA, 0x16ACF).addRange(0x16AEE, 0x16AEF);
    set.addRange(0x16AF6, 0x16AFF).addRange(0x16B46, 0x16B4F).addRange(0x16B78, 0x16B7C).addRange(0x16B90, 0x16D3F).addRange(0x16D7A, 0x16E3F).addRange(0x16E9B, 0x16EFF).addRange(0x16F4B, 0x16F4E).addRange(0x16F88, 0x16F8E).addRange(0x16FA0, 0x16FDF).addRange(0x16FE5, 0x16FEF).addRange(0x16FF2, 0x16FFF).addRange(0x187F8, 0x187FF).addRange(0x18CD6, 0x18CFE).addRange(0x18D09, 0x1AFEF).addRange(0x1B123, 0x1B131).addRange(0x1B133, 0x1B14F).addRange(0x1B153, 0x1B154).addRange(0x1B156, 0x1B163).addRange(0x1B168, 0x1B16F).addRange(0x1B2FC, 0x1BBFF).addRange(0x1BC6B, 0x1BC6F).addRange(0x1BC7D, 0x1BC7F).addRange(0x1BC89, 0x1BC8F).addRange(0x1BC9A, 0x1BC9B).addRange(0x1BCA4, 0x1CBFF).addRange(0x1CCFA, 0x1CCFF).addRange(0x1CEB4, 0x1CEFF).addRange(0x1CF2E, 0x1CF2F).addRange(0x1CF47, 0x1CF4F).addRange(0x1CFC4, 0x1CFFF).addRange(0x1D0F6, 0x1D0FF).addRange(0x1D127, 0x1D128).addRange(0x1D1EB, 0x1D1FF).addRange(0x1D246, 0x1D2BF).addRange(0x1D2D4, 0x1D2DF).addRange(0x1D2F4, 0x1D2FF).addRange(0x1D357, 0x1D35F).addRange(0x1D379, 0x1D3FF).addRange(0x1D4A0, 0x1D4A1).addRange(0x1D4A3, 0x1D4A4).addRange(0x1D4A7, 0x1D4A8).addRange(0x1D50B, 0x1D50C).addRange(0x1D547, 0x1D549).addRange(0x1D6A6, 0x1D6A7).addRange(0x1D7CC, 0x1D7CD).addRange(0x1DA8C, 0x1DA9A).addRange(0x1DAB0, 0x1DEFF).addRange(0x1DF1F, 0x1DF24).addRange(0x1DF2B, 0x1DFFF).addRange(0x1E019, 0x1E01A).addRange(0x1E02B, 0x1E02F);
    set.addRange(0x1E06E, 0x1E08E).addRange(0x1E090, 0x1E0FF).addRange(0x1E12D, 0x1E12F).addRange(0x1E13E, 0x1E13F).addRange(0x1E14A, 0x1E14D).addRange(0x1E150, 0x1E28F).addRange(0x1E2AF, 0x1E2BF).addRange(0x1E2FA, 0x1E2FE).addRange(0x1E300, 0x1E4CF).addRange(0x1E4FA, 0x1E5CF).addRange(0x1E5FB, 0x1E5FE).addRange(0x1E600, 0x1E7DF).addRange(0x1E8C5, 0x1E8C6).addRange(0x1E8D7, 0x1E8FF).addRange(0x1E94C, 0x1E94F).addRange(0x1E95A, 0x1E95D).addRange(0x1E960, 0x1EC70).addRange(0x1ECB5, 0x1ED00).addRange(0x1ED3E, 0x1EDFF).addRange(0x1EE25, 0x1EE26).addRange(0x1EE3C, 0x1EE41).addRange(0x1EE43, 0x1EE46).addRange(0x1EE55, 0x1EE56).addRange(0x1EE65, 0x1EE66).addRange(0x1EE9C, 0x1EEA0).addRange(0x1EEBC, 0x1EEEF).addRange(0x1EEF2, 0x1EFFF).addRange(0x1F02C, 0x1F02F).addRange(0x1F094, 0x1F09F).addRange(0x1F0AF, 0x1F0B0).addRange(0x1F0F6, 0x1F0FF).addRange(0x1F1AE, 0x1F1E5).addRange(0x1F203, 0x1F20F).addRange(0x1F23C, 0x1F23F).addRange(0x1F249, 0x1F24F).addRange(0x1F252, 0x1F25F).addRange(0x1F266, 0x1F2FF).addRange(0x1F6D8, 0x1F6DB).addRange(0x1F6ED, 0x1F6EF).addRange(0x1F6FD, 0x1F6FF).addRange(0x1F777, 0x1F77A).addRange(0x1F7DA, 0x1F7DF).addRange(0x1F7EC, 0x1F7EF).addRange(0x1F7F1, 0x1F7FF).addRange(0x1F80C, 0x1F80F).addRange(0x1F848, 0x1F84F).addRange(0x1F85A, 0x1F85F).addRange(0x1F888, 0x1F88F).addRange(0x1F8AE, 0x1F8AF).addRange(0x1F8BC, 0x1F8BF).addRange(0x1F8C2, 0x1F8FF);
    set.addRange(0x1FA54, 0x1FA5F).addRange(0x1FA6E, 0x1FA6F).addRange(0x1FA7D, 0x1FA7F).addRange(0x1FA8A, 0x1FA8E).addRange(0x1FAC7, 0x1FACD).addRange(0x1FADD, 0x1FADE).addRange(0x1FAEA, 0x1FAEF).addRange(0x1FAF9, 0x1FAFF).addRange(0x1FBFA, 0x1FFFF).addRange(0x2A6E0, 0x2A6FF).addRange(0x2B73A, 0x2B73F).addRange(0x2B81E, 0x2B81F).addRange(0x2CEA2, 0x2CEAF).addRange(0x2EBE1, 0x2EBEF).addRange(0x2EE5E, 0x2F7FF).addRange(0x2FA1E, 0x2FFFF).addRange(0x3134B, 0x3134F).addRange(0x323B0, 0xE0000).addRange(0xE0002, 0xE001F).addRange(0xE0080, 0xE00FF).addRange(0xE01F0, 0xEFFFF).addRange(0xFFFFE, 0xFFFFF).addRange(0x10FFFE, 0x10FFFF);
    Unassigned.characters = set;
    return Unassigned;
  }

var Uppercase_Letter = {};

var hasRequiredUppercase_Letter;
  function requireUppercase_Letter() {
    if (hasRequiredUppercase_Letter) return Uppercase_Letter;
    hasRequiredUppercase_Letter = 1;
    var set = regenerateExports(0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14A, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x17B, 0x17D, 0x184, 0x1A2, 0x1A4, 0x1A9, 0x1AC, 0x1B5, 0x1BC, 0x1C4, 0x1C7, 0x1CA, 0x1CD, 0x1CF, 0x1D1, 0x1D3, 0x1D5, 0x1D7, 0x1D9, 0x1DB, 0x1DE, 0x1E0, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x1EA, 0x1EC, 0x1EE, 0x1F1, 0x1F4, 0x1FA, 0x1FC, 0x1FE, 0x200, 0x202, 0x204, 0x206, 0x208, 0x20A, 0x20C, 0x20E, 0x210, 0x212, 0x214, 0x216, 0x218, 0x21A, 0x21C, 0x21E, 0x220, 0x222, 0x224, 0x226, 0x228, 0x22A, 0x22C, 0x22E, 0x230, 0x232, 0x241, 0x248, 0x24A, 0x24C, 0x24E, 0x370, 0x372, 0x376, 0x37F, 0x386, 0x38C, 0x3CF, 0x3D8, 0x3DA, 0x3DC, 0x3DE, 0x3E0, 0x3E2, 0x3E4, 0x3E6, 0x3E8, 0x3EA, 0x3EC, 0x3EE, 0x3F4, 0x3F7, 0x460, 0x462, 0x464, 0x466, 0x468, 0x46A, 0x46C, 0x46E, 0x470, 0x472, 0x474, 0x476, 0x478, 0x47A, 0x47C, 0x47E, 0x480, 0x48A, 0x48C, 0x48E, 0x490, 0x492, 0x494, 0x496, 0x498, 0x49A, 0x49C, 0x49E, 0x4A0, 0x4A2, 0x4A4, 0x4A6, 0x4A8, 0x4AA, 0x4AC, 0x4AE, 0x4B0, 0x4B2, 0x4B4, 0x4B6, 0x4B8, 0x4BA, 0x4BC, 0x4BE, 0x4C3, 0x4C5, 0x4C7, 0x4C9, 0x4CB, 0x4CD, 0x4D0, 0x4D2, 0x4D4, 0x4D6, 0x4D8, 0x4DA, 0x4DC, 0x4DE, 0x4E0, 0x4E2, 0x4E4, 0x4E6, 0x4E8, 0x4EA, 0x4EC, 0x4EE, 0x4F0, 0x4F2, 0x4F4, 0x4F6, 0x4F8, 0x4FA, 0x4FC, 0x4FE, 0x500, 0x502, 0x504, 0x506, 0x508, 0x50A, 0x50C, 0x50E, 0x510, 0x512, 0x514, 0x516, 0x518, 0x51A, 0x51C, 0x51E, 0x520, 0x522, 0x524, 0x526, 0x528, 0x52A, 0x52C, 0x52E, 0x10C7, 0x10CD, 0x1C89, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1E9E, 0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F59, 0x1F5B, 0x1F5D, 0x1F5F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2145, 0x2183, 0x2C60, 0x2C67, 0x2C69, 0x2C6B, 0x2C72, 0x2C75, 0x2C82, 0x2C84, 0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98, 0x2C9A, 0x2C9C, 0x2C9E, 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC, 0x2CAE, 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, 0x2CC0, 0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, 0x2CD0, 0x2CD2, 0x2CD4, 0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2, 0xA640, 0xA642, 0xA644, 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652, 0xA654, 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, 0xA666, 0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, 0xA688, 0xA68A, 0xA68C, 0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726, 0xA728, 0xA72A, 0xA72C, 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C, 0xA73E, 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, 0xA750, 0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, 0xA760, 0xA762, 0xA764, 0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA779, 0xA77B, 0xA780, 0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A, 0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7B6, 0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C9, 0xA7D0, 0xA7D6, 0xA7D8, 0xA7DA, 0xA7DC, 0xA7F5, 0x1D49C, 0x1D4A2, 0x1D546, 0x1D7CA);
    set.addRange(0x41, 0x5A).addRange(0xC0, 0xD6).addRange(0xD8, 0xDE).addRange(0x178, 0x179).addRange(0x181, 0x182).addRange(0x186, 0x187).addRange(0x189, 0x18B).addRange(0x18E, 0x191).addRange(0x193, 0x194).addRange(0x196, 0x198).addRange(0x19C, 0x19D).addRange(0x19F, 0x1A0).addRange(0x1A6, 0x1A7).addRange(0x1AE, 0x1AF).addRange(0x1B1, 0x1B3).addRange(0x1B7, 0x1B8).addRange(0x1F6, 0x1F8).addRange(0x23A, 0x23B).addRange(0x23D, 0x23E).addRange(0x243, 0x246).addRange(0x388, 0x38A).addRange(0x38E, 0x38F).addRange(0x391, 0x3A1).addRange(0x3A3, 0x3AB).addRange(0x3D2, 0x3D4).addRange(0x3F9, 0x3FA).addRange(0x3FD, 0x42F).addRange(0x4C0, 0x4C1).addRange(0x531, 0x556).addRange(0x10A0, 0x10C5).addRange(0x13A0, 0x13F5).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x1F08, 0x1F0F).addRange(0x1F18, 0x1F1D).addRange(0x1F28, 0x1F2F).addRange(0x1F38, 0x1F3F).addRange(0x1F48, 0x1F4D).addRange(0x1F68, 0x1F6F).addRange(0x1FB8, 0x1FBB).addRange(0x1FC8, 0x1FCB).addRange(0x1FD8, 0x1FDB).addRange(0x1FE8, 0x1FEC).addRange(0x1FF8, 0x1FFB).addRange(0x210B, 0x210D).addRange(0x2110, 0x2112).addRange(0x2119, 0x211D).addRange(0x212A, 0x212D).addRange(0x2130, 0x2133).addRange(0x213E, 0x213F).addRange(0x2C00, 0x2C2F);
    set.addRange(0x2C62, 0x2C64).addRange(0x2C6D, 0x2C70).addRange(0x2C7E, 0x2C80).addRange(0xA77D, 0xA77E).addRange(0xA7AA, 0xA7AE).addRange(0xA7B0, 0xA7B4).addRange(0xA7C4, 0xA7C7).addRange(0xA7CB, 0xA7CC).addRange(0xFF21, 0xFF3A).addRange(0x10400, 0x10427).addRange(0x104B0, 0x104D3).addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10C80, 0x10CB2).addRange(0x10D50, 0x10D65).addRange(0x118A0, 0x118BF).addRange(0x16E40, 0x16E5F).addRange(0x1D400, 0x1D419).addRange(0x1D434, 0x1D44D).addRange(0x1D468, 0x1D481).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B5).addRange(0x1D4D0, 0x1D4E9).addRange(0x1D504, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D538, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D56C, 0x1D585).addRange(0x1D5A0, 0x1D5B9).addRange(0x1D5D4, 0x1D5ED).addRange(0x1D608, 0x1D621).addRange(0x1D63C, 0x1D655).addRange(0x1D670, 0x1D689).addRange(0x1D6A8, 0x1D6C0).addRange(0x1D6E2, 0x1D6FA).addRange(0x1D71C, 0x1D734).addRange(0x1D756, 0x1D76E).addRange(0x1D790, 0x1D7A8).addRange(0x1E900, 0x1E921);
    Uppercase_Letter.characters = set;
    return Uppercase_Letter;
  }

var regenerateUnicodeProperties;
  var hasRequiredRegenerateUnicodeProperties;
  function requireRegenerateUnicodeProperties() {
    if (hasRequiredRegenerateUnicodeProperties) return regenerateUnicodeProperties;
    hasRequiredRegenerateUnicodeProperties = 1;
    regenerateUnicodeProperties = new Map([['General_Category', ['Cased_Letter', 'Close_Punctuation', 'Connector_Punctuation', 'Control', 'Currency_Symbol', 'Dash_Punctuation', 'Decimal_Number', 'Enclosing_Mark', 'Final_Punctuation', 'Format', 'Initial_Punctuation', 'Letter', 'Letter_Number', 'Line_Separator', 'Lowercase_Letter', 'Mark', 'Math_Symbol', 'Modifier_Letter', 'Modifier_Symbol', 'Nonspacing_Mark', 'Number', 'Open_Punctuation', 'Other', 'Other_Letter', 'Other_Number', 'Other_Punctuation', 'Other_Symbol', 'Paragraph_Separator', 'Private_Use', 'Punctuation', 'Separator', 'Space_Separator', 'Spacing_Mark', 'Surrogate', 'Symbol', 'Titlecase_Letter', 'Unassigned', 'Uppercase_Letter']], ['Script', ['Adlam', 'Ahom', 'Anatolian_Hieroglyphs', 'Arabic', 'Armenian', 'Avestan', 'Balinese', 'Bamum', 'Bassa_Vah', 'Batak', 'Bengali', 'Bhaiksuki', 'Bopomofo', 'Brahmi', 'Braille', 'Buginese', 'Buhid', 'Canadian_Aboriginal', 'Carian', 'Caucasian_Albanian', 'Chakma', 'Cham', 'Cherokee', 'Chorasmian', 'Common', 'Coptic', 'Cuneiform', 'Cypriot', 'Cypro_Minoan', 'Cyrillic', 'Deseret', 'Devanagari', 'Dives_Akuru', 'Dogra', 'Duployan', 'Egyptian_Hieroglyphs', 'Elbasan', 'Elymaic', 'Ethiopic', 'Garay', 'Georgian', 'Glagolitic', 'Gothic', 'Grantha', 'Greek', 'Gujarati', 'Gunjala_Gondi', 'Gurmukhi', 'Gurung_Khema', 'Han', 'Hangul', 'Hanifi_Rohingya', 'Hanunoo', 'Hatran', 'Hebrew', 'Hiragana', 'Imperial_Aramaic', 'Inherited', 'Inscriptional_Pahlavi', 'Inscriptional_Parthian', 'Javanese', 'Kaithi', 'Kannada', 'Katakana', 'Kawi', 'Kayah_Li', 'Kharoshthi', 'Khitan_Small_Script', 'Khmer', 'Khojki', 'Khudawadi', 'Kirat_Rai', 'Lao', 'Latin', 'Lepcha', 'Limbu', 'Linear_A', 'Linear_B', 'Lisu', 'Lycian', 'Lydian', 'Mahajani', 'Makasar', 'Malayalam', 'Mandaic', 'Manichaean', 'Marchen', 'Masaram_Gondi', 'Medefaidrin', 'Meetei_Mayek', 'Mende_Kikakui', 'Meroitic_Cursive', 'Meroitic_Hieroglyphs', 'Miao', 'Modi', 'Mongolian', 'Mro', 'Multani', 'Myanmar', 'Nabataean', 'Nag_Mundari', 'Nandinagari', 'New_Tai_Lue', 'Newa', 'Nko', 'Nushu', 'Nyiakeng_Puachue_Hmong', 'Ogham', 'Ol_Chiki', 'Ol_Onal', 'Old_Hungarian', 'Old_Italic', 'Old_North_Arabian', 'Old_Permic', 'Old_Persian', 'Old_Sogdian', 'Old_South_Arabian', 'Old_Turkic', 'Old_Uyghur', 'Oriya', 'Osage', 'Osmanya', 'Pahawh_Hmong', 'Palmyrene', 'Pau_Cin_Hau', 'Phags_Pa', 'Phoenician', 'Psalter_Pahlavi', 'Rejang', 'Runic', 'Samaritan', 'Saurashtra', 'Sharada', 'Shavian', 'Siddham', 'SignWriting', 'Sinhala', 'Sogdian', 'Sora_Sompeng', 'Soyombo', 'Sundanese', 'Sunuwar', 'Syloti_Nagri', 'Syriac', 'Tagalog', 'Tagbanwa', 'Tai_Le', 'Tai_Tham', 'Tai_Viet', 'Takri', 'Tamil', 'Tangsa', 'Tangut', 'Telugu', 'Thaana', 'Thai', 'Tibetan', 'Tifinagh', 'Tirhuta', 'Todhri', 'Toto', 'Tulu_Tigalari', 'Ugaritic', 'Vai', 'Vithkuqi', 'Wancho', 'Warang_Citi', 'Yezidi', 'Yi', 'Zanabazar_Square']], ['Script_Extensions', ['Adlam', 'Ahom', 'Anatolian_Hieroglyphs', 'Arabic', 'Armenian', 'Avestan', 'Balinese', 'Bamum', 'Bassa_Vah', 'Batak', 'Bengali', 'Bhaiksuki', 'Bopomofo', 'Brahmi', 'Braille', 'Buginese', 'Buhid', 'Canadian_Aboriginal', 'Carian', 'Caucasian_Albanian', 'Chakma', 'Cham', 'Cherokee', 'Chorasmian', 'Common', 'Coptic', 'Cuneiform', 'Cypriot', 'Cypro_Minoan', 'Cyrillic', 'Deseret', 'Devanagari', 'Dives_Akuru', 'Dogra', 'Duployan', 'Egyptian_Hieroglyphs', 'Elbasan', 'Elymaic', 'Ethiopic', 'Garay', 'Georgian', 'Glagolitic', 'Gothic', 'Grantha', 'Greek', 'Gujarati', 'Gunjala_Gondi', 'Gurmukhi', 'Gurung_Khema', 'Han', 'Hangul', 'Hanifi_Rohingya', 'Hanunoo', 'Hatran', 'Hebrew', 'Hiragana', 'Imperial_Aramaic', 'Inherited', 'Inscriptional_Pahlavi', 'Inscriptional_Parthian', 'Javanese', 'Kaithi', 'Kannada', 'Katakana', 'Kawi', 'Kayah_Li', 'Kharoshthi', 'Khitan_Small_Script', 'Khmer', 'Khojki', 'Khudawadi', 'Kirat_Rai', 'Lao', 'Latin', 'Lepcha', 'Limbu', 'Linear_A', 'Linear_B', 'Lisu', 'Lycian', 'Lydian', 'Mahajani', 'Makasar', 'Malayalam', 'Mandaic', 'Manichaean', 'Marchen', 'Masaram_Gondi', 'Medefaidrin', 'Meetei_Mayek', 'Mende_Kikakui', 'Meroitic_Cursive', 'Meroitic_Hieroglyphs', 'Miao', 'Modi', 'Mongolian', 'Mro', 'Multani', 'Myanmar', 'Nabataean', 'Nag_Mundari', 'Nandinagari', 'New_Tai_Lue', 'Newa', 'Nko', 'Nushu', 'Nyiakeng_Puachue_Hmong', 'Ogham', 'Ol_Chiki', 'Ol_Onal', 'Old_Hungarian', 'Old_Italic', 'Old_North_Arabian', 'Old_Permic', 'Old_Persian', 'Old_Sogdian', 'Old_South_Arabian', 'Old_Turkic', 'Old_Uyghur', 'Oriya', 'Osage', 'Osmanya', 'Pahawh_Hmong', 'Palmyrene', 'Pau_Cin_Hau', 'Phags_Pa', 'Phoenician', 'Psalter_Pahlavi', 'Rejang', 'Runic', 'Samaritan', 'Saurashtra', 'Sharada', 'Shavian', 'Siddham', 'SignWriting', 'Sinhala', 'Sogdian', 'Sora_Sompeng', 'Soyombo', 'Sundanese', 'Sunuwar', 'Syloti_Nagri', 'Syriac', 'Tagalog', 'Tagbanwa', 'Tai_Le', 'Tai_Tham', 'Tai_Viet', 'Takri', 'Tamil', 'Tangsa', 'Tangut', 'Telugu', 'Thaana', 'Thai', 'Tibetan', 'Tifinagh', 'Tirhuta', 'Todhri', 'Toto', 'Tulu_Tigalari', 'Ugaritic', 'Vai', 'Vithkuqi', 'Wancho', 'Warang_Citi', 'Yezidi', 'Yi', 'Zanabazar_Square']], ['Binary_Property', ['ASCII', 'ASCII_Hex_Digit', 'Alphabetic', 'Any', 'Assigned', 'Bidi_Control', 'Bidi_Mirrored', 'Case_Ignorable', 'Cased', 'Changes_When_Casefolded', 'Changes_When_Casemapped', 'Changes_When_Lowercased', 'Changes_When_NFKC_Casefolded', 'Changes_When_Titlecased', 'Changes_When_Uppercased', 'Dash', 'Default_Ignorable_Code_Point', 'Deprecated', 'Diacritic', 'Emoji', 'Emoji_Component', 'Emoji_Modifier', 'Emoji_Modifier_Base', 'Emoji_Presentation', 'Extended_Pictographic', 'Extender', 'Grapheme_Base', 'Grapheme_Extend', 'Hex_Digit', 'IDS_Binary_Operator', 'IDS_Trinary_Operator', 'ID_Continue', 'ID_Start', 'Ideographic', 'Join_Control', 'Logical_Order_Exception', 'Lowercase', 'Math', 'Noncharacter_Code_Point', 'Pattern_Syntax', 'Pattern_White_Space', 'Quotation_Mark', 'Radical', 'Regional_Indicator', 'Sentence_Terminal', 'Soft_Dotted', 'Terminal_Punctuation', 'Unified_Ideograph', 'Uppercase', 'Variation_Selector', 'White_Space', 'XID_Continue', 'XID_Start']], ['Property_of_Strings', ['Basic_Emoji', 'Emoji_Keycap_Sequence', 'RGI_Emoji', 'RGI_Emoji_Flag_Sequence', 'RGI_Emoji_Modifier_Sequence', 'RGI_Emoji_Tag_Sequence', 'RGI_Emoji_ZWJ_Sequence']]]);
    return regenerateUnicodeProperties;
  }

var Basic_Emoji = {};

var hasRequiredBasic_Emoji;
  function requireBasic_Emoji() {
    if (hasRequiredBasic_Emoji) return Basic_Emoji;
    hasRequiredBasic_Emoji = 1;
    var set = regenerateExports(0x23F0, 0x23F3, 0x267F, 0x2693, 0x26A1, 0x26CE, 0x26D4, 0x26EA, 0x26F5, 0x26FA, 0x26FD, 0x2705, 0x2728, 0x274C, 0x274E, 0x2757, 0x27B0, 0x27BF, 0x2B50, 0x2B55, 0x1F004, 0x1F0CF, 0x1F18E, 0x1F201, 0x1F21A, 0x1F22F, 0x1F3F4, 0x1F440, 0x1F57A, 0x1F5A4, 0x1F6CC, 0x1F7F0);
    set.addRange(0x231A, 0x231B).addRange(0x23E9, 0x23EC).addRange(0x25FD, 0x25FE).addRange(0x2614, 0x2615).addRange(0x2648, 0x2653).addRange(0x26AA, 0x26AB).addRange(0x26BD, 0x26BE).addRange(0x26C4, 0x26C5).addRange(0x26F2, 0x26F3).addRange(0x270A, 0x270B).addRange(0x2753, 0x2755).addRange(0x2795, 0x2797).addRange(0x2B1B, 0x2B1C).addRange(0x1F191, 0x1F19A).addRange(0x1F232, 0x1F236).addRange(0x1F238, 0x1F23A).addRange(0x1F250, 0x1F251).addRange(0x1F300, 0x1F320).addRange(0x1F32D, 0x1F335).addRange(0x1F337, 0x1F37C).addRange(0x1F37E, 0x1F393).addRange(0x1F3A0, 0x1F3CA).addRange(0x1F3CF, 0x1F3D3).addRange(0x1F3E0, 0x1F3F0).addRange(0x1F3F8, 0x1F43E).addRange(0x1F442, 0x1F4FC).addRange(0x1F4FF, 0x1F53D).addRange(0x1F54B, 0x1F54E).addRange(0x1F550, 0x1F567).addRange(0x1F595, 0x1F596).addRange(0x1F5FB, 0x1F64F).addRange(0x1F680, 0x1F6C5).addRange(0x1F6D0, 0x1F6D2).addRange(0x1F6D5, 0x1F6D7).addRange(0x1F6DC, 0x1F6DF).addRange(0x1F6EB, 0x1F6EC).addRange(0x1F6F4, 0x1F6FC).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F90C, 0x1F93A).addRange(0x1F93C, 0x1F945).addRange(0x1F947, 0x1F9FF).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA89).addRange(0x1FA8F, 0x1FAC6).addRange(0x1FACE, 0x1FADC).addRange(0x1FADF, 0x1FAE9).addRange(0x1FAF0, 0x1FAF8);
    Basic_Emoji.characters = set;
    Basic_Emoji.strings = ["\xA9\uFE0F", "\xAE\uFE0F", "\u203C\uFE0F", "\u2049\uFE0F", "\u2122\uFE0F", "\u2139\uFE0F", "\u2194\uFE0F", "\u2195\uFE0F", "\u2196\uFE0F", "\u2197\uFE0F", "\u2198\uFE0F", "\u2199\uFE0F", "\u21A9\uFE0F", "\u21AA\uFE0F", "\u2328\uFE0F", "\u23CF\uFE0F", "\u23ED\uFE0F", "\u23EE\uFE0F", "\u23EF\uFE0F", "\u23F1\uFE0F", "\u23F2\uFE0F", "\u23F8\uFE0F", "\u23F9\uFE0F", "\u23FA\uFE0F", "\u24C2\uFE0F", "\u25AA\uFE0F", "\u25AB\uFE0F", "\u25B6\uFE0F", "\u25C0\uFE0F", "\u25FB\uFE0F", "\u25FC\uFE0F", "\u2600\uFE0F", "\u2601\uFE0F", "\u2602\uFE0F", "\u2603\uFE0F", "\u2604\uFE0F", "\u260E\uFE0F", "\u2611\uFE0F", "\u2618\uFE0F", "\u261D\uFE0F", "\u2620\uFE0F", "\u2622\uFE0F", "\u2623\uFE0F", "\u2626\uFE0F", "\u262A\uFE0F", "\u262E\uFE0F", "\u262F\uFE0F", "\u2638\uFE0F", "\u2639\uFE0F", "\u263A\uFE0F", "\u2640\uFE0F", "\u2642\uFE0F", "\u265F\uFE0F", "\u2660\uFE0F", "\u2663\uFE0F", "\u2665\uFE0F", "\u2666\uFE0F", "\u2668\uFE0F", "\u267B\uFE0F", "\u267E\uFE0F", "\u2692\uFE0F", "\u2694\uFE0F", "\u2695\uFE0F", "\u2696\uFE0F", "\u2697\uFE0F", "\u2699\uFE0F", "\u269B\uFE0F", "\u269C\uFE0F", "\u26A0\uFE0F", "\u26A7\uFE0F", "\u26B0\uFE0F", "\u26B1\uFE0F", "\u26C8\uFE0F", "\u26CF\uFE0F", "\u26D1\uFE0F", "\u26D3\uFE0F", "\u26E9\uFE0F", "\u26F0\uFE0F", "\u26F1\uFE0F", "\u26F4\uFE0F", "\u26F7\uFE0F", "\u26F8\uFE0F", "\u26F9\uFE0F", "\u2702\uFE0F", "\u2708\uFE0F", "\u2709\uFE0F", "\u270C\uFE0F", "\u270D\uFE0F", "\u270F\uFE0F", "\u2712\uFE0F", "\u2714\uFE0F", "\u2716\uFE0F", "\u271D\uFE0F", "\u2721\uFE0F", "\u2733\uFE0F", "\u2734\uFE0F", "\u2744\uFE0F", "\u2747\uFE0F", "\u2763\uFE0F", "\u2764\uFE0F", "\u27A1\uFE0F", "\u2934\uFE0F", "\u2935\uFE0F", "\u2B05\uFE0F", "\u2B06\uFE0F", "\u2B07\uFE0F", "\u3030\uFE0F", "\u303D\uFE0F", "\u3297\uFE0F", "\u3299\uFE0F", "\uD83C\uDD70\uFE0F", "\uD83C\uDD71\uFE0F", "\uD83C\uDD7E\uFE0F", "\uD83C\uDD7F\uFE0F", "\uD83C\uDE02\uFE0F", "\uD83C\uDE37\uFE0F", "\uD83C\uDF21\uFE0F", "\uD83C\uDF24\uFE0F", "\uD83C\uDF25\uFE0F", "\uD83C\uDF26\uFE0F", "\uD83C\uDF27\uFE0F", "\uD83C\uDF28\uFE0F", "\uD83C\uDF29\uFE0F", "\uD83C\uDF2A\uFE0F", "\uD83C\uDF2B\uFE0F", "\uD83C\uDF2C\uFE0F", "\uD83C\uDF36\uFE0F", "\uD83C\uDF7D\uFE0F", "\uD83C\uDF96\uFE0F", "\uD83C\uDF97\uFE0F", "\uD83C\uDF99\uFE0F", "\uD83C\uDF9A\uFE0F", "\uD83C\uDF9B\uFE0F", "\uD83C\uDF9E\uFE0F", "\uD83C\uDF9F\uFE0F", "\uD83C\uDFCB\uFE0F", "\uD83C\uDFCC\uFE0F", "\uD83C\uDFCD\uFE0F", "\uD83C\uDFCE\uFE0F", "\uD83C\uDFD4\uFE0F", "\uD83C\uDFD5\uFE0F", "\uD83C\uDFD6\uFE0F", "\uD83C\uDFD7\uFE0F", "\uD83C\uDFD8\uFE0F", "\uD83C\uDFD9\uFE0F", "\uD83C\uDFDA\uFE0F", "\uD83C\uDFDB\uFE0F", "\uD83C\uDFDC\uFE0F", "\uD83C\uDFDD\uFE0F", "\uD83C\uDFDE\uFE0F", "\uD83C\uDFDF\uFE0F", "\uD83C\uDFF3\uFE0F", "\uD83C\uDFF5\uFE0F", "\uD83C\uDFF7\uFE0F", "\uD83D\uDC3F\uFE0F", "\uD83D\uDC41\uFE0F", "\uD83D\uDCFD\uFE0F", "\uD83D\uDD49\uFE0F", "\uD83D\uDD4A\uFE0F", "\uD83D\uDD6F\uFE0F", "\uD83D\uDD70\uFE0F", "\uD83D\uDD73\uFE0F", "\uD83D\uDD74\uFE0F", "\uD83D\uDD75\uFE0F", "\uD83D\uDD76\uFE0F", "\uD83D\uDD77\uFE0F", "\uD83D\uDD78\uFE0F", "\uD83D\uDD79\uFE0F", "\uD83D\uDD87\uFE0F", "\uD83D\uDD8A\uFE0F", "\uD83D\uDD8B\uFE0F", "\uD83D\uDD8C\uFE0F", "\uD83D\uDD8D\uFE0F", "\uD83D\uDD90\uFE0F", "\uD83D\uDDA5\uFE0F", "\uD83D\uDDA8\uFE0F", "\uD83D\uDDB1\uFE0F", "\uD83D\uDDB2\uFE0F", "\uD83D\uDDBC\uFE0F", "\uD83D\uDDC2\uFE0F", "\uD83D\uDDC3\uFE0F", "\uD83D\uDDC4\uFE0F", "\uD83D\uDDD1\uFE0F", "\uD83D\uDDD2\uFE0F", "\uD83D\uDDD3\uFE0F", "\uD83D\uDDDC\uFE0F", "\uD83D\uDDDD\uFE0F", "\uD83D\uDDDE\uFE0F", "\uD83D\uDDE1\uFE0F", "\uD83D\uDDE3\uFE0F", "\uD83D\uDDE8\uFE0F", "\uD83D\uDDEF\uFE0F", "\uD83D\uDDF3\uFE0F", "\uD83D\uDDFA\uFE0F", "\uD83D\uDECB\uFE0F", "\uD83D\uDECD\uFE0F", "\uD83D\uDECE\uFE0F", "\uD83D\uDECF\uFE0F", "\uD83D\uDEE0\uFE0F", "\uD83D\uDEE1\uFE0F", "\uD83D\uDEE2\uFE0F", "\uD83D\uDEE3\uFE0F", "\uD83D\uDEE4\uFE0F", "\uD83D\uDEE5\uFE0F", "\uD83D\uDEE9\uFE0F", "\uD83D\uDEF0\uFE0F", "\uD83D\uDEF3\uFE0F"];
    return Basic_Emoji;
  }

var Emoji_Keycap_Sequence = {};

var hasRequiredEmoji_Keycap_Sequence;
  function requireEmoji_Keycap_Sequence() {
    if (hasRequiredEmoji_Keycap_Sequence) return Emoji_Keycap_Sequence;
    hasRequiredEmoji_Keycap_Sequence = 1;
    var set = regenerateExports();
    Emoji_Keycap_Sequence.characters = set;
    Emoji_Keycap_Sequence.strings = ["#\uFE0F\u20E3", "*\uFE0F\u20E3", "0\uFE0F\u20E3", "1\uFE0F\u20E3", "2\uFE0F\u20E3", "3\uFE0F\u20E3", "4\uFE0F\u20E3", "5\uFE0F\u20E3", "6\uFE0F\u20E3", "7\uFE0F\u20E3", "8\uFE0F\u20E3", "9\uFE0F\u20E3"];
    return Emoji_Keycap_Sequence;
  }

var RGI_Emoji_Flag_Sequence = {};

var hasRequiredRGI_Emoji_Flag_Sequence;
  function requireRGI_Emoji_Flag_Sequence() {
    if (hasRequiredRGI_Emoji_Flag_Sequence) return RGI_Emoji_Flag_Sequence;
    hasRequiredRGI_Emoji_Flag_Sequence = 1;
    var set = regenerateExports();
    RGI_Emoji_Flag_Sequence.characters = set;
    RGI_Emoji_Flag_Sequence.strings = ["\uD83C\uDDE6\uD83C\uDDE8", "\uD83C\uDDE6\uD83C\uDDE9", "\uD83C\uDDE6\uD83C\uDDEA", "\uD83C\uDDE6\uD83C\uDDEB", "\uD83C\uDDE6\uD83C\uDDEC", "\uD83C\uDDE6\uD83C\uDDEE", "\uD83C\uDDE6\uD83C\uDDF1", "\uD83C\uDDE6\uD83C\uDDF2", "\uD83C\uDDE6\uD83C\uDDF4", "\uD83C\uDDE6\uD83C\uDDF6", "\uD83C\uDDE6\uD83C\uDDF7", "\uD83C\uDDE6\uD83C\uDDF8", "\uD83C\uDDE6\uD83C\uDDF9", "\uD83C\uDDE6\uD83C\uDDFA", "\uD83C\uDDE6\uD83C\uDDFC", "\uD83C\uDDE6\uD83C\uDDFD", "\uD83C\uDDE6\uD83C\uDDFF", "\uD83C\uDDE7\uD83C\uDDE6", "\uD83C\uDDE7\uD83C\uDDE7", "\uD83C\uDDE7\uD83C\uDDE9", "\uD83C\uDDE7\uD83C\uDDEA", "\uD83C\uDDE7\uD83C\uDDEB", "\uD83C\uDDE7\uD83C\uDDEC", "\uD83C\uDDE7\uD83C\uDDED", "\uD83C\uDDE7\uD83C\uDDEE", "\uD83C\uDDE7\uD83C\uDDEF", "\uD83C\uDDE7\uD83C\uDDF1", "\uD83C\uDDE7\uD83C\uDDF2", "\uD83C\uDDE7\uD83C\uDDF3", "\uD83C\uDDE7\uD83C\uDDF4", "\uD83C\uDDE7\uD83C\uDDF6", "\uD83C\uDDE7\uD83C\uDDF7", "\uD83C\uDDE7\uD83C\uDDF8", "\uD83C\uDDE7\uD83C\uDDF9", "\uD83C\uDDE7\uD83C\uDDFB", "\uD83C\uDDE7\uD83C\uDDFC", "\uD83C\uDDE7\uD83C\uDDFE", "\uD83C\uDDE7\uD83C\uDDFF", "\uD83C\uDDE8\uD83C\uDDE6", "\uD83C\uDDE8\uD83C\uDDE8", "\uD83C\uDDE8\uD83C\uDDE9", "\uD83C\uDDE8\uD83C\uDDEB", "\uD83C\uDDE8\uD83C\uDDEC", "\uD83C\uDDE8\uD83C\uDDED", "\uD83C\uDDE8\uD83C\uDDEE", "\uD83C\uDDE8\uD83C\uDDF0", "\uD83C\uDDE8\uD83C\uDDF1", "\uD83C\uDDE8\uD83C\uDDF2", "\uD83C\uDDE8\uD83C\uDDF3", "\uD83C\uDDE8\uD83C\uDDF4", "\uD83C\uDDE8\uD83C\uDDF5", "\uD83C\uDDE8\uD83C\uDDF6", "\uD83C\uDDE8\uD83C\uDDF7", "\uD83C\uDDE8\uD83C\uDDFA", "\uD83C\uDDE8\uD83C\uDDFB", "\uD83C\uDDE8\uD83C\uDDFC", "\uD83C\uDDE8\uD83C\uDDFD", "\uD83C\uDDE8\uD83C\uDDFE", "\uD83C\uDDE8\uD83C\uDDFF", "\uD83C\uDDE9\uD83C\uDDEA", "\uD83C\uDDE9\uD83C\uDDEC", "\uD83C\uDDE9\uD83C\uDDEF", "\uD83C\uDDE9\uD83C\uDDF0", "\uD83C\uDDE9\uD83C\uDDF2", "\uD83C\uDDE9\uD83C\uDDF4", "\uD83C\uDDE9\uD83C\uDDFF", "\uD83C\uDDEA\uD83C\uDDE6", "\uD83C\uDDEA\uD83C\uDDE8", "\uD83C\uDDEA\uD83C\uDDEA", "\uD83C\uDDEA\uD83C\uDDEC", "\uD83C\uDDEA\uD83C\uDDED", "\uD83C\uDDEA\uD83C\uDDF7", "\uD83C\uDDEA\uD83C\uDDF8", "\uD83C\uDDEA\uD83C\uDDF9", "\uD83C\uDDEA\uD83C\uDDFA", "\uD83C\uDDEB\uD83C\uDDEE", "\uD83C\uDDEB\uD83C\uDDEF", "\uD83C\uDDEB\uD83C\uDDF0", "\uD83C\uDDEB\uD83C\uDDF2", "\uD83C\uDDEB\uD83C\uDDF4", "\uD83C\uDDEB\uD83C\uDDF7", "\uD83C\uDDEC\uD83C\uDDE6", "\uD83C\uDDEC\uD83C\uDDE7", "\uD83C\uDDEC\uD83C\uDDE9", "\uD83C\uDDEC\uD83C\uDDEA", "\uD83C\uDDEC\uD83C\uDDEB", "\uD83C\uDDEC\uD83C\uDDEC", "\uD83C\uDDEC\uD83C\uDDED", "\uD83C\uDDEC\uD83C\uDDEE", "\uD83C\uDDEC\uD83C\uDDF1", "\uD83C\uDDEC\uD83C\uDDF2", "\uD83C\uDDEC\uD83C\uDDF3", "\uD83C\uDDEC\uD83C\uDDF5", "\uD83C\uDDEC\uD83C\uDDF6", "\uD83C\uDDEC\uD83C\uDDF7", "\uD83C\uDDEC\uD83C\uDDF8", "\uD83C\uDDEC\uD83C\uDDF9", "\uD83C\uDDEC\uD83C\uDDFA", "\uD83C\uDDEC\uD83C\uDDFC", "\uD83C\uDDEC\uD83C\uDDFE", "\uD83C\uDDED\uD83C\uDDF0", "\uD83C\uDDED\uD83C\uDDF2", "\uD83C\uDDED\uD83C\uDDF3", "\uD83C\uDDED\uD83C\uDDF7", "\uD83C\uDDED\uD83C\uDDF9", "\uD83C\uDDED\uD83C\uDDFA", "\uD83C\uDDEE\uD83C\uDDE8", "\uD83C\uDDEE\uD83C\uDDE9", "\uD83C\uDDEE\uD83C\uDDEA", "\uD83C\uDDEE\uD83C\uDDF1", "\uD83C\uDDEE\uD83C\uDDF2", "\uD83C\uDDEE\uD83C\uDDF3", "\uD83C\uDDEE\uD83C\uDDF4", "\uD83C\uDDEE\uD83C\uDDF6", "\uD83C\uDDEE\uD83C\uDDF7", "\uD83C\uDDEE\uD83C\uDDF8", "\uD83C\uDDEE\uD83C\uDDF9", "\uD83C\uDDEF\uD83C\uDDEA", "\uD83C\uDDEF\uD83C\uDDF2", "\uD83C\uDDEF\uD83C\uDDF4", "\uD83C\uDDEF\uD83C\uDDF5", "\uD83C\uDDF0\uD83C\uDDEA", "\uD83C\uDDF0\uD83C\uDDEC", "\uD83C\uDDF0\uD83C\uDDED", "\uD83C\uDDF0\uD83C\uDDEE", "\uD83C\uDDF0\uD83C\uDDF2", "\uD83C\uDDF0\uD83C\uDDF3", "\uD83C\uDDF0\uD83C\uDDF5", "\uD83C\uDDF0\uD83C\uDDF7", "\uD83C\uDDF0\uD83C\uDDFC", "\uD83C\uDDF0\uD83C\uDDFE", "\uD83C\uDDF0\uD83C\uDDFF", "\uD83C\uDDF1\uD83C\uDDE6", "\uD83C\uDDF1\uD83C\uDDE7", "\uD83C\uDDF1\uD83C\uDDE8", "\uD83C\uDDF1\uD83C\uDDEE", "\uD83C\uDDF1\uD83C\uDDF0", "\uD83C\uDDF1\uD83C\uDDF7", "\uD83C\uDDF1\uD83C\uDDF8", "\uD83C\uDDF1\uD83C\uDDF9", "\uD83C\uDDF1\uD83C\uDDFA", "\uD83C\uDDF1\uD83C\uDDFB", "\uD83C\uDDF1\uD83C\uDDFE", "\uD83C\uDDF2\uD83C\uDDE6", "\uD83C\uDDF2\uD83C\uDDE8", "\uD83C\uDDF2\uD83C\uDDE9", "\uD83C\uDDF2\uD83C\uDDEA", "\uD83C\uDDF2\uD83C\uDDEB", "\uD83C\uDDF2\uD83C\uDDEC", "\uD83C\uDDF2\uD83C\uDDED", "\uD83C\uDDF2\uD83C\uDDF0", "\uD83C\uDDF2\uD83C\uDDF1", "\uD83C\uDDF2\uD83C\uDDF2", "\uD83C\uDDF2\uD83C\uDDF3", "\uD83C\uDDF2\uD83C\uDDF4", "\uD83C\uDDF2\uD83C\uDDF5", "\uD83C\uDDF2\uD83C\uDDF6", "\uD83C\uDDF2\uD83C\uDDF7", "\uD83C\uDDF2\uD83C\uDDF8", "\uD83C\uDDF2\uD83C\uDDF9", "\uD83C\uDDF2\uD83C\uDDFA", "\uD83C\uDDF2\uD83C\uDDFB", "\uD83C\uDDF2\uD83C\uDDFC", "\uD83C\uDDF2\uD83C\uDDFD", "\uD83C\uDDF2\uD83C\uDDFE", "\uD83C\uDDF2\uD83C\uDDFF", "\uD83C\uDDF3\uD83C\uDDE6", "\uD83C\uDDF3\uD83C\uDDE8", "\uD83C\uDDF3\uD83C\uDDEA", "\uD83C\uDDF3\uD83C\uDDEB", "\uD83C\uDDF3\uD83C\uDDEC", "\uD83C\uDDF3\uD83C\uDDEE", "\uD83C\uDDF3\uD83C\uDDF1", "\uD83C\uDDF3\uD83C\uDDF4", "\uD83C\uDDF3\uD83C\uDDF5", "\uD83C\uDDF3\uD83C\uDDF7", "\uD83C\uDDF3\uD83C\uDDFA", "\uD83C\uDDF3\uD83C\uDDFF", "\uD83C\uDDF4\uD83C\uDDF2", "\uD83C\uDDF5\uD83C\uDDE6", "\uD83C\uDDF5\uD83C\uDDEA", "\uD83C\uDDF5\uD83C\uDDEB", "\uD83C\uDDF5\uD83C\uDDEC", "\uD83C\uDDF5\uD83C\uDDED", "\uD83C\uDDF5\uD83C\uDDF0", "\uD83C\uDDF5\uD83C\uDDF1", "\uD83C\uDDF5\uD83C\uDDF2", "\uD83C\uDDF5\uD83C\uDDF3", "\uD83C\uDDF5\uD83C\uDDF7", "\uD83C\uDDF5\uD83C\uDDF8", "\uD83C\uDDF5\uD83C\uDDF9", "\uD83C\uDDF5\uD83C\uDDFC", "\uD83C\uDDF5\uD83C\uDDFE", "\uD83C\uDDF6\uD83C\uDDE6", "\uD83C\uDDF7\uD83C\uDDEA", "\uD83C\uDDF7\uD83C\uDDF4", "\uD83C\uDDF7\uD83C\uDDF8", "\uD83C\uDDF7\uD83C\uDDFA", "\uD83C\uDDF7\uD83C\uDDFC", "\uD83C\uDDF8\uD83C\uDDE6", "\uD83C\uDDF8\uD83C\uDDE7", "\uD83C\uDDF8\uD83C\uDDE8", "\uD83C\uDDF8\uD83C\uDDE9", "\uD83C\uDDF8\uD83C\uDDEA", "\uD83C\uDDF8\uD83C\uDDEC", "\uD83C\uDDF8\uD83C\uDDED", "\uD83C\uDDF8\uD83C\uDDEE", "\uD83C\uDDF8\uD83C\uDDEF", "\uD83C\uDDF8\uD83C\uDDF0", "\uD83C\uDDF8\uD83C\uDDF1", "\uD83C\uDDF8\uD83C\uDDF2", "\uD83C\uDDF8\uD83C\uDDF3", "\uD83C\uDDF8\uD83C\uDDF4", "\uD83C\uDDF8\uD83C\uDDF7", "\uD83C\uDDF8\uD83C\uDDF8", "\uD83C\uDDF8\uD83C\uDDF9", "\uD83C\uDDF8\uD83C\uDDFB", "\uD83C\uDDF8\uD83C\uDDFD", "\uD83C\uDDF8\uD83C\uDDFE", "\uD83C\uDDF8\uD83C\uDDFF", "\uD83C\uDDF9\uD83C\uDDE6", "\uD83C\uDDF9\uD83C\uDDE8", "\uD83C\uDDF9\uD83C\uDDE9", "\uD83C\uDDF9\uD83C\uDDEB", "\uD83C\uDDF9\uD83C\uDDEC", "\uD83C\uDDF9\uD83C\uDDED", "\uD83C\uDDF9\uD83C\uDDEF", "\uD83C\uDDF9\uD83C\uDDF0", "\uD83C\uDDF9\uD83C\uDDF1", "\uD83C\uDDF9\uD83C\uDDF2", "\uD83C\uDDF9\uD83C\uDDF3", "\uD83C\uDDF9\uD83C\uDDF4", "\uD83C\uDDF9\uD83C\uDDF7", "\uD83C\uDDF9\uD83C\uDDF9", "\uD83C\uDDF9\uD83C\uDDFB", "\uD83C\uDDF9\uD83C\uDDFC", "\uD83C\uDDF9\uD83C\uDDFF", "\uD83C\uDDFA\uD83C\uDDE6", "\uD83C\uDDFA\uD83C\uDDEC", "\uD83C\uDDFA\uD83C\uDDF2", "\uD83C\uDDFA\uD83C\uDDF3", "\uD83C\uDDFA\uD83C\uDDF8", "\uD83C\uDDFA\uD83C\uDDFE", "\uD83C\uDDFA\uD83C\uDDFF", "\uD83C\uDDFB\uD83C\uDDE6", "\uD83C\uDDFB\uD83C\uDDE8", "\uD83C\uDDFB\uD83C\uDDEA", "\uD83C\uDDFB\uD83C\uDDEC", "\uD83C\uDDFB\uD83C\uDDEE", "\uD83C\uDDFB\uD83C\uDDF3", "\uD83C\uDDFB\uD83C\uDDFA", "\uD83C\uDDFC\uD83C\uDDEB", "\uD83C\uDDFC\uD83C\uDDF8", "\uD83C\uDDFD\uD83C\uDDF0", "\uD83C\uDDFE\uD83C\uDDEA", "\uD83C\uDDFE\uD83C\uDDF9", "\uD83C\uDDFF\uD83C\uDDE6", "\uD83C\uDDFF\uD83C\uDDF2", "\uD83C\uDDFF\uD83C\uDDFC"];
    return RGI_Emoji_Flag_Sequence;
  }

var RGI_Emoji_Modifier_Sequence = {};

var hasRequiredRGI_Emoji_Modifier_Sequence;
  function requireRGI_Emoji_Modifier_Sequence() {
    if (hasRequiredRGI_Emoji_Modifier_Sequence) return RGI_Emoji_Modifier_Sequence;
    hasRequiredRGI_Emoji_Modifier_Sequence = 1;
    var set = regenerateExports();
    RGI_Emoji_Modifier_Sequence.characters = set;
    RGI_Emoji_Modifier_Sequence.strings = ["\u261D\uD83C\uDFFB", "\u261D\uD83C\uDFFC", "\u261D\uD83C\uDFFD", "\u261D\uD83C\uDFFE", "\u261D\uD83C\uDFFF", "\u26F9\uD83C\uDFFB", "\u26F9\uD83C\uDFFC", "\u26F9\uD83C\uDFFD", "\u26F9\uD83C\uDFFE", "\u26F9\uD83C\uDFFF", "\u270A\uD83C\uDFFB", "\u270A\uD83C\uDFFC", "\u270A\uD83C\uDFFD", "\u270A\uD83C\uDFFE", "\u270A\uD83C\uDFFF", "\u270B\uD83C\uDFFB", "\u270B\uD83C\uDFFC", "\u270B\uD83C\uDFFD", "\u270B\uD83C\uDFFE", "\u270B\uD83C\uDFFF", "\u270C\uD83C\uDFFB", "\u270C\uD83C\uDFFC", "\u270C\uD83C\uDFFD", "\u270C\uD83C\uDFFE", "\u270C\uD83C\uDFFF", "\u270D\uD83C\uDFFB", "\u270D\uD83C\uDFFC", "\u270D\uD83C\uDFFD", "\u270D\uD83C\uDFFE", "\u270D\uD83C\uDFFF", "\uD83C\uDF85\uD83C\uDFFB", "\uD83C\uDF85\uD83C\uDFFC", "\uD83C\uDF85\uD83C\uDFFD", "\uD83C\uDF85\uD83C\uDFFE", "\uD83C\uDF85\uD83C\uDFFF", "\uD83C\uDFC2\uD83C\uDFFB", "\uD83C\uDFC2\uD83C\uDFFC", "\uD83C\uDFC2\uD83C\uDFFD", "\uD83C\uDFC2\uD83C\uDFFE", "\uD83C\uDFC2\uD83C\uDFFF", "\uD83C\uDFC3\uD83C\uDFFB", "\uD83C\uDFC3\uD83C\uDFFC", "\uD83C\uDFC3\uD83C\uDFFD", "\uD83C\uDFC3\uD83C\uDFFE", "\uD83C\uDFC3\uD83C\uDFFF", "\uD83C\uDFC4\uD83C\uDFFB", "\uD83C\uDFC4\uD83C\uDFFC", "\uD83C\uDFC4\uD83C\uDFFD", "\uD83C\uDFC4\uD83C\uDFFE", "\uD83C\uDFC4\uD83C\uDFFF", "\uD83C\uDFC7\uD83C\uDFFB", "\uD83C\uDFC7\uD83C\uDFFC", "\uD83C\uDFC7\uD83C\uDFFD", "\uD83C\uDFC7\uD83C\uDFFE", "\uD83C\uDFC7\uD83C\uDFFF", "\uD83C\uDFCA\uD83C\uDFFB", "\uD83C\uDFCA\uD83C\uDFFC", "\uD83C\uDFCA\uD83C\uDFFD", "\uD83C\uDFCA\uD83C\uDFFE", "\uD83C\uDFCA\uD83C\uDFFF", "\uD83C\uDFCB\uD83C\uDFFB", "\uD83C\uDFCB\uD83C\uDFFC", "\uD83C\uDFCB\uD83C\uDFFD", "\uD83C\uDFCB\uD83C\uDFFE", "\uD83C\uDFCB\uD83C\uDFFF", "\uD83C\uDFCC\uD83C\uDFFB", "\uD83C\uDFCC\uD83C\uDFFC", "\uD83C\uDFCC\uD83C\uDFFD", "\uD83C\uDFCC\uD83C\uDFFE", "\uD83C\uDFCC\uD83C\uDFFF", "\uD83D\uDC42\uD83C\uDFFB", "\uD83D\uDC42\uD83C\uDFFC", "\uD83D\uDC42\uD83C\uDFFD", "\uD83D\uDC42\uD83C\uDFFE", "\uD83D\uDC42\uD83C\uDFFF", "\uD83D\uDC43\uD83C\uDFFB", "\uD83D\uDC43\uD83C\uDFFC", "\uD83D\uDC43\uD83C\uDFFD", "\uD83D\uDC43\uD83C\uDFFE", "\uD83D\uDC43\uD83C\uDFFF", "\uD83D\uDC46\uD83C\uDFFB", "\uD83D\uDC46\uD83C\uDFFC", "\uD83D\uDC46\uD83C\uDFFD", "\uD83D\uDC46\uD83C\uDFFE", "\uD83D\uDC46\uD83C\uDFFF", "\uD83D\uDC47\uD83C\uDFFB", "\uD83D\uDC47\uD83C\uDFFC", "\uD83D\uDC47\uD83C\uDFFD", "\uD83D\uDC47\uD83C\uDFFE", "\uD83D\uDC47\uD83C\uDFFF", "\uD83D\uDC48\uD83C\uDFFB", "\uD83D\uDC48\uD83C\uDFFC", "\uD83D\uDC48\uD83C\uDFFD", "\uD83D\uDC48\uD83C\uDFFE", "\uD83D\uDC48\uD83C\uDFFF", "\uD83D\uDC49\uD83C\uDFFB", "\uD83D\uDC49\uD83C\uDFFC", "\uD83D\uDC49\uD83C\uDFFD", "\uD83D\uDC49\uD83C\uDFFE", "\uD83D\uDC49\uD83C\uDFFF", "\uD83D\uDC4A\uD83C\uDFFB", "\uD83D\uDC4A\uD83C\uDFFC", "\uD83D\uDC4A\uD83C\uDFFD", "\uD83D\uDC4A\uD83C\uDFFE", "\uD83D\uDC4A\uD83C\uDFFF", "\uD83D\uDC4B\uD83C\uDFFB", "\uD83D\uDC4B\uD83C\uDFFC", "\uD83D\uDC4B\uD83C\uDFFD", "\uD83D\uDC4B\uD83C\uDFFE", "\uD83D\uDC4B\uD83C\uDFFF", "\uD83D\uDC4C\uD83C\uDFFB", "\uD83D\uDC4C\uD83C\uDFFC", "\uD83D\uDC4C\uD83C\uDFFD", "\uD83D\uDC4C\uD83C\uDFFE", "\uD83D\uDC4C\uD83C\uDFFF", "\uD83D\uDC4D\uD83C\uDFFB", "\uD83D\uDC4D\uD83C\uDFFC", "\uD83D\uDC4D\uD83C\uDFFD", "\uD83D\uDC4D\uD83C\uDFFE", "\uD83D\uDC4D\uD83C\uDFFF", "\uD83D\uDC4E\uD83C\uDFFB", "\uD83D\uDC4E\uD83C\uDFFC", "\uD83D\uDC4E\uD83C\uDFFD", "\uD83D\uDC4E\uD83C\uDFFE", "\uD83D\uDC4E\uD83C\uDFFF", "\uD83D\uDC4F\uD83C\uDFFB", "\uD83D\uDC4F\uD83C\uDFFC", "\uD83D\uDC4F\uD83C\uDFFD", "\uD83D\uDC4F\uD83C\uDFFE", "\uD83D\uDC4F\uD83C\uDFFF", "\uD83D\uDC50\uD83C\uDFFB", "\uD83D\uDC50\uD83C\uDFFC", "\uD83D\uDC50\uD83C\uDFFD", "\uD83D\uDC50\uD83C\uDFFE", "\uD83D\uDC50\uD83C\uDFFF", "\uD83D\uDC66\uD83C\uDFFB", "\uD83D\uDC66\uD83C\uDFFC", "\uD83D\uDC66\uD83C\uDFFD", "\uD83D\uDC66\uD83C\uDFFE", "\uD83D\uDC66\uD83C\uDFFF", "\uD83D\uDC67\uD83C\uDFFB", "\uD83D\uDC67\uD83C\uDFFC", "\uD83D\uDC67\uD83C\uDFFD", "\uD83D\uDC67\uD83C\uDFFE", "\uD83D\uDC67\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC6B\uD83C\uDFFB", "\uD83D\uDC6B\uD83C\uDFFC", "\uD83D\uDC6B\uD83C\uDFFD", "\uD83D\uDC6B\uD83C\uDFFE", "\uD83D\uDC6B\uD83C\uDFFF", "\uD83D\uDC6C\uD83C\uDFFB", "\uD83D\uDC6C\uD83C\uDFFC", "\uD83D\uDC6C\uD83C\uDFFD", "\uD83D\uDC6C\uD83C\uDFFE", "\uD83D\uDC6C\uD83C\uDFFF", "\uD83D\uDC6D\uD83C\uDFFB", "\uD83D\uDC6D\uD83C\uDFFC", "\uD83D\uDC6D\uD83C\uDFFD", "\uD83D\uDC6D\uD83C\uDFFE", "\uD83D\uDC6D\uD83C\uDFFF", "\uD83D\uDC6E\uD83C\uDFFB", "\uD83D\uDC6E\uD83C\uDFFC", "\uD83D\uDC6E\uD83C\uDFFD", "\uD83D\uDC6E\uD83C\uDFFE", "\uD83D\uDC6E\uD83C\uDFFF", "\uD83D\uDC70\uD83C\uDFFB", "\uD83D\uDC70\uD83C\uDFFC", "\uD83D\uDC70\uD83C\uDFFD", "\uD83D\uDC70\uD83C\uDFFE", "\uD83D\uDC70\uD83C\uDFFF", "\uD83D\uDC71\uD83C\uDFFB", "\uD83D\uDC71\uD83C\uDFFC", "\uD83D\uDC71\uD83C\uDFFD", "\uD83D\uDC71\uD83C\uDFFE", "\uD83D\uDC71\uD83C\uDFFF", "\uD83D\uDC72\uD83C\uDFFB", "\uD83D\uDC72\uD83C\uDFFC", "\uD83D\uDC72\uD83C\uDFFD", "\uD83D\uDC72\uD83C\uDFFE", "\uD83D\uDC72\uD83C\uDFFF", "\uD83D\uDC73\uD83C\uDFFB", "\uD83D\uDC73\uD83C\uDFFC", "\uD83D\uDC73\uD83C\uDFFD", "\uD83D\uDC73\uD83C\uDFFE", "\uD83D\uDC73\uD83C\uDFFF", "\uD83D\uDC74\uD83C\uDFFB", "\uD83D\uDC74\uD83C\uDFFC", "\uD83D\uDC74\uD83C\uDFFD", "\uD83D\uDC74\uD83C\uDFFE", "\uD83D\uDC74\uD83C\uDFFF", "\uD83D\uDC75\uD83C\uDFFB", "\uD83D\uDC75\uD83C\uDFFC", "\uD83D\uDC75\uD83C\uDFFD", "\uD83D\uDC75\uD83C\uDFFE", "\uD83D\uDC75\uD83C\uDFFF", "\uD83D\uDC76\uD83C\uDFFB", "\uD83D\uDC76\uD83C\uDFFC", "\uD83D\uDC76\uD83C\uDFFD", "\uD83D\uDC76\uD83C\uDFFE", "\uD83D\uDC76\uD83C\uDFFF", "\uD83D\uDC77\uD83C\uDFFB", "\uD83D\uDC77\uD83C\uDFFC", "\uD83D\uDC77\uD83C\uDFFD", "\uD83D\uDC77\uD83C\uDFFE", "\uD83D\uDC77\uD83C\uDFFF", "\uD83D\uDC78\uD83C\uDFFB", "\uD83D\uDC78\uD83C\uDFFC", "\uD83D\uDC78\uD83C\uDFFD", "\uD83D\uDC78\uD83C\uDFFE", "\uD83D\uDC78\uD83C\uDFFF", "\uD83D\uDC7C\uD83C\uDFFB", "\uD83D\uDC7C\uD83C\uDFFC", "\uD83D\uDC7C\uD83C\uDFFD", "\uD83D\uDC7C\uD83C\uDFFE", "\uD83D\uDC7C\uD83C\uDFFF", "\uD83D\uDC81\uD83C\uDFFB", "\uD83D\uDC81\uD83C\uDFFC", "\uD83D\uDC81\uD83C\uDFFD", "\uD83D\uDC81\uD83C\uDFFE", "\uD83D\uDC81\uD83C\uDFFF", "\uD83D\uDC82\uD83C\uDFFB", "\uD83D\uDC82\uD83C\uDFFC", "\uD83D\uDC82\uD83C\uDFFD", "\uD83D\uDC82\uD83C\uDFFE", "\uD83D\uDC82\uD83C\uDFFF", "\uD83D\uDC83\uD83C\uDFFB", "\uD83D\uDC83\uD83C\uDFFC", "\uD83D\uDC83\uD83C\uDFFD", "\uD83D\uDC83\uD83C\uDFFE", "\uD83D\uDC83\uD83C\uDFFF", "\uD83D\uDC85\uD83C\uDFFB", "\uD83D\uDC85\uD83C\uDFFC", "\uD83D\uDC85\uD83C\uDFFD", "\uD83D\uDC85\uD83C\uDFFE", "\uD83D\uDC85\uD83C\uDFFF", "\uD83D\uDC86\uD83C\uDFFB", "\uD83D\uDC86\uD83C\uDFFC", "\uD83D\uDC86\uD83C\uDFFD", "\uD83D\uDC86\uD83C\uDFFE", "\uD83D\uDC86\uD83C\uDFFF", "\uD83D\uDC87\uD83C\uDFFB", "\uD83D\uDC87\uD83C\uDFFC", "\uD83D\uDC87\uD83C\uDFFD", "\uD83D\uDC87\uD83C\uDFFE", "\uD83D\uDC87\uD83C\uDFFF", "\uD83D\uDC8F\uD83C\uDFFB", "\uD83D\uDC8F\uD83C\uDFFC", "\uD83D\uDC8F\uD83C\uDFFD", "\uD83D\uDC8F\uD83C\uDFFE", "\uD83D\uDC8F\uD83C\uDFFF", "\uD83D\uDC91\uD83C\uDFFB", "\uD83D\uDC91\uD83C\uDFFC", "\uD83D\uDC91\uD83C\uDFFD", "\uD83D\uDC91\uD83C\uDFFE", "\uD83D\uDC91\uD83C\uDFFF", "\uD83D\uDCAA\uD83C\uDFFB", "\uD83D\uDCAA\uD83C\uDFFC", "\uD83D\uDCAA\uD83C\uDFFD", "\uD83D\uDCAA\uD83C\uDFFE", "\uD83D\uDCAA\uD83C\uDFFF", "\uD83D\uDD74\uD83C\uDFFB", "\uD83D\uDD74\uD83C\uDFFC", "\uD83D\uDD74\uD83C\uDFFD", "\uD83D\uDD74\uD83C\uDFFE", "\uD83D\uDD74\uD83C\uDFFF", "\uD83D\uDD75\uD83C\uDFFB", "\uD83D\uDD75\uD83C\uDFFC", "\uD83D\uDD75\uD83C\uDFFD", "\uD83D\uDD75\uD83C\uDFFE", "\uD83D\uDD75\uD83C\uDFFF", "\uD83D\uDD7A\uD83C\uDFFB", "\uD83D\uDD7A\uD83C\uDFFC", "\uD83D\uDD7A\uD83C\uDFFD", "\uD83D\uDD7A\uD83C\uDFFE", "\uD83D\uDD7A\uD83C\uDFFF", "\uD83D\uDD90\uD83C\uDFFB", "\uD83D\uDD90\uD83C\uDFFC", "\uD83D\uDD90\uD83C\uDFFD", "\uD83D\uDD90\uD83C\uDFFE", "\uD83D\uDD90\uD83C\uDFFF", "\uD83D\uDD95\uD83C\uDFFB", "\uD83D\uDD95\uD83C\uDFFC", "\uD83D\uDD95\uD83C\uDFFD", "\uD83D\uDD95\uD83C\uDFFE", "\uD83D\uDD95\uD83C\uDFFF", "\uD83D\uDD96\uD83C\uDFFB", "\uD83D\uDD96\uD83C\uDFFC", "\uD83D\uDD96\uD83C\uDFFD", "\uD83D\uDD96\uD83C\uDFFE", "\uD83D\uDD96\uD83C\uDFFF", "\uD83D\uDE45\uD83C\uDFFB", "\uD83D\uDE45\uD83C\uDFFC", "\uD83D\uDE45\uD83C\uDFFD", "\uD83D\uDE45\uD83C\uDFFE", "\uD83D\uDE45\uD83C\uDFFF", "\uD83D\uDE46\uD83C\uDFFB", "\uD83D\uDE46\uD83C\uDFFC", "\uD83D\uDE46\uD83C\uDFFD", "\uD83D\uDE46\uD83C\uDFFE", "\uD83D\uDE46\uD83C\uDFFF", "\uD83D\uDE47\uD83C\uDFFB", "\uD83D\uDE47\uD83C\uDFFC", "\uD83D\uDE47\uD83C\uDFFD", "\uD83D\uDE47\uD83C\uDFFE", "\uD83D\uDE47\uD83C\uDFFF", "\uD83D\uDE4B\uD83C\uDFFB", "\uD83D\uDE4B\uD83C\uDFFC", "\uD83D\uDE4B\uD83C\uDFFD", "\uD83D\uDE4B\uD83C\uDFFE", "\uD83D\uDE4B\uD83C\uDFFF", "\uD83D\uDE4C\uD83C\uDFFB", "\uD83D\uDE4C\uD83C\uDFFC", "\uD83D\uDE4C\uD83C\uDFFD", "\uD83D\uDE4C\uD83C\uDFFE", "\uD83D\uDE4C\uD83C\uDFFF", "\uD83D\uDE4D\uD83C\uDFFB", "\uD83D\uDE4D\uD83C\uDFFC", "\uD83D\uDE4D\uD83C\uDFFD", "\uD83D\uDE4D\uD83C\uDFFE", "\uD83D\uDE4D\uD83C\uDFFF", "\uD83D\uDE4E\uD83C\uDFFB", "\uD83D\uDE4E\uD83C\uDFFC", "\uD83D\uDE4E\uD83C\uDFFD", "\uD83D\uDE4E\uD83C\uDFFE", "\uD83D\uDE4E\uD83C\uDFFF", "\uD83D\uDE4F\uD83C\uDFFB", "\uD83D\uDE4F\uD83C\uDFFC", "\uD83D\uDE4F\uD83C\uDFFD", "\uD83D\uDE4F\uD83C\uDFFE", "\uD83D\uDE4F\uD83C\uDFFF", "\uD83D\uDEA3\uD83C\uDFFB", "\uD83D\uDEA3\uD83C\uDFFC", "\uD83D\uDEA3\uD83C\uDFFD", "\uD83D\uDEA3\uD83C\uDFFE", "\uD83D\uDEA3\uD83C\uDFFF", "\uD83D\uDEB4\uD83C\uDFFB", "\uD83D\uDEB4\uD83C\uDFFC", "\uD83D\uDEB4\uD83C\uDFFD", "\uD83D\uDEB4\uD83C\uDFFE", "\uD83D\uDEB4\uD83C\uDFFF", "\uD83D\uDEB5\uD83C\uDFFB", "\uD83D\uDEB5\uD83C\uDFFC", "\uD83D\uDEB5\uD83C\uDFFD", "\uD83D\uDEB5\uD83C\uDFFE", "\uD83D\uDEB5\uD83C\uDFFF", "\uD83D\uDEB6\uD83C\uDFFB", "\uD83D\uDEB6\uD83C\uDFFC", "\uD83D\uDEB6\uD83C\uDFFD", "\uD83D\uDEB6\uD83C\uDFFE", "\uD83D\uDEB6\uD83C\uDFFF", "\uD83D\uDEC0\uD83C\uDFFB", "\uD83D\uDEC0\uD83C\uDFFC", "\uD83D\uDEC0\uD83C\uDFFD", "\uD83D\uDEC0\uD83C\uDFFE", "\uD83D\uDEC0\uD83C\uDFFF", "\uD83D\uDECC\uD83C\uDFFB", "\uD83D\uDECC\uD83C\uDFFC", "\uD83D\uDECC\uD83C\uDFFD", "\uD83D\uDECC\uD83C\uDFFE", "\uD83D\uDECC\uD83C\uDFFF", "\uD83E\uDD0C\uD83C\uDFFB", "\uD83E\uDD0C\uD83C\uDFFC", "\uD83E\uDD0C\uD83C\uDFFD", "\uD83E\uDD0C\uD83C\uDFFE", "\uD83E\uDD0C\uD83C\uDFFF", "\uD83E\uDD0F\uD83C\uDFFB", "\uD83E\uDD0F\uD83C\uDFFC", "\uD83E\uDD0F\uD83C\uDFFD", "\uD83E\uDD0F\uD83C\uDFFE", "\uD83E\uDD0F\uD83C\uDFFF", "\uD83E\uDD18\uD83C\uDFFB", "\uD83E\uDD18\uD83C\uDFFC", "\uD83E\uDD18\uD83C\uDFFD", "\uD83E\uDD18\uD83C\uDFFE", "\uD83E\uDD18\uD83C\uDFFF", "\uD83E\uDD19\uD83C\uDFFB", "\uD83E\uDD19\uD83C\uDFFC", "\uD83E\uDD19\uD83C\uDFFD", "\uD83E\uDD19\uD83C\uDFFE", "\uD83E\uDD19\uD83C\uDFFF", "\uD83E\uDD1A\uD83C\uDFFB", "\uD83E\uDD1A\uD83C\uDFFC", "\uD83E\uDD1A\uD83C\uDFFD", "\uD83E\uDD1A\uD83C\uDFFE", "\uD83E\uDD1A\uD83C\uDFFF", "\uD83E\uDD1B\uD83C\uDFFB", "\uD83E\uDD1B\uD83C\uDFFC", "\uD83E\uDD1B\uD83C\uDFFD", "\uD83E\uDD1B\uD83C\uDFFE", "\uD83E\uDD1B\uD83C\uDFFF", "\uD83E\uDD1C\uD83C\uDFFB", "\uD83E\uDD1C\uD83C\uDFFC", "\uD83E\uDD1C\uD83C\uDFFD", "\uD83E\uDD1C\uD83C\uDFFE", "\uD83E\uDD1C\uD83C\uDFFF", "\uD83E\uDD1D\uD83C\uDFFB", "\uD83E\uDD1D\uD83C\uDFFC", "\uD83E\uDD1D\uD83C\uDFFD", "\uD83E\uDD1D\uD83C\uDFFE", "\uD83E\uDD1D\uD83C\uDFFF", "\uD83E\uDD1E\uD83C\uDFFB", "\uD83E\uDD1E\uD83C\uDFFC", "\uD83E\uDD1E\uD83C\uDFFD", "\uD83E\uDD1E\uD83C\uDFFE", "\uD83E\uDD1E\uD83C\uDFFF", "\uD83E\uDD1F\uD83C\uDFFB", "\uD83E\uDD1F\uD83C\uDFFC", "\uD83E\uDD1F\uD83C\uDFFD", "\uD83E\uDD1F\uD83C\uDFFE", "\uD83E\uDD1F\uD83C\uDFFF", "\uD83E\uDD26\uD83C\uDFFB", "\uD83E\uDD26\uD83C\uDFFC", "\uD83E\uDD26\uD83C\uDFFD", "\uD83E\uDD26\uD83C\uDFFE", "\uD83E\uDD26\uD83C\uDFFF", "\uD83E\uDD30\uD83C\uDFFB", "\uD83E\uDD30\uD83C\uDFFC", "\uD83E\uDD30\uD83C\uDFFD", "\uD83E\uDD30\uD83C\uDFFE", "\uD83E\uDD30\uD83C\uDFFF", "\uD83E\uDD31\uD83C\uDFFB", "\uD83E\uDD31\uD83C\uDFFC", "\uD83E\uDD31\uD83C\uDFFD", "\uD83E\uDD31\uD83C\uDFFE", "\uD83E\uDD31\uD83C\uDFFF", "\uD83E\uDD32\uD83C\uDFFB", "\uD83E\uDD32\uD83C\uDFFC", "\uD83E\uDD32\uD83C\uDFFD", "\uD83E\uDD32\uD83C\uDFFE", "\uD83E\uDD32\uD83C\uDFFF", "\uD83E\uDD33\uD83C\uDFFB", "\uD83E\uDD33\uD83C\uDFFC", "\uD83E\uDD33\uD83C\uDFFD", "\uD83E\uDD33\uD83C\uDFFE", "\uD83E\uDD33\uD83C\uDFFF", "\uD83E\uDD34\uD83C\uDFFB", "\uD83E\uDD34\uD83C\uDFFC", "\uD83E\uDD34\uD83C\uDFFD", "\uD83E\uDD34\uD83C\uDFFE", "\uD83E\uDD34\uD83C\uDFFF", "\uD83E\uDD35\uD83C\uDFFB", "\uD83E\uDD35\uD83C\uDFFC", "\uD83E\uDD35\uD83C\uDFFD", "\uD83E\uDD35\uD83C\uDFFE", "\uD83E\uDD35\uD83C\uDFFF", "\uD83E\uDD36\uD83C\uDFFB", "\uD83E\uDD36\uD83C\uDFFC", "\uD83E\uDD36\uD83C\uDFFD", "\uD83E\uDD36\uD83C\uDFFE", "\uD83E\uDD36\uD83C\uDFFF", "\uD83E\uDD37\uD83C\uDFFB", "\uD83E\uDD37\uD83C\uDFFC", "\uD83E\uDD37\uD83C\uDFFD", "\uD83E\uDD37\uD83C\uDFFE", "\uD83E\uDD37\uD83C\uDFFF", "\uD83E\uDD38\uD83C\uDFFB", "\uD83E\uDD38\uD83C\uDFFC", "\uD83E\uDD38\uD83C\uDFFD", "\uD83E\uDD38\uD83C\uDFFE", "\uD83E\uDD38\uD83C\uDFFF", "\uD83E\uDD39\uD83C\uDFFB", "\uD83E\uDD39\uD83C\uDFFC", "\uD83E\uDD39\uD83C\uDFFD", "\uD83E\uDD39\uD83C\uDFFE", "\uD83E\uDD39\uD83C\uDFFF", "\uD83E\uDD3D\uD83C\uDFFB", "\uD83E\uDD3D\uD83C\uDFFC", "\uD83E\uDD3D\uD83C\uDFFD", "\uD83E\uDD3D\uD83C\uDFFE", "\uD83E\uDD3D\uD83C\uDFFF", "\uD83E\uDD3E\uD83C\uDFFB", "\uD83E\uDD3E\uD83C\uDFFC", "\uD83E\uDD3E\uD83C\uDFFD", "\uD83E\uDD3E\uD83C\uDFFE", "\uD83E\uDD3E\uD83C\uDFFF", "\uD83E\uDD77\uD83C\uDFFB", "\uD83E\uDD77\uD83C\uDFFC", "\uD83E\uDD77\uD83C\uDFFD", "\uD83E\uDD77\uD83C\uDFFE", "\uD83E\uDD77\uD83C\uDFFF", "\uD83E\uDDB5\uD83C\uDFFB", "\uD83E\uDDB5\uD83C\uDFFC", "\uD83E\uDDB5\uD83C\uDFFD", "\uD83E\uDDB5\uD83C\uDFFE", "\uD83E\uDDB5\uD83C\uDFFF", "\uD83E\uDDB6\uD83C\uDFFB", "\uD83E\uDDB6\uD83C\uDFFC", "\uD83E\uDDB6\uD83C\uDFFD", "\uD83E\uDDB6\uD83C\uDFFE", "\uD83E\uDDB6\uD83C\uDFFF", "\uD83E\uDDB8\uD83C\uDFFB", "\uD83E\uDDB8\uD83C\uDFFC", "\uD83E\uDDB8\uD83C\uDFFD", "\uD83E\uDDB8\uD83C\uDFFE", "\uD83E\uDDB8\uD83C\uDFFF", "\uD83E\uDDB9\uD83C\uDFFB", "\uD83E\uDDB9\uD83C\uDFFC", "\uD83E\uDDB9\uD83C\uDFFD", "\uD83E\uDDB9\uD83C\uDFFE", "\uD83E\uDDB9\uD83C\uDFFF", "\uD83E\uDDBB\uD83C\uDFFB", "\uD83E\uDDBB\uD83C\uDFFC", "\uD83E\uDDBB\uD83C\uDFFD", "\uD83E\uDDBB\uD83C\uDFFE", "\uD83E\uDDBB\uD83C\uDFFF", "\uD83E\uDDCD\uD83C\uDFFB", "\uD83E\uDDCD\uD83C\uDFFC", "\uD83E\uDDCD\uD83C\uDFFD", "\uD83E\uDDCD\uD83C\uDFFE", "\uD83E\uDDCD\uD83C\uDFFF", "\uD83E\uDDCE\uD83C\uDFFB", "\uD83E\uDDCE\uD83C\uDFFC", "\uD83E\uDDCE\uD83C\uDFFD", "\uD83E\uDDCE\uD83C\uDFFE", "\uD83E\uDDCE\uD83C\uDFFF", "\uD83E\uDDCF\uD83C\uDFFB", "\uD83E\uDDCF\uD83C\uDFFC", "\uD83E\uDDCF\uD83C\uDFFD", "\uD83E\uDDCF\uD83C\uDFFE", "\uD83E\uDDCF\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD2\uD83C\uDFFB", "\uD83E\uDDD2\uD83C\uDFFC", "\uD83E\uDDD2\uD83C\uDFFD", "\uD83E\uDDD2\uD83C\uDFFE", "\uD83E\uDDD2\uD83C\uDFFF", "\uD83E\uDDD3\uD83C\uDFFB", "\uD83E\uDDD3\uD83C\uDFFC", "\uD83E\uDDD3\uD83C\uDFFD", "\uD83E\uDDD3\uD83C\uDFFE", "\uD83E\uDDD3\uD83C\uDFFF", "\uD83E\uDDD4\uD83C\uDFFB", "\uD83E\uDDD4\uD83C\uDFFC", "\uD83E\uDDD4\uD83C\uDFFD", "\uD83E\uDDD4\uD83C\uDFFE", "\uD83E\uDDD4\uD83C\uDFFF", "\uD83E\uDDD5\uD83C\uDFFB", "\uD83E\uDDD5\uD83C\uDFFC", "\uD83E\uDDD5\uD83C\uDFFD", "\uD83E\uDDD5\uD83C\uDFFE", "\uD83E\uDDD5\uD83C\uDFFF", "\uD83E\uDDD6\uD83C\uDFFB", "\uD83E\uDDD6\uD83C\uDFFC", "\uD83E\uDDD6\uD83C\uDFFD", "\uD83E\uDDD6\uD83C\uDFFE", "\uD83E\uDDD6\uD83C\uDFFF", "\uD83E\uDDD7\uD83C\uDFFB", "\uD83E\uDDD7\uD83C\uDFFC", "\uD83E\uDDD7\uD83C\uDFFD", "\uD83E\uDDD7\uD83C\uDFFE", "\uD83E\uDDD7\uD83C\uDFFF", "\uD83E\uDDD8\uD83C\uDFFB", "\uD83E\uDDD8\uD83C\uDFFC", "\uD83E\uDDD8\uD83C\uDFFD", "\uD83E\uDDD8\uD83C\uDFFE", "\uD83E\uDDD8\uD83C\uDFFF", "\uD83E\uDDD9\uD83C\uDFFB", "\uD83E\uDDD9\uD83C\uDFFC", "\uD83E\uDDD9\uD83C\uDFFD", "\uD83E\uDDD9\uD83C\uDFFE", "\uD83E\uDDD9\uD83C\uDFFF", "\uD83E\uDDDA\uD83C\uDFFB", "\uD83E\uDDDA\uD83C\uDFFC", "\uD83E\uDDDA\uD83C\uDFFD", "\uD83E\uDDDA\uD83C\uDFFE", "\uD83E\uDDDA\uD83C\uDFFF", "\uD83E\uDDDB\uD83C\uDFFB", "\uD83E\uDDDB\uD83C\uDFFC", "\uD83E\uDDDB\uD83C\uDFFD", "\uD83E\uDDDB\uD83C\uDFFE", "\uD83E\uDDDB\uD83C\uDFFF", "\uD83E\uDDDC\uD83C\uDFFB", "\uD83E\uDDDC\uD83C\uDFFC", "\uD83E\uDDDC\uD83C\uDFFD", "\uD83E\uDDDC\uD83C\uDFFE", "\uD83E\uDDDC\uD83C\uDFFF", "\uD83E\uDDDD\uD83C\uDFFB", "\uD83E\uDDDD\uD83C\uDFFC", "\uD83E\uDDDD\uD83C\uDFFD", "\uD83E\uDDDD\uD83C\uDFFE", "\uD83E\uDDDD\uD83C\uDFFF", "\uD83E\uDEC3\uD83C\uDFFB", "\uD83E\uDEC3\uD83C\uDFFC", "\uD83E\uDEC3\uD83C\uDFFD", "\uD83E\uDEC3\uD83C\uDFFE", "\uD83E\uDEC3\uD83C\uDFFF", "\uD83E\uDEC4\uD83C\uDFFB", "\uD83E\uDEC4\uD83C\uDFFC", "\uD83E\uDEC4\uD83C\uDFFD", "\uD83E\uDEC4\uD83C\uDFFE", "\uD83E\uDEC4\uD83C\uDFFF", "\uD83E\uDEC5\uD83C\uDFFB", "\uD83E\uDEC5\uD83C\uDFFC", "\uD83E\uDEC5\uD83C\uDFFD", "\uD83E\uDEC5\uD83C\uDFFE", "\uD83E\uDEC5\uD83C\uDFFF", "\uD83E\uDEF0\uD83C\uDFFB", "\uD83E\uDEF0\uD83C\uDFFC", "\uD83E\uDEF0\uD83C\uDFFD", "\uD83E\uDEF0\uD83C\uDFFE", "\uD83E\uDEF0\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFB", "\uD83E\uDEF1\uD83C\uDFFC", "\uD83E\uDEF1\uD83C\uDFFD", "\uD83E\uDEF1\uD83C\uDFFE", "\uD83E\uDEF1\uD83C\uDFFF", "\uD83E\uDEF2\uD83C\uDFFB", "\uD83E\uDEF2\uD83C\uDFFC", "\uD83E\uDEF2\uD83C\uDFFD", "\uD83E\uDEF2\uD83C\uDFFE", "\uD83E\uDEF2\uD83C\uDFFF", "\uD83E\uDEF3\uD83C\uDFFB", "\uD83E\uDEF3\uD83C\uDFFC", "\uD83E\uDEF3\uD83C\uDFFD", "\uD83E\uDEF3\uD83C\uDFFE", "\uD83E\uDEF3\uD83C\uDFFF", "\uD83E\uDEF4\uD83C\uDFFB", "\uD83E\uDEF4\uD83C\uDFFC", "\uD83E\uDEF4\uD83C\uDFFD", "\uD83E\uDEF4\uD83C\uDFFE", "\uD83E\uDEF4\uD83C\uDFFF", "\uD83E\uDEF5\uD83C\uDFFB", "\uD83E\uDEF5\uD83C\uDFFC", "\uD83E\uDEF5\uD83C\uDFFD", "\uD83E\uDEF5\uD83C\uDFFE", "\uD83E\uDEF5\uD83C\uDFFF", "\uD83E\uDEF6\uD83C\uDFFB", "\uD83E\uDEF6\uD83C\uDFFC", "\uD83E\uDEF6\uD83C\uDFFD", "\uD83E\uDEF6\uD83C\uDFFE", "\uD83E\uDEF6\uD83C\uDFFF", "\uD83E\uDEF7\uD83C\uDFFB", "\uD83E\uDEF7\uD83C\uDFFC", "\uD83E\uDEF7\uD83C\uDFFD", "\uD83E\uDEF7\uD83C\uDFFE", "\uD83E\uDEF7\uD83C\uDFFF", "\uD83E\uDEF8\uD83C\uDFFB", "\uD83E\uDEF8\uD83C\uDFFC", "\uD83E\uDEF8\uD83C\uDFFD", "\uD83E\uDEF8\uD83C\uDFFE", "\uD83E\uDEF8\uD83C\uDFFF"];
    return RGI_Emoji_Modifier_Sequence;
  }

var RGI_Emoji_Tag_Sequence = {};

var hasRequiredRGI_Emoji_Tag_Sequence;
  function requireRGI_Emoji_Tag_Sequence() {
    if (hasRequiredRGI_Emoji_Tag_Sequence) return RGI_Emoji_Tag_Sequence;
    hasRequiredRGI_Emoji_Tag_Sequence = 1;
    var set = regenerateExports();
    RGI_Emoji_Tag_Sequence.characters = set;
    RGI_Emoji_Tag_Sequence.strings = ["\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67\uDB40\uDC7F", "\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74\uDB40\uDC7F", "\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73\uDB40\uDC7F"];
    return RGI_Emoji_Tag_Sequence;
  }

var RGI_Emoji_ZWJ_Sequence = {};

var hasRequiredRGI_Emoji_ZWJ_Sequence;
  function requireRGI_Emoji_ZWJ_Sequence() {
    if (hasRequiredRGI_Emoji_ZWJ_Sequence) return RGI_Emoji_ZWJ_Sequence;
    hasRequiredRGI_Emoji_ZWJ_Sequence = 1;
    var set = regenerateExports();
    RGI_Emoji_ZWJ_Sequence.characters = set;
    RGI_Emoji_ZWJ_Sequence.strings = ["\uD83D\uDC68\u200D\u2764\uFE0F\u200D\uD83D\uDC68", "\uD83D\uDC68\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68", "\uD83D\uDC68\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC66\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC67", "\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC67", "\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC66\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC67", "\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC67", "\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67", "\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC67", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC68", "\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC69", "\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68", "\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69", "\uD83D\uDC69\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC67", "\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC67", "\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC67", "\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC67", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83E\uDDD1\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1", "\uD83E\uDDD1\u200D\uD83E\uDDD1\u200D\uD83E\uDDD2", "\uD83E\uDDD1\u200D\uD83E\uDDD1\u200D\uD83E\uDDD2\u200D\uD83E\uDDD2", "\uD83E\uDDD1\u200D\uD83E\uDDD2", "\uD83E\uDDD1\u200D\uD83E\uDDD2\u200D\uD83E\uDDD2", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFB\u200D\uD83E\uDEF2\uD83C\uDFFC", "\uD83E\uDEF1\uD83C\uDFFB\u200D\uD83E\uDEF2\uD83C\uDFFD", "\uD83E\uDEF1\uD83C\uDFFB\u200D\uD83E\uDEF2\uD83C\uDFFE", "\uD83E\uDEF1\uD83C\uDFFB\u200D\uD83E\uDEF2\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFC\u200D\uD83E\uDEF2\uD83C\uDFFB", "\uD83E\uDEF1\uD83C\uDFFC\u200D\uD83E\uDEF2\uD83C\uDFFD", "\uD83E\uDEF1\uD83C\uDFFC\u200D\uD83E\uDEF2\uD83C\uDFFE", "\uD83E\uDEF1\uD83C\uDFFC\u200D\uD83E\uDEF2\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFD\u200D\uD83E\uDEF2\uD83C\uDFFB", "\uD83E\uDEF1\uD83C\uDFFD\u200D\uD83E\uDEF2\uD83C\uDFFC", "\uD83E\uDEF1\uD83C\uDFFD\u200D\uD83E\uDEF2\uD83C\uDFFE", "\uD83E\uDEF1\uD83C\uDFFD\u200D\uD83E\uDEF2\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFE\u200D\uD83E\uDEF2\uD83C\uDFFB", "\uD83E\uDEF1\uD83C\uDFFE\u200D\uD83E\uDEF2\uD83C\uDFFC", "\uD83E\uDEF1\uD83C\uDFFE\u200D\uD83E\uDEF2\uD83C\uDFFD", "\uD83E\uDEF1\uD83C\uDFFE\u200D\uD83E\uDEF2\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFF\u200D\uD83E\uDEF2\uD83C\uDFFB", "\uD83E\uDEF1\uD83C\uDFFF\u200D\uD83E\uDEF2\uD83C\uDFFC", "\uD83E\uDEF1\uD83C\uDFFF\u200D\uD83E\uDEF2\uD83C\uDFFD", "\uD83E\uDEF1\uD83C\uDFFF\u200D\uD83E\uDEF2\uD83C\uDFFE", "\uD83C\uDFC3\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFB\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFC\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFD\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFE\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFF\u200D\u27A1\uFE0F", "\uD83D\uDC68\u200D\u2695\uFE0F", "\uD83D\uDC68\u200D\u2696\uFE0F", "\uD83D\uDC68\u200D\u2708\uFE0F", "\uD83D\uDC68\u200D\uD83C\uDF3E", "\uD83D\uDC68\u200D\uD83C\uDF73", "\uD83D\uDC68\u200D\uD83C\uDF7C", "\uD83D\uDC68\u200D\uD83C\uDF93", "\uD83D\uDC68\u200D\uD83C\uDFA4", "\uD83D\uDC68\u200D\uD83C\uDFA8", "\uD83D\uDC68\u200D\uD83C\uDFEB", "\uD83D\uDC68\u200D\uD83C\uDFED", "\uD83D\uDC68\u200D\uD83D\uDCBB", "\uD83D\uDC68\u200D\uD83D\uDCBC", "\uD83D\uDC68\u200D\uD83D\uDD27", "\uD83D\uDC68\u200D\uD83D\uDD2C", "\uD83D\uDC68\u200D\uD83D\uDE80", "\uD83D\uDC68\u200D\uD83D\uDE92", "\uD83D\uDC68\u200D\uD83E\uDDAF", "\uD83D\uDC68\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\u200D\uD83E\uDDBC", "\uD83D\uDC68\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\u200D\uD83E\uDDBD", "\uD83D\uDC68\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2695\uFE0F", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2696\uFE0F", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2708\uFE0F", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDF3E", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDF73", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDF7C", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDF93", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFA4", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFA8", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFEB", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFED", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDCBB", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDCBC", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDD27", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDD2C", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDE80", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDE92", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDAF", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDBC", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDBD", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2695\uFE0F", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2696\uFE0F", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2708\uFE0F", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDF3E", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDF73", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDF7C", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDF93", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFA4", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFA8", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFEB", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFED", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDCBB", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDCBC", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDD27", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDD2C", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDE80", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDE92", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDAF", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDBC", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDBD", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2695\uFE0F", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2696\uFE0F", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2708\uFE0F", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDF3E", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDF73", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDF7C", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDF93", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFA4", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFA8", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFEB", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFED", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDCBB", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDCBC", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDD27", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDD2C", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDE80", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDE92", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDAF", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDBC", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDBD", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2695\uFE0F", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2696\uFE0F", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2708\uFE0F", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDF3E", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDF73", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDF7C", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDF93", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFA4", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFA8", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFEB", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFED", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDCBB", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDCBC", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDD27", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDD2C", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDE80", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDE92", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDAF", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDBC", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDBD", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2695\uFE0F", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2696\uFE0F", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2708\uFE0F", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDF3E", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDF73", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDF7C", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDF93", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFA4", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFA8", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFEB", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFED", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDCBB", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDCBC", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDD27", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDD2C", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDE80", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDE92", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDAF", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDBC", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDBD", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\u200D\u2695\uFE0F", "\uD83D\uDC69\u200D\u2696\uFE0F", "\uD83D\uDC69\u200D\u2708\uFE0F", "\uD83D\uDC69\u200D\uD83C\uDF3E", "\uD83D\uDC69\u200D\uD83C\uDF73", "\uD83D\uDC69\u200D\uD83C\uDF7C", "\uD83D\uDC69\u200D\uD83C\uDF93", "\uD83D\uDC69\u200D\uD83C\uDFA4", "\uD83D\uDC69\u200D\uD83C\uDFA8", "\uD83D\uDC69\u200D\uD83C\uDFEB", "\uD83D\uDC69\u200D\uD83C\uDFED", "\uD83D\uDC69\u200D\uD83D\uDCBB", "\uD83D\uDC69\u200D\uD83D\uDCBC", "\uD83D\uDC69\u200D\uD83D\uDD27", "\uD83D\uDC69\u200D\uD83D\uDD2C", "\uD83D\uDC69\u200D\uD83D\uDE80", "\uD83D\uDC69\u200D\uD83D\uDE92", "\uD83D\uDC69\u200D\uD83E\uDDAF", "\uD83D\uDC69\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\u200D\uD83E\uDDBC", "\uD83D\uDC69\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\u200D\uD83E\uDDBD", "\uD83D\uDC69\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2695\uFE0F", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2696\uFE0F", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2708\uFE0F", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDF3E", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDF73", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDF7C", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDF93", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFA4", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFA8", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFEB", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFED", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDCBB", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDCBC", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDD27", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDD2C", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDE80", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDE92", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDAF", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDBC", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDBD", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2695\uFE0F", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2696\uFE0F", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2708\uFE0F", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDF3E", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDF73", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDF7C", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDF93", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFA4", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFA8", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFEB", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFED", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDCBB", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDCBC", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDD27", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDD2C", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDE80", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDE92", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDAF", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDBC", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDBD", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2695\uFE0F", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2696\uFE0F", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2708\uFE0F", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDF3E", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDF73", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDF7C", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDF93", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFA4", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFA8", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFEB", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFED", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDCBB", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDCBC", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDD27", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDD2C", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDE80", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDE92", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDAF", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDBC", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDBD", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2695\uFE0F", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2696\uFE0F", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2708\uFE0F", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDF3E", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDF73", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDF7C", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDF93", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFA4", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFA8", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFEB", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFED", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDCBB", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDCBC", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDD27", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDD2C", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDE80", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDE92", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDAF", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDBC", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDBD", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2695\uFE0F", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2696\uFE0F", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2708\uFE0F", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDF3E", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDF73", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDF7C", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDF93", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFA4", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFA8", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFEB", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFED", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDCBB", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDCBC", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDD27", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDD2C", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDE80", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDE92", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDAF", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDBC", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDBD", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDEB6\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFB\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFC\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFD\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFE\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFF\u200D\u27A1\uFE0F", "\uD83E\uDDCE\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFB\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFC\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFD\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFE\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\u200D\u2695\uFE0F", "\uD83E\uDDD1\u200D\u2696\uFE0F", "\uD83E\uDDD1\u200D\u2708\uFE0F", "\uD83E\uDDD1\u200D\uD83C\uDF3E", "\uD83E\uDDD1\u200D\uD83C\uDF73", "\uD83E\uDDD1\u200D\uD83C\uDF7C", "\uD83E\uDDD1\u200D\uD83C\uDF84", "\uD83E\uDDD1\u200D\uD83C\uDF93", "\uD83E\uDDD1\u200D\uD83C\uDFA4", "\uD83E\uDDD1\u200D\uD83C\uDFA8", "\uD83E\uDDD1\u200D\uD83C\uDFEB", "\uD83E\uDDD1\u200D\uD83C\uDFED", "\uD83E\uDDD1\u200D\uD83D\uDCBB", "\uD83E\uDDD1\u200D\uD83D\uDCBC", "\uD83E\uDDD1\u200D\uD83D\uDD27", "\uD83E\uDDD1\u200D\uD83D\uDD2C", "\uD83E\uDDD1\u200D\uD83D\uDE80", "\uD83E\uDDD1\u200D\uD83D\uDE92", "\uD83E\uDDD1\u200D\uD83E\uDDAF", "\uD83E\uDDD1\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\u200D\uD83E\uDDBC", "\uD83E\uDDD1\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\u200D\uD83E\uDDBD", "\uD83E\uDDD1\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2695\uFE0F", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2696\uFE0F", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2708\uFE0F", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDF3E", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDF73", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDF7C", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDF84", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDF93", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDFA4", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDFA8", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDFEB", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDFED", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDCBB", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDCBC", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDD27", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDD2C", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDE80", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDE92", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDAF", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDBC", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDBD", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2695\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2696\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2708\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDF3E", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDF73", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDF7C", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDF84", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDF93", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDFA4", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDFA8", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDFEB", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDFED", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDCBB", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDCBC", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDD27", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDD2C", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDE80", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDE92", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDAF", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDBC", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDBD", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2695\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2696\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2708\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDF3E", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDF73", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDF7C", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDF84", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDF93", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDFA4", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDFA8", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDFEB", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDFED", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDCBB", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDCBC", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDD27", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDD2C", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDE80", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDE92", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDAF", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDBC", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDBD", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2695\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2696\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2708\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDF3E", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDF73", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDF7C", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDF84", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDF93", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDFA4", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDFA8", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDFEB", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDFED", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDCBB", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDCBC", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDD27", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDD2C", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDE80", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDE92", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDAF", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDBC", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDBD", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2695\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2696\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2708\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDF3E", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDF73", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDF7C", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDF84", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDF93", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDFA4", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDFA8", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDFEB", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDFED", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDCBB", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDCBC", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDD27", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDD2C", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDE80", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDE92", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDAF", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDBC", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDBD", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\u26F9\uD83C\uDFFB\u200D\u2640\uFE0F", "\u26F9\uD83C\uDFFB\u200D\u2642\uFE0F", "\u26F9\uD83C\uDFFC\u200D\u2640\uFE0F", "\u26F9\uD83C\uDFFC\u200D\u2642\uFE0F", "\u26F9\uD83C\uDFFD\u200D\u2640\uFE0F", "\u26F9\uD83C\uDFFD\u200D\u2642\uFE0F", "\u26F9\uD83C\uDFFE\u200D\u2640\uFE0F", "\u26F9\uD83C\uDFFE\u200D\u2642\uFE0F", "\u26F9\uD83C\uDFFF\u200D\u2640\uFE0F", "\u26F9\uD83C\uDFFF\u200D\u2642\uFE0F", "\u26F9\uFE0F\u200D\u2640\uFE0F", "\u26F9\uFE0F\u200D\u2642\uFE0F", "\uD83C\uDFC3\u200D\u2640\uFE0F", "\uD83C\uDFC3\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\u200D\u2642\uFE0F", "\uD83C\uDFC3\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83C\uDFC3\uD83C\uDFFB\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83C\uDFC3\uD83C\uDFFB\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83C\uDFC3\uD83C\uDFFC\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83C\uDFC3\uD83C\uDFFC\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83C\uDFC3\uD83C\uDFFD\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83C\uDFC3\uD83C\uDFFD\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83C\uDFC3\uD83C\uDFFE\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83C\uDFC3\uD83C\uDFFE\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83C\uDFC3\uD83C\uDFFF\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83C\uDFC3\uD83C\uDFFF\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC4\u200D\u2640\uFE0F", "\uD83C\uDFC4\u200D\u2642\uFE0F", "\uD83C\uDFC4\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83C\uDFC4\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83C\uDFC4\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83C\uDFC4\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83C\uDFC4\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83C\uDFC4\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83C\uDFC4\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83C\uDFC4\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83C\uDFC4\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83C\uDFC4\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83C\uDFCA\u200D\u2640\uFE0F", "\uD83C\uDFCA\u200D\u2642\uFE0F", "\uD83C\uDFCA\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83C\uDFCA\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83C\uDFCA\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83C\uDFCA\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83C\uDFCA\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83C\uDFCA\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83C\uDFCA\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83C\uDFCA\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83C\uDFCA\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83C\uDFCA\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83C\uDFCB\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83C\uDFCB\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83C\uDFCB\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83C\uDFCB\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83C\uDFCB\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83C\uDFCB\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83C\uDFCB\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83C\uDFCB\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83C\uDFCB\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83C\uDFCB\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83C\uDFCB\uFE0F\u200D\u2640\uFE0F", "\uD83C\uDFCB\uFE0F\u200D\u2642\uFE0F", "\uD83C\uDFCC\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83C\uDFCC\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83C\uDFCC\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83C\uDFCC\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83C\uDFCC\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83C\uDFCC\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83C\uDFCC\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83C\uDFCC\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83C\uDFCC\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83C\uDFCC\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83C\uDFCC\uFE0F\u200D\u2640\uFE0F", "\uD83C\uDFCC\uFE0F\u200D\u2642\uFE0F", "\uD83D\uDC6E\u200D\u2640\uFE0F", "\uD83D\uDC6E\u200D\u2642\uFE0F", "\uD83D\uDC6E\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC6E\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC6E\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC6E\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC6E\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC6E\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC6E\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC6E\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC6E\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC6E\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC6F\u200D\u2640\uFE0F", "\uD83D\uDC6F\u200D\u2642\uFE0F", "\uD83D\uDC70\u200D\u2640\uFE0F", "\uD83D\uDC70\u200D\u2642\uFE0F", "\uD83D\uDC70\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC70\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC70\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC70\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC70\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC70\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC70\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC70\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC70\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC70\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC71\u200D\u2640\uFE0F", "\uD83D\uDC71\u200D\u2642\uFE0F", "\uD83D\uDC71\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC71\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC71\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC71\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC71\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC71\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC71\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC71\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC71\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC71\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC73\u200D\u2640\uFE0F", "\uD83D\uDC73\u200D\u2642\uFE0F", "\uD83D\uDC73\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC73\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC73\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC73\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC73\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC73\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC73\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC73\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC73\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC73\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC77\u200D\u2640\uFE0F", "\uD83D\uDC77\u200D\u2642\uFE0F", "\uD83D\uDC77\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC77\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC77\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC77\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC77\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC77\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC77\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC77\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC77\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC77\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC81\u200D\u2640\uFE0F", "\uD83D\uDC81\u200D\u2642\uFE0F", "\uD83D\uDC81\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC81\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC81\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC81\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC81\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC81\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC81\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC81\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC81\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC81\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC82\u200D\u2640\uFE0F", "\uD83D\uDC82\u200D\u2642\uFE0F", "\uD83D\uDC82\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC82\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC82\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC82\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC82\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC82\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC82\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC82\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC82\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC82\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC86\u200D\u2640\uFE0F", "\uD83D\uDC86\u200D\u2642\uFE0F", "\uD83D\uDC86\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC86\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC86\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC86\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC86\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC86\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC86\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC86\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC86\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC86\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC87\u200D\u2640\uFE0F", "\uD83D\uDC87\u200D\u2642\uFE0F", "\uD83D\uDC87\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC87\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC87\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC87\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC87\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC87\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC87\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC87\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC87\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC87\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDD75\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDD75\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDD75\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDD75\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDD75\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDD75\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDD75\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDD75\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDD75\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDD75\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDD75\uFE0F\u200D\u2640\uFE0F", "\uD83D\uDD75\uFE0F\u200D\u2642\uFE0F", "\uD83D\uDE45\u200D\u2640\uFE0F", "\uD83D\uDE45\u200D\u2642\uFE0F", "\uD83D\uDE45\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE45\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE45\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE45\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE45\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE45\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE45\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE45\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE45\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE45\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDE46\u200D\u2640\uFE0F", "\uD83D\uDE46\u200D\u2642\uFE0F", "\uD83D\uDE46\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE46\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE46\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE46\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE46\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE46\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE46\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE46\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE46\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE46\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDE47\u200D\u2640\uFE0F", "\uD83D\uDE47\u200D\u2642\uFE0F", "\uD83D\uDE47\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE47\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE47\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE47\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE47\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE47\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE47\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE47\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE47\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE47\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDE4B\u200D\u2640\uFE0F", "\uD83D\uDE4B\u200D\u2642\uFE0F", "\uD83D\uDE4B\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE4B\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE4B\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE4B\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE4B\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE4B\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE4B\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE4B\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE4B\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE4B\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDE4D\u200D\u2640\uFE0F", "\uD83D\uDE4D\u200D\u2642\uFE0F", "\uD83D\uDE4D\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE4D\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE4D\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE4D\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE4D\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE4D\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE4D\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE4D\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE4D\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE4D\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDE4E\u200D\u2640\uFE0F", "\uD83D\uDE4E\u200D\u2642\uFE0F", "\uD83D\uDE4E\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE4E\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE4E\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE4E\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE4E\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE4E\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE4E\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE4E\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE4E\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE4E\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDEA3\u200D\u2640\uFE0F", "\uD83D\uDEA3\u200D\u2642\uFE0F", "\uD83D\uDEA3\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDEA3\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDEA3\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDEA3\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDEA3\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDEA3\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDEA3\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDEA3\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDEA3\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDEA3\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDEB4\u200D\u2640\uFE0F", "\uD83D\uDEB4\u200D\u2642\uFE0F", "\uD83D\uDEB4\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDEB4\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDEB4\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDEB4\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDEB4\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDEB4\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDEB4\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDEB4\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDEB4\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDEB4\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDEB5\u200D\u2640\uFE0F", "\uD83D\uDEB5\u200D\u2642\uFE0F", "\uD83D\uDEB5\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDEB5\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDEB5\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDEB5\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDEB5\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDEB5\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDEB5\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDEB5\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDEB5\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDEB5\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDEB6\u200D\u2640\uFE0F", "\uD83D\uDEB6\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\u200D\u2642\uFE0F", "\uD83D\uDEB6\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDEB6\uD83C\uDFFB\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDEB6\uD83C\uDFFB\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDEB6\uD83C\uDFFC\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDEB6\uD83C\uDFFC\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDEB6\uD83C\uDFFD\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDEB6\uD83C\uDFFD\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDEB6\uD83C\uDFFE\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDEB6\uD83C\uDFFE\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDEB6\uD83C\uDFFF\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDEB6\uD83C\uDFFF\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDD26\u200D\u2640\uFE0F", "\uD83E\uDD26\u200D\u2642\uFE0F", "\uD83E\uDD26\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD26\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD26\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD26\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD26\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD26\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD26\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD26\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD26\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD26\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD35\u200D\u2640\uFE0F", "\uD83E\uDD35\u200D\u2642\uFE0F", "\uD83E\uDD35\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD35\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD35\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD35\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD35\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD35\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD35\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD35\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD35\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD35\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD37\u200D\u2640\uFE0F", "\uD83E\uDD37\u200D\u2642\uFE0F", "\uD83E\uDD37\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD37\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD37\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD37\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD37\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD37\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD37\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD37\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD37\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD37\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD38\u200D\u2640\uFE0F", "\uD83E\uDD38\u200D\u2642\uFE0F", "\uD83E\uDD38\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD38\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD38\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD38\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD38\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD38\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD38\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD38\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD38\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD38\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD39\u200D\u2640\uFE0F", "\uD83E\uDD39\u200D\u2642\uFE0F", "\uD83E\uDD39\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD39\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD39\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD39\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD39\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD39\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD39\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD39\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD39\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD39\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD3C\u200D\u2640\uFE0F", "\uD83E\uDD3C\u200D\u2642\uFE0F", "\uD83E\uDD3D\u200D\u2640\uFE0F", "\uD83E\uDD3D\u200D\u2642\uFE0F", "\uD83E\uDD3D\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD3D\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD3D\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD3D\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD3D\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD3D\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD3D\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD3D\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD3D\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD3D\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD3E\u200D\u2640\uFE0F", "\uD83E\uDD3E\u200D\u2642\uFE0F", "\uD83E\uDD3E\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD3E\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD3E\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD3E\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD3E\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD3E\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD3E\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD3E\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD3E\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD3E\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDB8\u200D\u2640\uFE0F", "\uD83E\uDDB8\u200D\u2642\uFE0F", "\uD83E\uDDB8\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDB8\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDB8\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDB8\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDB8\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDB8\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDB8\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDB8\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDB8\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDB8\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDB9\u200D\u2640\uFE0F", "\uD83E\uDDB9\u200D\u2642\uFE0F", "\uD83E\uDDB9\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDB9\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDB9\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDB9\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDB9\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDB9\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDB9\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDB9\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDB9\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDB9\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDCD\u200D\u2640\uFE0F", "\uD83E\uDDCD\u200D\u2642\uFE0F", "\uD83E\uDDCD\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDCD\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDCD\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDCD\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDCD\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDCD\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDCD\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDCD\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDCD\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDCD\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDCE\u200D\u2640\uFE0F", "\uD83E\uDDCE\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\u200D\u2642\uFE0F", "\uD83E\uDDCE\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDCE\uD83C\uDFFB\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDCE\uD83C\uDFFB\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDCE\uD83C\uDFFC\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDCE\uD83C\uDFFC\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDCE\uD83C\uDFFD\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDCE\uD83C\uDFFD\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDCE\uD83C\uDFFE\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDCE\uD83C\uDFFE\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDCE\uD83C\uDFFF\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDCE\uD83C\uDFFF\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCF\u200D\u2640\uFE0F", "\uD83E\uDDCF\u200D\u2642\uFE0F", "\uD83E\uDDCF\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDCF\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDCF\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDCF\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDCF\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDCF\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDCF\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDCF\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDCF\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDCF\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDD4\u200D\u2640\uFE0F", "\uD83E\uDDD4\u200D\u2642\uFE0F", "\uD83E\uDDD4\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDD4\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDD4\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDD4\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDD4\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDD4\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDD4\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDD4\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDD4\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDD4\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDD6\u200D\u2640\uFE0F", "\uD83E\uDDD6\u200D\u2642\uFE0F", "\uD83E\uDDD6\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDD6\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDD6\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDD6\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDD6\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDD6\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDD6\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDD6\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDD6\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDD6\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDD7\u200D\u2640\uFE0F", "\uD83E\uDDD7\u200D\u2642\uFE0F", "\uD83E\uDDD7\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDD7\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDD7\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDD7\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDD7\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDD7\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDD7\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDD7\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDD7\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDD7\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDD8\u200D\u2640\uFE0F", "\uD83E\uDDD8\u200D\u2642\uFE0F", "\uD83E\uDDD8\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDD8\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDD8\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDD8\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDD8\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDD8\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDD8\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDD8\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDD8\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDD8\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDD9\u200D\u2640\uFE0F", "\uD83E\uDDD9\u200D\u2642\uFE0F", "\uD83E\uDDD9\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDD9\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDD9\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDD9\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDD9\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDD9\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDD9\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDD9\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDD9\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDD9\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDDA\u200D\u2640\uFE0F", "\uD83E\uDDDA\u200D\u2642\uFE0F", "\uD83E\uDDDA\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDDA\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDDA\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDDA\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDDA\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDDA\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDDA\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDDA\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDDA\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDDA\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDDB\u200D\u2640\uFE0F", "\uD83E\uDDDB\u200D\u2642\uFE0F", "\uD83E\uDDDB\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDDB\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDDB\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDDB\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDDB\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDDB\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDDB\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDDB\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDDB\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDDB\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDDC\u200D\u2640\uFE0F", "\uD83E\uDDDC\u200D\u2642\uFE0F", "\uD83E\uDDDC\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDDC\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDDC\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDDC\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDDC\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDDC\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDDC\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDDC\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDDC\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDDC\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDDD\u200D\u2640\uFE0F", "\uD83E\uDDDD\u200D\u2642\uFE0F", "\uD83E\uDDDD\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDDD\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDDD\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDDD\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDDD\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDDD\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDDD\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDDD\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDDD\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDDD\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDDE\u200D\u2640\uFE0F", "\uD83E\uDDDE\u200D\u2642\uFE0F", "\uD83E\uDDDF\u200D\u2640\uFE0F", "\uD83E\uDDDF\u200D\u2642\uFE0F", "\uD83D\uDC68\u200D\uD83E\uDDB0", "\uD83D\uDC68\u200D\uD83E\uDDB1", "\uD83D\uDC68\u200D\uD83E\uDDB2", "\uD83D\uDC68\u200D\uD83E\uDDB3", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDB0", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDB1", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDB2", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDB3", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDB0", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDB1", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDB2", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDB3", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDB0", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDB1", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDB2", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDB3", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDB0", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDB1", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDB2", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDB3", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDB0", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDB1", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDB2", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDB3", "\uD83D\uDC69\u200D\uD83E\uDDB0", "\uD83D\uDC69\u200D\uD83E\uDDB1", "\uD83D\uDC69\u200D\uD83E\uDDB2", "\uD83D\uDC69\u200D\uD83E\uDDB3", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDB0", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDB1", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDB2", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDB3", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDB0", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDB1", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDB2", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDB3", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDB0", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDB1", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDB2", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDB3", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDB0", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDB1", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDB2", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDB3", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDB0", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDB1", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDB2", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDB3", "\uD83E\uDDD1\u200D\uD83E\uDDB0", "\uD83E\uDDD1\u200D\uD83E\uDDB1", "\uD83E\uDDD1\u200D\uD83E\uDDB2", "\uD83E\uDDD1\u200D\uD83E\uDDB3", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDB0", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDB1", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDB2", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDB3", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDB0", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDB1", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDB2", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDB3", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDB0", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDB1", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDB2", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDB3", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDB0", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDB1", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDB2", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDB3", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDB0", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDB1", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDB2", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDB3", "\u26D3\uFE0F\u200D\uD83D\uDCA5", "\u2764\uFE0F\u200D\uD83D\uDD25", "\u2764\uFE0F\u200D\uD83E\uDE79", "\uD83C\uDF44\u200D\uD83D\uDFEB", "\uD83C\uDF4B\u200D\uD83D\uDFE9", "\uD83C\uDFF3\uFE0F\u200D\u26A7\uFE0F", "\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08", "\uD83C\uDFF4\u200D\u2620\uFE0F", "\uD83D\uDC08\u200D\u2B1B", "\uD83D\uDC15\u200D\uD83E\uDDBA", "\uD83D\uDC26\u200D\u2B1B", "\uD83D\uDC26\u200D\uD83D\uDD25", "\uD83D\uDC3B\u200D\u2744\uFE0F", "\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8\uFE0F", "\uD83D\uDE2E\u200D\uD83D\uDCA8", "\uD83D\uDE35\u200D\uD83D\uDCAB", "\uD83D\uDE36\u200D\uD83C\uDF2B\uFE0F", "\uD83D\uDE42\u200D\u2194\uFE0F", "\uD83D\uDE42\u200D\u2195\uFE0F"];
    return RGI_Emoji_ZWJ_Sequence;
  }

var RGI_Emoji = {};

var hasRequiredRGI_Emoji;
  function requireRGI_Emoji() {
    if (hasRequiredRGI_Emoji) return RGI_Emoji;
    hasRequiredRGI_Emoji = 1;
    var set = regenerateExports(0x23F0, 0x23F3, 0x267F, 0x2693, 0x26A1, 0x26CE, 0x26D4, 0x26EA, 0x26F5, 0x26FA, 0x26FD, 0x2705, 0x2728, 0x274C, 0x274E, 0x2757, 0x27B0, 0x27BF, 0x2B50, 0x2B55, 0x1F004, 0x1F0CF, 0x1F18E, 0x1F201, 0x1F21A, 0x1F22F, 0x1F3F4, 0x1F440, 0x1F57A, 0x1F5A4, 0x1F6CC, 0x1F7F0);
    set.addRange(0x231A, 0x231B).addRange(0x23E9, 0x23EC).addRange(0x25FD, 0x25FE).addRange(0x2614, 0x2615).addRange(0x2648, 0x2653).addRange(0x26AA, 0x26AB).addRange(0x26BD, 0x26BE).addRange(0x26C4, 0x26C5).addRange(0x26F2, 0x26F3).addRange(0x270A, 0x270B).addRange(0x2753, 0x2755).addRange(0x2795, 0x2797).addRange(0x2B1B, 0x2B1C).addRange(0x1F191, 0x1F19A).addRange(0x1F232, 0x1F236).addRange(0x1F238, 0x1F23A).addRange(0x1F250, 0x1F251).addRange(0x1F300, 0x1F320).addRange(0x1F32D, 0x1F335).addRange(0x1F337, 0x1F37C).addRange(0x1F37E, 0x1F393).addRange(0x1F3A0, 0x1F3CA).addRange(0x1F3CF, 0x1F3D3).addRange(0x1F3E0, 0x1F3F0).addRange(0x1F3F8, 0x1F43E).addRange(0x1F442, 0x1F4FC).addRange(0x1F4FF, 0x1F53D).addRange(0x1F54B, 0x1F54E).addRange(0x1F550, 0x1F567).addRange(0x1F595, 0x1F596).addRange(0x1F5FB, 0x1F64F).addRange(0x1F680, 0x1F6C5).addRange(0x1F6D0, 0x1F6D2).addRange(0x1F6D5, 0x1F6D7).addRange(0x1F6DC, 0x1F6DF).addRange(0x1F6EB, 0x1F6EC).addRange(0x1F6F4, 0x1F6FC).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F90C, 0x1F93A).addRange(0x1F93C, 0x1F945).addRange(0x1F947, 0x1F9FF).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA89).addRange(0x1FA8F, 0x1FAC6).addRange(0x1FACE, 0x1FADC).addRange(0x1FADF, 0x1FAE9).addRange(0x1FAF0, 0x1FAF8);
    RGI_Emoji.characters = set;
    RGI_Emoji.strings = ["#\uFE0F\u20E3", "*\uFE0F\u20E3", "0\uFE0F\u20E3", "1\uFE0F\u20E3", "2\uFE0F\u20E3", "3\uFE0F\u20E3", "4\uFE0F\u20E3", "5\uFE0F\u20E3", "6\uFE0F\u20E3", "7\uFE0F\u20E3", "8\uFE0F\u20E3", "9\uFE0F\u20E3", "\xA9\uFE0F", "\xAE\uFE0F", "\u203C\uFE0F", "\u2049\uFE0F", "\u2122\uFE0F", "\u2139\uFE0F", "\u2194\uFE0F", "\u2195\uFE0F", "\u2196\uFE0F", "\u2197\uFE0F", "\u2198\uFE0F", "\u2199\uFE0F", "\u21A9\uFE0F", "\u21AA\uFE0F", "\u2328\uFE0F", "\u23CF\uFE0F", "\u23ED\uFE0F", "\u23EE\uFE0F", "\u23EF\uFE0F", "\u23F1\uFE0F", "\u23F2\uFE0F", "\u23F8\uFE0F", "\u23F9\uFE0F", "\u23FA\uFE0F", "\u24C2\uFE0F", "\u25AA\uFE0F", "\u25AB\uFE0F", "\u25B6\uFE0F", "\u25C0\uFE0F", "\u25FB\uFE0F", "\u25FC\uFE0F", "\u2600\uFE0F", "\u2601\uFE0F", "\u2602\uFE0F", "\u2603\uFE0F", "\u2604\uFE0F", "\u260E\uFE0F", "\u2611\uFE0F", "\u2618\uFE0F", "\u261D\uD83C\uDFFB", "\u261D\uD83C\uDFFC", "\u261D\uD83C\uDFFD", "\u261D\uD83C\uDFFE", "\u261D\uD83C\uDFFF", "\u261D\uFE0F", "\u2620\uFE0F", "\u2622\uFE0F", "\u2623\uFE0F", "\u2626\uFE0F", "\u262A\uFE0F", "\u262E\uFE0F", "\u262F\uFE0F", "\u2638\uFE0F", "\u2639\uFE0F", "\u263A\uFE0F", "\u2640\uFE0F", "\u2642\uFE0F", "\u265F\uFE0F", "\u2660\uFE0F", "\u2663\uFE0F", "\u2665\uFE0F", "\u2666\uFE0F", "\u2668\uFE0F", "\u267B\uFE0F", "\u267E\uFE0F", "\u2692\uFE0F", "\u2694\uFE0F", "\u2695\uFE0F", "\u2696\uFE0F", "\u2697\uFE0F", "\u2699\uFE0F", "\u269B\uFE0F", "\u269C\uFE0F", "\u26A0\uFE0F", "\u26A7\uFE0F", "\u26B0\uFE0F", "\u26B1\uFE0F", "\u26C8\uFE0F", "\u26CF\uFE0F", "\u26D1\uFE0F", "\u26D3\uFE0F", "\u26D3\uFE0F\u200D\uD83D\uDCA5", "\u26E9\uFE0F", "\u26F0\uFE0F", "\u26F1\uFE0F", "\u26F4\uFE0F", "\u26F7\uFE0F", "\u26F8\uFE0F", "\u26F9\uD83C\uDFFB", "\u26F9\uD83C\uDFFB\u200D\u2640\uFE0F", "\u26F9\uD83C\uDFFB\u200D\u2642\uFE0F", "\u26F9\uD83C\uDFFC", "\u26F9\uD83C\uDFFC\u200D\u2640\uFE0F", "\u26F9\uD83C\uDFFC\u200D\u2642\uFE0F", "\u26F9\uD83C\uDFFD", "\u26F9\uD83C\uDFFD\u200D\u2640\uFE0F", "\u26F9\uD83C\uDFFD\u200D\u2642\uFE0F", "\u26F9\uD83C\uDFFE", "\u26F9\uD83C\uDFFE\u200D\u2640\uFE0F", "\u26F9\uD83C\uDFFE\u200D\u2642\uFE0F", "\u26F9\uD83C\uDFFF", "\u26F9\uD83C\uDFFF\u200D\u2640\uFE0F", "\u26F9\uD83C\uDFFF\u200D\u2642\uFE0F", "\u26F9\uFE0F", "\u26F9\uFE0F\u200D\u2640\uFE0F", "\u26F9\uFE0F\u200D\u2642\uFE0F", "\u2702\uFE0F", "\u2708\uFE0F", "\u2709\uFE0F", "\u270A\uD83C\uDFFB", "\u270A\uD83C\uDFFC", "\u270A\uD83C\uDFFD", "\u270A\uD83C\uDFFE", "\u270A\uD83C\uDFFF", "\u270B\uD83C\uDFFB", "\u270B\uD83C\uDFFC", "\u270B\uD83C\uDFFD", "\u270B\uD83C\uDFFE", "\u270B\uD83C\uDFFF", "\u270C\uD83C\uDFFB", "\u270C\uD83C\uDFFC", "\u270C\uD83C\uDFFD", "\u270C\uD83C\uDFFE", "\u270C\uD83C\uDFFF", "\u270C\uFE0F", "\u270D\uD83C\uDFFB", "\u270D\uD83C\uDFFC", "\u270D\uD83C\uDFFD", "\u270D\uD83C\uDFFE", "\u270D\uD83C\uDFFF", "\u270D\uFE0F", "\u270F\uFE0F", "\u2712\uFE0F", "\u2714\uFE0F", "\u2716\uFE0F", "\u271D\uFE0F", "\u2721\uFE0F", "\u2733\uFE0F", "\u2734\uFE0F", "\u2744\uFE0F", "\u2747\uFE0F", "\u2763\uFE0F", "\u2764\uFE0F", "\u2764\uFE0F\u200D\uD83D\uDD25", "\u2764\uFE0F\u200D\uD83E\uDE79", "\u27A1\uFE0F", "\u2934\uFE0F", "\u2935\uFE0F", "\u2B05\uFE0F", "\u2B06\uFE0F", "\u2B07\uFE0F", "\u3030\uFE0F", "\u303D\uFE0F", "\u3297\uFE0F", "\u3299\uFE0F", "\uD83C\uDD70\uFE0F", "\uD83C\uDD71\uFE0F", "\uD83C\uDD7E\uFE0F", "\uD83C\uDD7F\uFE0F", "\uD83C\uDDE6\uD83C\uDDE8", "\uD83C\uDDE6\uD83C\uDDE9", "\uD83C\uDDE6\uD83C\uDDEA", "\uD83C\uDDE6\uD83C\uDDEB", "\uD83C\uDDE6\uD83C\uDDEC", "\uD83C\uDDE6\uD83C\uDDEE", "\uD83C\uDDE6\uD83C\uDDF1", "\uD83C\uDDE6\uD83C\uDDF2", "\uD83C\uDDE6\uD83C\uDDF4", "\uD83C\uDDE6\uD83C\uDDF6", "\uD83C\uDDE6\uD83C\uDDF7", "\uD83C\uDDE6\uD83C\uDDF8", "\uD83C\uDDE6\uD83C\uDDF9", "\uD83C\uDDE6\uD83C\uDDFA", "\uD83C\uDDE6\uD83C\uDDFC", "\uD83C\uDDE6\uD83C\uDDFD", "\uD83C\uDDE6\uD83C\uDDFF", "\uD83C\uDDE7\uD83C\uDDE6", "\uD83C\uDDE7\uD83C\uDDE7", "\uD83C\uDDE7\uD83C\uDDE9", "\uD83C\uDDE7\uD83C\uDDEA", "\uD83C\uDDE7\uD83C\uDDEB", "\uD83C\uDDE7\uD83C\uDDEC", "\uD83C\uDDE7\uD83C\uDDED", "\uD83C\uDDE7\uD83C\uDDEE", "\uD83C\uDDE7\uD83C\uDDEF", "\uD83C\uDDE7\uD83C\uDDF1", "\uD83C\uDDE7\uD83C\uDDF2", "\uD83C\uDDE7\uD83C\uDDF3", "\uD83C\uDDE7\uD83C\uDDF4", "\uD83C\uDDE7\uD83C\uDDF6", "\uD83C\uDDE7\uD83C\uDDF7", "\uD83C\uDDE7\uD83C\uDDF8", "\uD83C\uDDE7\uD83C\uDDF9", "\uD83C\uDDE7\uD83C\uDDFB", "\uD83C\uDDE7\uD83C\uDDFC", "\uD83C\uDDE7\uD83C\uDDFE", "\uD83C\uDDE7\uD83C\uDDFF", "\uD83C\uDDE8\uD83C\uDDE6", "\uD83C\uDDE8\uD83C\uDDE8", "\uD83C\uDDE8\uD83C\uDDE9", "\uD83C\uDDE8\uD83C\uDDEB", "\uD83C\uDDE8\uD83C\uDDEC", "\uD83C\uDDE8\uD83C\uDDED", "\uD83C\uDDE8\uD83C\uDDEE", "\uD83C\uDDE8\uD83C\uDDF0", "\uD83C\uDDE8\uD83C\uDDF1", "\uD83C\uDDE8\uD83C\uDDF2", "\uD83C\uDDE8\uD83C\uDDF3", "\uD83C\uDDE8\uD83C\uDDF4", "\uD83C\uDDE8\uD83C\uDDF5", "\uD83C\uDDE8\uD83C\uDDF6", "\uD83C\uDDE8\uD83C\uDDF7", "\uD83C\uDDE8\uD83C\uDDFA", "\uD83C\uDDE8\uD83C\uDDFB", "\uD83C\uDDE8\uD83C\uDDFC", "\uD83C\uDDE8\uD83C\uDDFD", "\uD83C\uDDE8\uD83C\uDDFE", "\uD83C\uDDE8\uD83C\uDDFF", "\uD83C\uDDE9\uD83C\uDDEA", "\uD83C\uDDE9\uD83C\uDDEC", "\uD83C\uDDE9\uD83C\uDDEF", "\uD83C\uDDE9\uD83C\uDDF0", "\uD83C\uDDE9\uD83C\uDDF2", "\uD83C\uDDE9\uD83C\uDDF4", "\uD83C\uDDE9\uD83C\uDDFF", "\uD83C\uDDEA\uD83C\uDDE6", "\uD83C\uDDEA\uD83C\uDDE8", "\uD83C\uDDEA\uD83C\uDDEA", "\uD83C\uDDEA\uD83C\uDDEC", "\uD83C\uDDEA\uD83C\uDDED", "\uD83C\uDDEA\uD83C\uDDF7", "\uD83C\uDDEA\uD83C\uDDF8", "\uD83C\uDDEA\uD83C\uDDF9", "\uD83C\uDDEA\uD83C\uDDFA", "\uD83C\uDDEB\uD83C\uDDEE", "\uD83C\uDDEB\uD83C\uDDEF", "\uD83C\uDDEB\uD83C\uDDF0", "\uD83C\uDDEB\uD83C\uDDF2", "\uD83C\uDDEB\uD83C\uDDF4", "\uD83C\uDDEB\uD83C\uDDF7", "\uD83C\uDDEC\uD83C\uDDE6", "\uD83C\uDDEC\uD83C\uDDE7", "\uD83C\uDDEC\uD83C\uDDE9", "\uD83C\uDDEC\uD83C\uDDEA", "\uD83C\uDDEC\uD83C\uDDEB", "\uD83C\uDDEC\uD83C\uDDEC", "\uD83C\uDDEC\uD83C\uDDED", "\uD83C\uDDEC\uD83C\uDDEE", "\uD83C\uDDEC\uD83C\uDDF1", "\uD83C\uDDEC\uD83C\uDDF2", "\uD83C\uDDEC\uD83C\uDDF3", "\uD83C\uDDEC\uD83C\uDDF5", "\uD83C\uDDEC\uD83C\uDDF6", "\uD83C\uDDEC\uD83C\uDDF7", "\uD83C\uDDEC\uD83C\uDDF8", "\uD83C\uDDEC\uD83C\uDDF9", "\uD83C\uDDEC\uD83C\uDDFA", "\uD83C\uDDEC\uD83C\uDDFC", "\uD83C\uDDEC\uD83C\uDDFE", "\uD83C\uDDED\uD83C\uDDF0", "\uD83C\uDDED\uD83C\uDDF2", "\uD83C\uDDED\uD83C\uDDF3", "\uD83C\uDDED\uD83C\uDDF7", "\uD83C\uDDED\uD83C\uDDF9", "\uD83C\uDDED\uD83C\uDDFA", "\uD83C\uDDEE\uD83C\uDDE8", "\uD83C\uDDEE\uD83C\uDDE9", "\uD83C\uDDEE\uD83C\uDDEA", "\uD83C\uDDEE\uD83C\uDDF1", "\uD83C\uDDEE\uD83C\uDDF2", "\uD83C\uDDEE\uD83C\uDDF3", "\uD83C\uDDEE\uD83C\uDDF4", "\uD83C\uDDEE\uD83C\uDDF6", "\uD83C\uDDEE\uD83C\uDDF7", "\uD83C\uDDEE\uD83C\uDDF8", "\uD83C\uDDEE\uD83C\uDDF9", "\uD83C\uDDEF\uD83C\uDDEA", "\uD83C\uDDEF\uD83C\uDDF2", "\uD83C\uDDEF\uD83C\uDDF4", "\uD83C\uDDEF\uD83C\uDDF5", "\uD83C\uDDF0\uD83C\uDDEA", "\uD83C\uDDF0\uD83C\uDDEC", "\uD83C\uDDF0\uD83C\uDDED", "\uD83C\uDDF0\uD83C\uDDEE", "\uD83C\uDDF0\uD83C\uDDF2", "\uD83C\uDDF0\uD83C\uDDF3", "\uD83C\uDDF0\uD83C\uDDF5", "\uD83C\uDDF0\uD83C\uDDF7", "\uD83C\uDDF0\uD83C\uDDFC", "\uD83C\uDDF0\uD83C\uDDFE", "\uD83C\uDDF0\uD83C\uDDFF", "\uD83C\uDDF1\uD83C\uDDE6", "\uD83C\uDDF1\uD83C\uDDE7", "\uD83C\uDDF1\uD83C\uDDE8", "\uD83C\uDDF1\uD83C\uDDEE", "\uD83C\uDDF1\uD83C\uDDF0", "\uD83C\uDDF1\uD83C\uDDF7", "\uD83C\uDDF1\uD83C\uDDF8", "\uD83C\uDDF1\uD83C\uDDF9", "\uD83C\uDDF1\uD83C\uDDFA", "\uD83C\uDDF1\uD83C\uDDFB", "\uD83C\uDDF1\uD83C\uDDFE", "\uD83C\uDDF2\uD83C\uDDE6", "\uD83C\uDDF2\uD83C\uDDE8", "\uD83C\uDDF2\uD83C\uDDE9", "\uD83C\uDDF2\uD83C\uDDEA", "\uD83C\uDDF2\uD83C\uDDEB", "\uD83C\uDDF2\uD83C\uDDEC", "\uD83C\uDDF2\uD83C\uDDED", "\uD83C\uDDF2\uD83C\uDDF0", "\uD83C\uDDF2\uD83C\uDDF1", "\uD83C\uDDF2\uD83C\uDDF2", "\uD83C\uDDF2\uD83C\uDDF3", "\uD83C\uDDF2\uD83C\uDDF4", "\uD83C\uDDF2\uD83C\uDDF5", "\uD83C\uDDF2\uD83C\uDDF6", "\uD83C\uDDF2\uD83C\uDDF7", "\uD83C\uDDF2\uD83C\uDDF8", "\uD83C\uDDF2\uD83C\uDDF9", "\uD83C\uDDF2\uD83C\uDDFA", "\uD83C\uDDF2\uD83C\uDDFB", "\uD83C\uDDF2\uD83C\uDDFC", "\uD83C\uDDF2\uD83C\uDDFD", "\uD83C\uDDF2\uD83C\uDDFE", "\uD83C\uDDF2\uD83C\uDDFF", "\uD83C\uDDF3\uD83C\uDDE6", "\uD83C\uDDF3\uD83C\uDDE8", "\uD83C\uDDF3\uD83C\uDDEA", "\uD83C\uDDF3\uD83C\uDDEB", "\uD83C\uDDF3\uD83C\uDDEC", "\uD83C\uDDF3\uD83C\uDDEE", "\uD83C\uDDF3\uD83C\uDDF1", "\uD83C\uDDF3\uD83C\uDDF4", "\uD83C\uDDF3\uD83C\uDDF5", "\uD83C\uDDF3\uD83C\uDDF7", "\uD83C\uDDF3\uD83C\uDDFA", "\uD83C\uDDF3\uD83C\uDDFF", "\uD83C\uDDF4\uD83C\uDDF2", "\uD83C\uDDF5\uD83C\uDDE6", "\uD83C\uDDF5\uD83C\uDDEA", "\uD83C\uDDF5\uD83C\uDDEB", "\uD83C\uDDF5\uD83C\uDDEC", "\uD83C\uDDF5\uD83C\uDDED", "\uD83C\uDDF5\uD83C\uDDF0", "\uD83C\uDDF5\uD83C\uDDF1", "\uD83C\uDDF5\uD83C\uDDF2", "\uD83C\uDDF5\uD83C\uDDF3", "\uD83C\uDDF5\uD83C\uDDF7", "\uD83C\uDDF5\uD83C\uDDF8", "\uD83C\uDDF5\uD83C\uDDF9", "\uD83C\uDDF5\uD83C\uDDFC", "\uD83C\uDDF5\uD83C\uDDFE", "\uD83C\uDDF6\uD83C\uDDE6", "\uD83C\uDDF7\uD83C\uDDEA", "\uD83C\uDDF7\uD83C\uDDF4", "\uD83C\uDDF7\uD83C\uDDF8", "\uD83C\uDDF7\uD83C\uDDFA", "\uD83C\uDDF7\uD83C\uDDFC", "\uD83C\uDDF8\uD83C\uDDE6", "\uD83C\uDDF8\uD83C\uDDE7", "\uD83C\uDDF8\uD83C\uDDE8", "\uD83C\uDDF8\uD83C\uDDE9", "\uD83C\uDDF8\uD83C\uDDEA", "\uD83C\uDDF8\uD83C\uDDEC", "\uD83C\uDDF8\uD83C\uDDED", "\uD83C\uDDF8\uD83C\uDDEE", "\uD83C\uDDF8\uD83C\uDDEF", "\uD83C\uDDF8\uD83C\uDDF0", "\uD83C\uDDF8\uD83C\uDDF1", "\uD83C\uDDF8\uD83C\uDDF2", "\uD83C\uDDF8\uD83C\uDDF3", "\uD83C\uDDF8\uD83C\uDDF4", "\uD83C\uDDF8\uD83C\uDDF7", "\uD83C\uDDF8\uD83C\uDDF8", "\uD83C\uDDF8\uD83C\uDDF9", "\uD83C\uDDF8\uD83C\uDDFB", "\uD83C\uDDF8\uD83C\uDDFD", "\uD83C\uDDF8\uD83C\uDDFE", "\uD83C\uDDF8\uD83C\uDDFF", "\uD83C\uDDF9\uD83C\uDDE6", "\uD83C\uDDF9\uD83C\uDDE8", "\uD83C\uDDF9\uD83C\uDDE9", "\uD83C\uDDF9\uD83C\uDDEB", "\uD83C\uDDF9\uD83C\uDDEC", "\uD83C\uDDF9\uD83C\uDDED", "\uD83C\uDDF9\uD83C\uDDEF", "\uD83C\uDDF9\uD83C\uDDF0", "\uD83C\uDDF9\uD83C\uDDF1", "\uD83C\uDDF9\uD83C\uDDF2", "\uD83C\uDDF9\uD83C\uDDF3", "\uD83C\uDDF9\uD83C\uDDF4", "\uD83C\uDDF9\uD83C\uDDF7", "\uD83C\uDDF9\uD83C\uDDF9", "\uD83C\uDDF9\uD83C\uDDFB", "\uD83C\uDDF9\uD83C\uDDFC", "\uD83C\uDDF9\uD83C\uDDFF", "\uD83C\uDDFA\uD83C\uDDE6", "\uD83C\uDDFA\uD83C\uDDEC", "\uD83C\uDDFA\uD83C\uDDF2", "\uD83C\uDDFA\uD83C\uDDF3", "\uD83C\uDDFA\uD83C\uDDF8", "\uD83C\uDDFA\uD83C\uDDFE", "\uD83C\uDDFA\uD83C\uDDFF", "\uD83C\uDDFB\uD83C\uDDE6", "\uD83C\uDDFB\uD83C\uDDE8", "\uD83C\uDDFB\uD83C\uDDEA", "\uD83C\uDDFB\uD83C\uDDEC", "\uD83C\uDDFB\uD83C\uDDEE", "\uD83C\uDDFB\uD83C\uDDF3", "\uD83C\uDDFB\uD83C\uDDFA", "\uD83C\uDDFC\uD83C\uDDEB", "\uD83C\uDDFC\uD83C\uDDF8", "\uD83C\uDDFD\uD83C\uDDF0", "\uD83C\uDDFE\uD83C\uDDEA", "\uD83C\uDDFE\uD83C\uDDF9", "\uD83C\uDDFF\uD83C\uDDE6", "\uD83C\uDDFF\uD83C\uDDF2", "\uD83C\uDDFF\uD83C\uDDFC", "\uD83C\uDE02\uFE0F", "\uD83C\uDE37\uFE0F", "\uD83C\uDF21\uFE0F", "\uD83C\uDF24\uFE0F", "\uD83C\uDF25\uFE0F", "\uD83C\uDF26\uFE0F", "\uD83C\uDF27\uFE0F", "\uD83C\uDF28\uFE0F", "\uD83C\uDF29\uFE0F", "\uD83C\uDF2A\uFE0F", "\uD83C\uDF2B\uFE0F", "\uD83C\uDF2C\uFE0F", "\uD83C\uDF36\uFE0F", "\uD83C\uDF44\u200D\uD83D\uDFEB", "\uD83C\uDF4B\u200D\uD83D\uDFE9", "\uD83C\uDF7D\uFE0F", "\uD83C\uDF85\uD83C\uDFFB", "\uD83C\uDF85\uD83C\uDFFC", "\uD83C\uDF85\uD83C\uDFFD", "\uD83C\uDF85\uD83C\uDFFE", "\uD83C\uDF85\uD83C\uDFFF", "\uD83C\uDF96\uFE0F", "\uD83C\uDF97\uFE0F", "\uD83C\uDF99\uFE0F", "\uD83C\uDF9A\uFE0F", "\uD83C\uDF9B\uFE0F", "\uD83C\uDF9E\uFE0F", "\uD83C\uDF9F\uFE0F", "\uD83C\uDFC2\uD83C\uDFFB", "\uD83C\uDFC2\uD83C\uDFFC", "\uD83C\uDFC2\uD83C\uDFFD", "\uD83C\uDFC2\uD83C\uDFFE", "\uD83C\uDFC2\uD83C\uDFFF", "\uD83C\uDFC3\u200D\u2640\uFE0F", "\uD83C\uDFC3\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\u200D\u2642\uFE0F", "\uD83C\uDFC3\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFB", "\uD83C\uDFC3\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83C\uDFC3\uD83C\uDFFB\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83C\uDFC3\uD83C\uDFFB\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFB\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFC", "\uD83C\uDFC3\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83C\uDFC3\uD83C\uDFFC\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83C\uDFC3\uD83C\uDFFC\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFC\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFD", "\uD83C\uDFC3\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83C\uDFC3\uD83C\uDFFD\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83C\uDFC3\uD83C\uDFFD\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFD\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFE", "\uD83C\uDFC3\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83C\uDFC3\uD83C\uDFFE\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83C\uDFC3\uD83C\uDFFE\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFE\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFF", "\uD83C\uDFC3\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83C\uDFC3\uD83C\uDFFF\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83C\uDFC3\uD83C\uDFFF\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83C\uDFC3\uD83C\uDFFF\u200D\u27A1\uFE0F", "\uD83C\uDFC4\u200D\u2640\uFE0F", "\uD83C\uDFC4\u200D\u2642\uFE0F", "\uD83C\uDFC4\uD83C\uDFFB", "\uD83C\uDFC4\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83C\uDFC4\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83C\uDFC4\uD83C\uDFFC", "\uD83C\uDFC4\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83C\uDFC4\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83C\uDFC4\uD83C\uDFFD", "\uD83C\uDFC4\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83C\uDFC4\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83C\uDFC4\uD83C\uDFFE", "\uD83C\uDFC4\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83C\uDFC4\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83C\uDFC4\uD83C\uDFFF", "\uD83C\uDFC4\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83C\uDFC4\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83C\uDFC7\uD83C\uDFFB", "\uD83C\uDFC7\uD83C\uDFFC", "\uD83C\uDFC7\uD83C\uDFFD", "\uD83C\uDFC7\uD83C\uDFFE", "\uD83C\uDFC7\uD83C\uDFFF", "\uD83C\uDFCA\u200D\u2640\uFE0F", "\uD83C\uDFCA\u200D\u2642\uFE0F", "\uD83C\uDFCA\uD83C\uDFFB", "\uD83C\uDFCA\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83C\uDFCA\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83C\uDFCA\uD83C\uDFFC", "\uD83C\uDFCA\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83C\uDFCA\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83C\uDFCA\uD83C\uDFFD", "\uD83C\uDFCA\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83C\uDFCA\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83C\uDFCA\uD83C\uDFFE", "\uD83C\uDFCA\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83C\uDFCA\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83C\uDFCA\uD83C\uDFFF", "\uD83C\uDFCA\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83C\uDFCA\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83C\uDFCB\uD83C\uDFFB", "\uD83C\uDFCB\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83C\uDFCB\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83C\uDFCB\uD83C\uDFFC", "\uD83C\uDFCB\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83C\uDFCB\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83C\uDFCB\uD83C\uDFFD", "\uD83C\uDFCB\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83C\uDFCB\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83C\uDFCB\uD83C\uDFFE", "\uD83C\uDFCB\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83C\uDFCB\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83C\uDFCB\uD83C\uDFFF", "\uD83C\uDFCB\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83C\uDFCB\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83C\uDFCB\uFE0F", "\uD83C\uDFCB\uFE0F\u200D\u2640\uFE0F", "\uD83C\uDFCB\uFE0F\u200D\u2642\uFE0F", "\uD83C\uDFCC\uD83C\uDFFB", "\uD83C\uDFCC\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83C\uDFCC\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83C\uDFCC\uD83C\uDFFC", "\uD83C\uDFCC\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83C\uDFCC\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83C\uDFCC\uD83C\uDFFD", "\uD83C\uDFCC\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83C\uDFCC\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83C\uDFCC\uD83C\uDFFE", "\uD83C\uDFCC\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83C\uDFCC\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83C\uDFCC\uD83C\uDFFF", "\uD83C\uDFCC\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83C\uDFCC\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83C\uDFCC\uFE0F", "\uD83C\uDFCC\uFE0F\u200D\u2640\uFE0F", "\uD83C\uDFCC\uFE0F\u200D\u2642\uFE0F", "\uD83C\uDFCD\uFE0F", "\uD83C\uDFCE\uFE0F", "\uD83C\uDFD4\uFE0F", "\uD83C\uDFD5\uFE0F", "\uD83C\uDFD6\uFE0F", "\uD83C\uDFD7\uFE0F", "\uD83C\uDFD8\uFE0F", "\uD83C\uDFD9\uFE0F", "\uD83C\uDFDA\uFE0F", "\uD83C\uDFDB\uFE0F", "\uD83C\uDFDC\uFE0F", "\uD83C\uDFDD\uFE0F", "\uD83C\uDFDE\uFE0F", "\uD83C\uDFDF\uFE0F", "\uD83C\uDFF3\uFE0F", "\uD83C\uDFF3\uFE0F\u200D\u26A7\uFE0F", "\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08", "\uD83C\uDFF4\u200D\u2620\uFE0F", "\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67\uDB40\uDC7F", "\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74\uDB40\uDC7F", "\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73\uDB40\uDC7F", "\uD83C\uDFF5\uFE0F", "\uD83C\uDFF7\uFE0F", "\uD83D\uDC08\u200D\u2B1B", "\uD83D\uDC15\u200D\uD83E\uDDBA", "\uD83D\uDC26\u200D\u2B1B", "\uD83D\uDC26\u200D\uD83D\uDD25", "\uD83D\uDC3B\u200D\u2744\uFE0F", "\uD83D\uDC3F\uFE0F", "\uD83D\uDC41\uFE0F", "\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8\uFE0F", "\uD83D\uDC42\uD83C\uDFFB", "\uD83D\uDC42\uD83C\uDFFC", "\uD83D\uDC42\uD83C\uDFFD", "\uD83D\uDC42\uD83C\uDFFE", "\uD83D\uDC42\uD83C\uDFFF", "\uD83D\uDC43\uD83C\uDFFB", "\uD83D\uDC43\uD83C\uDFFC", "\uD83D\uDC43\uD83C\uDFFD", "\uD83D\uDC43\uD83C\uDFFE", "\uD83D\uDC43\uD83C\uDFFF", "\uD83D\uDC46\uD83C\uDFFB", "\uD83D\uDC46\uD83C\uDFFC", "\uD83D\uDC46\uD83C\uDFFD", "\uD83D\uDC46\uD83C\uDFFE", "\uD83D\uDC46\uD83C\uDFFF", "\uD83D\uDC47\uD83C\uDFFB", "\uD83D\uDC47\uD83C\uDFFC", "\uD83D\uDC47\uD83C\uDFFD", "\uD83D\uDC47\uD83C\uDFFE", "\uD83D\uDC47\uD83C\uDFFF", "\uD83D\uDC48\uD83C\uDFFB", "\uD83D\uDC48\uD83C\uDFFC", "\uD83D\uDC48\uD83C\uDFFD", "\uD83D\uDC48\uD83C\uDFFE", "\uD83D\uDC48\uD83C\uDFFF", "\uD83D\uDC49\uD83C\uDFFB", "\uD83D\uDC49\uD83C\uDFFC", "\uD83D\uDC49\uD83C\uDFFD", "\uD83D\uDC49\uD83C\uDFFE", "\uD83D\uDC49\uD83C\uDFFF", "\uD83D\uDC4A\uD83C\uDFFB", "\uD83D\uDC4A\uD83C\uDFFC", "\uD83D\uDC4A\uD83C\uDFFD", "\uD83D\uDC4A\uD83C\uDFFE", "\uD83D\uDC4A\uD83C\uDFFF", "\uD83D\uDC4B\uD83C\uDFFB", "\uD83D\uDC4B\uD83C\uDFFC", "\uD83D\uDC4B\uD83C\uDFFD", "\uD83D\uDC4B\uD83C\uDFFE", "\uD83D\uDC4B\uD83C\uDFFF", "\uD83D\uDC4C\uD83C\uDFFB", "\uD83D\uDC4C\uD83C\uDFFC", "\uD83D\uDC4C\uD83C\uDFFD", "\uD83D\uDC4C\uD83C\uDFFE", "\uD83D\uDC4C\uD83C\uDFFF", "\uD83D\uDC4D\uD83C\uDFFB", "\uD83D\uDC4D\uD83C\uDFFC", "\uD83D\uDC4D\uD83C\uDFFD", "\uD83D\uDC4D\uD83C\uDFFE", "\uD83D\uDC4D\uD83C\uDFFF", "\uD83D\uDC4E\uD83C\uDFFB", "\uD83D\uDC4E\uD83C\uDFFC", "\uD83D\uDC4E\uD83C\uDFFD", "\uD83D\uDC4E\uD83C\uDFFE", "\uD83D\uDC4E\uD83C\uDFFF", "\uD83D\uDC4F\uD83C\uDFFB", "\uD83D\uDC4F\uD83C\uDFFC", "\uD83D\uDC4F\uD83C\uDFFD", "\uD83D\uDC4F\uD83C\uDFFE", "\uD83D\uDC4F\uD83C\uDFFF", "\uD83D\uDC50\uD83C\uDFFB", "\uD83D\uDC50\uD83C\uDFFC", "\uD83D\uDC50\uD83C\uDFFD", "\uD83D\uDC50\uD83C\uDFFE", "\uD83D\uDC50\uD83C\uDFFF", "\uD83D\uDC66\uD83C\uDFFB", "\uD83D\uDC66\uD83C\uDFFC", "\uD83D\uDC66\uD83C\uDFFD", "\uD83D\uDC66\uD83C\uDFFE", "\uD83D\uDC66\uD83C\uDFFF", "\uD83D\uDC67\uD83C\uDFFB", "\uD83D\uDC67\uD83C\uDFFC", "\uD83D\uDC67\uD83C\uDFFD", "\uD83D\uDC67\uD83C\uDFFE", "\uD83D\uDC67\uD83C\uDFFF", "\uD83D\uDC68\u200D\u2695\uFE0F", "\uD83D\uDC68\u200D\u2696\uFE0F", "\uD83D\uDC68\u200D\u2708\uFE0F", "\uD83D\uDC68\u200D\u2764\uFE0F\u200D\uD83D\uDC68", "\uD83D\uDC68\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68", "\uD83D\uDC68\u200D\uD83C\uDF3E", "\uD83D\uDC68\u200D\uD83C\uDF73", "\uD83D\uDC68\u200D\uD83C\uDF7C", "\uD83D\uDC68\u200D\uD83C\uDF93", "\uD83D\uDC68\u200D\uD83C\uDFA4", "\uD83D\uDC68\u200D\uD83C\uDFA8", "\uD83D\uDC68\u200D\uD83C\uDFEB", "\uD83D\uDC68\u200D\uD83C\uDFED", "\uD83D\uDC68\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC66\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC67", "\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC67", "\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC66\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC67", "\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC67", "\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67", "\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66", "\uD83D\uDC68\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC67", "\uD83D\uDC68\u200D\uD83D\uDCBB", "\uD83D\uDC68\u200D\uD83D\uDCBC", "\uD83D\uDC68\u200D\uD83D\uDD27", "\uD83D\uDC68\u200D\uD83D\uDD2C", "\uD83D\uDC68\u200D\uD83D\uDE80", "\uD83D\uDC68\u200D\uD83D\uDE92", "\uD83D\uDC68\u200D\uD83E\uDDAF", "\uD83D\uDC68\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\u200D\uD83E\uDDB0", "\uD83D\uDC68\u200D\uD83E\uDDB1", "\uD83D\uDC68\u200D\uD83E\uDDB2", "\uD83D\uDC68\u200D\uD83E\uDDB3", "\uD83D\uDC68\u200D\uD83E\uDDBC", "\uD83D\uDC68\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\u200D\uD83E\uDDBD", "\uD83D\uDC68\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2695\uFE0F", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2696\uFE0F", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2708\uFE0F", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDF3E", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDF73", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDF7C", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDF93", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFA4", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFA8", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFEB", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83C\uDFED", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDCBB", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDCBC", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDD27", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDD2C", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDE80", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83D\uDE92", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDAF", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDB0", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDB1", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDB2", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDB3", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDBC", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDBD", "\uD83D\uDC68\uD83C\uDFFB\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2695\uFE0F", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2696\uFE0F", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2708\uFE0F", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDF3E", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDF73", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDF7C", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDF93", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFA4", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFA8", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFEB", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83C\uDFED", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDCBB", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDCBC", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDD27", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDD2C", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDE80", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83D\uDE92", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDAF", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDB0", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDB1", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDB2", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDB3", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDBC", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDBD", "\uD83D\uDC68\uD83C\uDFFC\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2695\uFE0F", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2696\uFE0F", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2708\uFE0F", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDF3E", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDF73", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDF7C", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDF93", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFA4", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFA8", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFEB", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83C\uDFED", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDCBB", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDCBC", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDD27", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDD2C", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDE80", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83D\uDE92", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDAF", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDB0", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDB1", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDB2", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDB3", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDBC", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDBD", "\uD83D\uDC68\uD83C\uDFFD\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2695\uFE0F", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2696\uFE0F", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2708\uFE0F", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDF3E", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDF73", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDF7C", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDF93", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFA4", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFA8", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFEB", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83C\uDFED", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDCBB", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDCBC", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDD27", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDD2C", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDE80", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83D\uDE92", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDAF", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDB0", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDB1", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDB2", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDB3", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDBC", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDBD", "\uD83D\uDC68\uD83C\uDFFE\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2695\uFE0F", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2696\uFE0F", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2708\uFE0F", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDF3E", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDF73", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDF7C", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDF93", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFA4", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFA8", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFEB", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83C\uDFED", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDCBB", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDCBC", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDD27", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDD2C", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDE80", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83D\uDE92", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDAF", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDB0", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDB1", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDB2", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDB3", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDBC", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDBD", "\uD83D\uDC68\uD83C\uDFFF\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\u200D\u2695\uFE0F", "\uD83D\uDC69\u200D\u2696\uFE0F", "\uD83D\uDC69\u200D\u2708\uFE0F", "\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC68", "\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC69", "\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68", "\uD83D\uDC69\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69", "\uD83D\uDC69\u200D\uD83C\uDF3E", "\uD83D\uDC69\u200D\uD83C\uDF73", "\uD83D\uDC69\u200D\uD83C\uDF7C", "\uD83D\uDC69\u200D\uD83C\uDF93", "\uD83D\uDC69\u200D\uD83C\uDFA4", "\uD83D\uDC69\u200D\uD83C\uDFA8", "\uD83D\uDC69\u200D\uD83C\uDFEB", "\uD83D\uDC69\u200D\uD83C\uDFED", "\uD83D\uDC69\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC67", "\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC67", "\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC67", "\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC66", "\uD83D\uDC69\u200D\uD83D\uDC69\u200D\uD83D\uDC67\u200D\uD83D\uDC67", "\uD83D\uDC69\u200D\uD83D\uDCBB", "\uD83D\uDC69\u200D\uD83D\uDCBC", "\uD83D\uDC69\u200D\uD83D\uDD27", "\uD83D\uDC69\u200D\uD83D\uDD2C", "\uD83D\uDC69\u200D\uD83D\uDE80", "\uD83D\uDC69\u200D\uD83D\uDE92", "\uD83D\uDC69\u200D\uD83E\uDDAF", "\uD83D\uDC69\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\u200D\uD83E\uDDB0", "\uD83D\uDC69\u200D\uD83E\uDDB1", "\uD83D\uDC69\u200D\uD83E\uDDB2", "\uD83D\uDC69\u200D\uD83E\uDDB3", "\uD83D\uDC69\u200D\uD83E\uDDBC", "\uD83D\uDC69\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\u200D\uD83E\uDDBD", "\uD83D\uDC69\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2695\uFE0F", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2696\uFE0F", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2708\uFE0F", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDF3E", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDF73", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDF7C", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDF93", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFA4", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFA8", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFEB", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83C\uDFED", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDCBB", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDCBC", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDD27", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDD2C", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDE80", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83D\uDE92", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDAF", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDB0", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDB1", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDB2", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDB3", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDBC", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDBD", "\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2695\uFE0F", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2696\uFE0F", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2708\uFE0F", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDF3E", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDF73", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDF7C", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDF93", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFA4", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFA8", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFEB", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83C\uDFED", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDCBB", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDCBC", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDD27", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDD2C", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDE80", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83D\uDE92", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDAF", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDB0", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDB1", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDB2", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDB3", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDBC", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDBD", "\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2695\uFE0F", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2696\uFE0F", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2708\uFE0F", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDF3E", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDF73", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDF7C", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDF93", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFA4", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFA8", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFEB", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83C\uDFED", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDCBB", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDCBC", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDD27", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDD2C", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDE80", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83D\uDE92", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDAF", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDB0", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDB1", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDB2", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDB3", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDBC", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDBD", "\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2695\uFE0F", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2696\uFE0F", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2708\uFE0F", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDF3E", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDF73", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDF7C", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDF93", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFA4", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFA8", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFEB", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83C\uDFED", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDCBB", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDCBC", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDD27", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDD2C", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDE80", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83D\uDE92", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDAF", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDB0", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDB1", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDB2", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDB3", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDBC", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDBD", "\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2695\uFE0F", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2696\uFE0F", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2708\uFE0F", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC68\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83D\uDC69\uD83C\uDFFF", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDF3E", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDF73", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDF7C", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDF93", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFA4", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFA8", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFEB", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83C\uDFED", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDCBB", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDCBC", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDD27", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDD2C", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDE80", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83D\uDE92", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFB", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFC", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFD", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83D\uDC69\uD83C\uDFFE", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDAF", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDB0", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDB1", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDB2", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDB3", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDBC", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDBD", "\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83D\uDC6B\uD83C\uDFFB", "\uD83D\uDC6B\uD83C\uDFFC", "\uD83D\uDC6B\uD83C\uDFFD", "\uD83D\uDC6B\uD83C\uDFFE", "\uD83D\uDC6B\uD83C\uDFFF", "\uD83D\uDC6C\uD83C\uDFFB", "\uD83D\uDC6C\uD83C\uDFFC", "\uD83D\uDC6C\uD83C\uDFFD", "\uD83D\uDC6C\uD83C\uDFFE", "\uD83D\uDC6C\uD83C\uDFFF", "\uD83D\uDC6D\uD83C\uDFFB", "\uD83D\uDC6D\uD83C\uDFFC", "\uD83D\uDC6D\uD83C\uDFFD", "\uD83D\uDC6D\uD83C\uDFFE", "\uD83D\uDC6D\uD83C\uDFFF", "\uD83D\uDC6E\u200D\u2640\uFE0F", "\uD83D\uDC6E\u200D\u2642\uFE0F", "\uD83D\uDC6E\uD83C\uDFFB", "\uD83D\uDC6E\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC6E\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC6E\uD83C\uDFFC", "\uD83D\uDC6E\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC6E\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC6E\uD83C\uDFFD", "\uD83D\uDC6E\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC6E\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC6E\uD83C\uDFFE", "\uD83D\uDC6E\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC6E\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC6E\uD83C\uDFFF", "\uD83D\uDC6E\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC6E\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC6F\u200D\u2640\uFE0F", "\uD83D\uDC6F\u200D\u2642\uFE0F", "\uD83D\uDC70\u200D\u2640\uFE0F", "\uD83D\uDC70\u200D\u2642\uFE0F", "\uD83D\uDC70\uD83C\uDFFB", "\uD83D\uDC70\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC70\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC70\uD83C\uDFFC", "\uD83D\uDC70\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC70\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC70\uD83C\uDFFD", "\uD83D\uDC70\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC70\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC70\uD83C\uDFFE", "\uD83D\uDC70\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC70\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC70\uD83C\uDFFF", "\uD83D\uDC70\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC70\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC71\u200D\u2640\uFE0F", "\uD83D\uDC71\u200D\u2642\uFE0F", "\uD83D\uDC71\uD83C\uDFFB", "\uD83D\uDC71\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC71\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC71\uD83C\uDFFC", "\uD83D\uDC71\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC71\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC71\uD83C\uDFFD", "\uD83D\uDC71\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC71\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC71\uD83C\uDFFE", "\uD83D\uDC71\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC71\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC71\uD83C\uDFFF", "\uD83D\uDC71\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC71\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC72\uD83C\uDFFB", "\uD83D\uDC72\uD83C\uDFFC", "\uD83D\uDC72\uD83C\uDFFD", "\uD83D\uDC72\uD83C\uDFFE", "\uD83D\uDC72\uD83C\uDFFF", "\uD83D\uDC73\u200D\u2640\uFE0F", "\uD83D\uDC73\u200D\u2642\uFE0F", "\uD83D\uDC73\uD83C\uDFFB", "\uD83D\uDC73\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC73\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC73\uD83C\uDFFC", "\uD83D\uDC73\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC73\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC73\uD83C\uDFFD", "\uD83D\uDC73\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC73\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC73\uD83C\uDFFE", "\uD83D\uDC73\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC73\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC73\uD83C\uDFFF", "\uD83D\uDC73\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC73\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC74\uD83C\uDFFB", "\uD83D\uDC74\uD83C\uDFFC", "\uD83D\uDC74\uD83C\uDFFD", "\uD83D\uDC74\uD83C\uDFFE", "\uD83D\uDC74\uD83C\uDFFF", "\uD83D\uDC75\uD83C\uDFFB", "\uD83D\uDC75\uD83C\uDFFC", "\uD83D\uDC75\uD83C\uDFFD", "\uD83D\uDC75\uD83C\uDFFE", "\uD83D\uDC75\uD83C\uDFFF", "\uD83D\uDC76\uD83C\uDFFB", "\uD83D\uDC76\uD83C\uDFFC", "\uD83D\uDC76\uD83C\uDFFD", "\uD83D\uDC76\uD83C\uDFFE", "\uD83D\uDC76\uD83C\uDFFF", "\uD83D\uDC77\u200D\u2640\uFE0F", "\uD83D\uDC77\u200D\u2642\uFE0F", "\uD83D\uDC77\uD83C\uDFFB", "\uD83D\uDC77\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC77\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC77\uD83C\uDFFC", "\uD83D\uDC77\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC77\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC77\uD83C\uDFFD", "\uD83D\uDC77\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC77\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC77\uD83C\uDFFE", "\uD83D\uDC77\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC77\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC77\uD83C\uDFFF", "\uD83D\uDC77\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC77\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC78\uD83C\uDFFB", "\uD83D\uDC78\uD83C\uDFFC", "\uD83D\uDC78\uD83C\uDFFD", "\uD83D\uDC78\uD83C\uDFFE", "\uD83D\uDC78\uD83C\uDFFF", "\uD83D\uDC7C\uD83C\uDFFB", "\uD83D\uDC7C\uD83C\uDFFC", "\uD83D\uDC7C\uD83C\uDFFD", "\uD83D\uDC7C\uD83C\uDFFE", "\uD83D\uDC7C\uD83C\uDFFF", "\uD83D\uDC81\u200D\u2640\uFE0F", "\uD83D\uDC81\u200D\u2642\uFE0F", "\uD83D\uDC81\uD83C\uDFFB", "\uD83D\uDC81\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC81\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC81\uD83C\uDFFC", "\uD83D\uDC81\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC81\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC81\uD83C\uDFFD", "\uD83D\uDC81\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC81\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC81\uD83C\uDFFE", "\uD83D\uDC81\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC81\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC81\uD83C\uDFFF", "\uD83D\uDC81\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC81\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC82\u200D\u2640\uFE0F", "\uD83D\uDC82\u200D\u2642\uFE0F", "\uD83D\uDC82\uD83C\uDFFB", "\uD83D\uDC82\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC82\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC82\uD83C\uDFFC", "\uD83D\uDC82\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC82\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC82\uD83C\uDFFD", "\uD83D\uDC82\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC82\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC82\uD83C\uDFFE", "\uD83D\uDC82\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC82\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC82\uD83C\uDFFF", "\uD83D\uDC82\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC82\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC83\uD83C\uDFFB", "\uD83D\uDC83\uD83C\uDFFC", "\uD83D\uDC83\uD83C\uDFFD", "\uD83D\uDC83\uD83C\uDFFE", "\uD83D\uDC83\uD83C\uDFFF", "\uD83D\uDC85\uD83C\uDFFB", "\uD83D\uDC85\uD83C\uDFFC", "\uD83D\uDC85\uD83C\uDFFD", "\uD83D\uDC85\uD83C\uDFFE", "\uD83D\uDC85\uD83C\uDFFF", "\uD83D\uDC86\u200D\u2640\uFE0F", "\uD83D\uDC86\u200D\u2642\uFE0F", "\uD83D\uDC86\uD83C\uDFFB", "\uD83D\uDC86\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC86\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC86\uD83C\uDFFC", "\uD83D\uDC86\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC86\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC86\uD83C\uDFFD", "\uD83D\uDC86\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC86\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC86\uD83C\uDFFE", "\uD83D\uDC86\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC86\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC86\uD83C\uDFFF", "\uD83D\uDC86\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC86\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC87\u200D\u2640\uFE0F", "\uD83D\uDC87\u200D\u2642\uFE0F", "\uD83D\uDC87\uD83C\uDFFB", "\uD83D\uDC87\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDC87\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDC87\uD83C\uDFFC", "\uD83D\uDC87\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDC87\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDC87\uD83C\uDFFD", "\uD83D\uDC87\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDC87\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDC87\uD83C\uDFFE", "\uD83D\uDC87\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDC87\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDC87\uD83C\uDFFF", "\uD83D\uDC87\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDC87\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDC8F\uD83C\uDFFB", "\uD83D\uDC8F\uD83C\uDFFC", "\uD83D\uDC8F\uD83C\uDFFD", "\uD83D\uDC8F\uD83C\uDFFE", "\uD83D\uDC8F\uD83C\uDFFF", "\uD83D\uDC91\uD83C\uDFFB", "\uD83D\uDC91\uD83C\uDFFC", "\uD83D\uDC91\uD83C\uDFFD", "\uD83D\uDC91\uD83C\uDFFE", "\uD83D\uDC91\uD83C\uDFFF", "\uD83D\uDCAA\uD83C\uDFFB", "\uD83D\uDCAA\uD83C\uDFFC", "\uD83D\uDCAA\uD83C\uDFFD", "\uD83D\uDCAA\uD83C\uDFFE", "\uD83D\uDCAA\uD83C\uDFFF", "\uD83D\uDCFD\uFE0F", "\uD83D\uDD49\uFE0F", "\uD83D\uDD4A\uFE0F", "\uD83D\uDD6F\uFE0F", "\uD83D\uDD70\uFE0F", "\uD83D\uDD73\uFE0F", "\uD83D\uDD74\uD83C\uDFFB", "\uD83D\uDD74\uD83C\uDFFC", "\uD83D\uDD74\uD83C\uDFFD", "\uD83D\uDD74\uD83C\uDFFE", "\uD83D\uDD74\uD83C\uDFFF", "\uD83D\uDD74\uFE0F", "\uD83D\uDD75\uD83C\uDFFB", "\uD83D\uDD75\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDD75\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDD75\uD83C\uDFFC", "\uD83D\uDD75\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDD75\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDD75\uD83C\uDFFD", "\uD83D\uDD75\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDD75\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDD75\uD83C\uDFFE", "\uD83D\uDD75\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDD75\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDD75\uD83C\uDFFF", "\uD83D\uDD75\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDD75\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDD75\uFE0F", "\uD83D\uDD75\uFE0F\u200D\u2640\uFE0F", "\uD83D\uDD75\uFE0F\u200D\u2642\uFE0F", "\uD83D\uDD76\uFE0F", "\uD83D\uDD77\uFE0F", "\uD83D\uDD78\uFE0F", "\uD83D\uDD79\uFE0F", "\uD83D\uDD7A\uD83C\uDFFB", "\uD83D\uDD7A\uD83C\uDFFC", "\uD83D\uDD7A\uD83C\uDFFD", "\uD83D\uDD7A\uD83C\uDFFE", "\uD83D\uDD7A\uD83C\uDFFF", "\uD83D\uDD87\uFE0F", "\uD83D\uDD8A\uFE0F", "\uD83D\uDD8B\uFE0F", "\uD83D\uDD8C\uFE0F", "\uD83D\uDD8D\uFE0F", "\uD83D\uDD90\uD83C\uDFFB", "\uD83D\uDD90\uD83C\uDFFC", "\uD83D\uDD90\uD83C\uDFFD", "\uD83D\uDD90\uD83C\uDFFE", "\uD83D\uDD90\uD83C\uDFFF", "\uD83D\uDD90\uFE0F", "\uD83D\uDD95\uD83C\uDFFB", "\uD83D\uDD95\uD83C\uDFFC", "\uD83D\uDD95\uD83C\uDFFD", "\uD83D\uDD95\uD83C\uDFFE", "\uD83D\uDD95\uD83C\uDFFF", "\uD83D\uDD96\uD83C\uDFFB", "\uD83D\uDD96\uD83C\uDFFC", "\uD83D\uDD96\uD83C\uDFFD", "\uD83D\uDD96\uD83C\uDFFE", "\uD83D\uDD96\uD83C\uDFFF", "\uD83D\uDDA5\uFE0F", "\uD83D\uDDA8\uFE0F", "\uD83D\uDDB1\uFE0F", "\uD83D\uDDB2\uFE0F", "\uD83D\uDDBC\uFE0F", "\uD83D\uDDC2\uFE0F", "\uD83D\uDDC3\uFE0F", "\uD83D\uDDC4\uFE0F", "\uD83D\uDDD1\uFE0F", "\uD83D\uDDD2\uFE0F", "\uD83D\uDDD3\uFE0F", "\uD83D\uDDDC\uFE0F", "\uD83D\uDDDD\uFE0F", "\uD83D\uDDDE\uFE0F", "\uD83D\uDDE1\uFE0F", "\uD83D\uDDE3\uFE0F", "\uD83D\uDDE8\uFE0F", "\uD83D\uDDEF\uFE0F", "\uD83D\uDDF3\uFE0F", "\uD83D\uDDFA\uFE0F", "\uD83D\uDE2E\u200D\uD83D\uDCA8", "\uD83D\uDE35\u200D\uD83D\uDCAB", "\uD83D\uDE36\u200D\uD83C\uDF2B\uFE0F", "\uD83D\uDE42\u200D\u2194\uFE0F", "\uD83D\uDE42\u200D\u2195\uFE0F", "\uD83D\uDE45\u200D\u2640\uFE0F", "\uD83D\uDE45\u200D\u2642\uFE0F", "\uD83D\uDE45\uD83C\uDFFB", "\uD83D\uDE45\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE45\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE45\uD83C\uDFFC", "\uD83D\uDE45\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE45\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE45\uD83C\uDFFD", "\uD83D\uDE45\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE45\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE45\uD83C\uDFFE", "\uD83D\uDE45\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE45\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE45\uD83C\uDFFF", "\uD83D\uDE45\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE45\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDE46\u200D\u2640\uFE0F", "\uD83D\uDE46\u200D\u2642\uFE0F", "\uD83D\uDE46\uD83C\uDFFB", "\uD83D\uDE46\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE46\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE46\uD83C\uDFFC", "\uD83D\uDE46\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE46\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE46\uD83C\uDFFD", "\uD83D\uDE46\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE46\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE46\uD83C\uDFFE", "\uD83D\uDE46\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE46\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE46\uD83C\uDFFF", "\uD83D\uDE46\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE46\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDE47\u200D\u2640\uFE0F", "\uD83D\uDE47\u200D\u2642\uFE0F", "\uD83D\uDE47\uD83C\uDFFB", "\uD83D\uDE47\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE47\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE47\uD83C\uDFFC", "\uD83D\uDE47\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE47\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE47\uD83C\uDFFD", "\uD83D\uDE47\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE47\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE47\uD83C\uDFFE", "\uD83D\uDE47\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE47\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE47\uD83C\uDFFF", "\uD83D\uDE47\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE47\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDE4B\u200D\u2640\uFE0F", "\uD83D\uDE4B\u200D\u2642\uFE0F", "\uD83D\uDE4B\uD83C\uDFFB", "\uD83D\uDE4B\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE4B\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE4B\uD83C\uDFFC", "\uD83D\uDE4B\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE4B\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE4B\uD83C\uDFFD", "\uD83D\uDE4B\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE4B\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE4B\uD83C\uDFFE", "\uD83D\uDE4B\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE4B\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE4B\uD83C\uDFFF", "\uD83D\uDE4B\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE4B\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDE4C\uD83C\uDFFB", "\uD83D\uDE4C\uD83C\uDFFC", "\uD83D\uDE4C\uD83C\uDFFD", "\uD83D\uDE4C\uD83C\uDFFE", "\uD83D\uDE4C\uD83C\uDFFF", "\uD83D\uDE4D\u200D\u2640\uFE0F", "\uD83D\uDE4D\u200D\u2642\uFE0F", "\uD83D\uDE4D\uD83C\uDFFB", "\uD83D\uDE4D\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE4D\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE4D\uD83C\uDFFC", "\uD83D\uDE4D\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE4D\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE4D\uD83C\uDFFD", "\uD83D\uDE4D\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE4D\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE4D\uD83C\uDFFE", "\uD83D\uDE4D\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE4D\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE4D\uD83C\uDFFF", "\uD83D\uDE4D\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE4D\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDE4E\u200D\u2640\uFE0F", "\uD83D\uDE4E\u200D\u2642\uFE0F", "\uD83D\uDE4E\uD83C\uDFFB", "\uD83D\uDE4E\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDE4E\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDE4E\uD83C\uDFFC", "\uD83D\uDE4E\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDE4E\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDE4E\uD83C\uDFFD", "\uD83D\uDE4E\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDE4E\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDE4E\uD83C\uDFFE", "\uD83D\uDE4E\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDE4E\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDE4E\uD83C\uDFFF", "\uD83D\uDE4E\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDE4E\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDE4F\uD83C\uDFFB", "\uD83D\uDE4F\uD83C\uDFFC", "\uD83D\uDE4F\uD83C\uDFFD", "\uD83D\uDE4F\uD83C\uDFFE", "\uD83D\uDE4F\uD83C\uDFFF", "\uD83D\uDEA3\u200D\u2640\uFE0F", "\uD83D\uDEA3\u200D\u2642\uFE0F", "\uD83D\uDEA3\uD83C\uDFFB", "\uD83D\uDEA3\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDEA3\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDEA3\uD83C\uDFFC", "\uD83D\uDEA3\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDEA3\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDEA3\uD83C\uDFFD", "\uD83D\uDEA3\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDEA3\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDEA3\uD83C\uDFFE", "\uD83D\uDEA3\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDEA3\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDEA3\uD83C\uDFFF", "\uD83D\uDEA3\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDEA3\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDEB4\u200D\u2640\uFE0F", "\uD83D\uDEB4\u200D\u2642\uFE0F", "\uD83D\uDEB4\uD83C\uDFFB", "\uD83D\uDEB4\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDEB4\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDEB4\uD83C\uDFFC", "\uD83D\uDEB4\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDEB4\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDEB4\uD83C\uDFFD", "\uD83D\uDEB4\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDEB4\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDEB4\uD83C\uDFFE", "\uD83D\uDEB4\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDEB4\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDEB4\uD83C\uDFFF", "\uD83D\uDEB4\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDEB4\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDEB5\u200D\u2640\uFE0F", "\uD83D\uDEB5\u200D\u2642\uFE0F", "\uD83D\uDEB5\uD83C\uDFFB", "\uD83D\uDEB5\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDEB5\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDEB5\uD83C\uDFFC", "\uD83D\uDEB5\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDEB5\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDEB5\uD83C\uDFFD", "\uD83D\uDEB5\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDEB5\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDEB5\uD83C\uDFFE", "\uD83D\uDEB5\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDEB5\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDEB5\uD83C\uDFFF", "\uD83D\uDEB5\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDEB5\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDEB6\u200D\u2640\uFE0F", "\uD83D\uDEB6\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\u200D\u2642\uFE0F", "\uD83D\uDEB6\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFB", "\uD83D\uDEB6\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83D\uDEB6\uD83C\uDFFB\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83D\uDEB6\uD83C\uDFFB\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFB\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFC", "\uD83D\uDEB6\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83D\uDEB6\uD83C\uDFFC\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83D\uDEB6\uD83C\uDFFC\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFC\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFD", "\uD83D\uDEB6\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83D\uDEB6\uD83C\uDFFD\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83D\uDEB6\uD83C\uDFFD\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFD\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFE", "\uD83D\uDEB6\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83D\uDEB6\uD83C\uDFFE\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83D\uDEB6\uD83C\uDFFE\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFE\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFF", "\uD83D\uDEB6\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83D\uDEB6\uD83C\uDFFF\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83D\uDEB6\uD83C\uDFFF\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83D\uDEB6\uD83C\uDFFF\u200D\u27A1\uFE0F", "\uD83D\uDEC0\uD83C\uDFFB", "\uD83D\uDEC0\uD83C\uDFFC", "\uD83D\uDEC0\uD83C\uDFFD", "\uD83D\uDEC0\uD83C\uDFFE", "\uD83D\uDEC0\uD83C\uDFFF", "\uD83D\uDECB\uFE0F", "\uD83D\uDECC\uD83C\uDFFB", "\uD83D\uDECC\uD83C\uDFFC", "\uD83D\uDECC\uD83C\uDFFD", "\uD83D\uDECC\uD83C\uDFFE", "\uD83D\uDECC\uD83C\uDFFF", "\uD83D\uDECD\uFE0F", "\uD83D\uDECE\uFE0F", "\uD83D\uDECF\uFE0F", "\uD83D\uDEE0\uFE0F", "\uD83D\uDEE1\uFE0F", "\uD83D\uDEE2\uFE0F", "\uD83D\uDEE3\uFE0F", "\uD83D\uDEE4\uFE0F", "\uD83D\uDEE5\uFE0F", "\uD83D\uDEE9\uFE0F", "\uD83D\uDEF0\uFE0F", "\uD83D\uDEF3\uFE0F", "\uD83E\uDD0C\uD83C\uDFFB", "\uD83E\uDD0C\uD83C\uDFFC", "\uD83E\uDD0C\uD83C\uDFFD", "\uD83E\uDD0C\uD83C\uDFFE", "\uD83E\uDD0C\uD83C\uDFFF", "\uD83E\uDD0F\uD83C\uDFFB", "\uD83E\uDD0F\uD83C\uDFFC", "\uD83E\uDD0F\uD83C\uDFFD", "\uD83E\uDD0F\uD83C\uDFFE", "\uD83E\uDD0F\uD83C\uDFFF", "\uD83E\uDD18\uD83C\uDFFB", "\uD83E\uDD18\uD83C\uDFFC", "\uD83E\uDD18\uD83C\uDFFD", "\uD83E\uDD18\uD83C\uDFFE", "\uD83E\uDD18\uD83C\uDFFF", "\uD83E\uDD19\uD83C\uDFFB", "\uD83E\uDD19\uD83C\uDFFC", "\uD83E\uDD19\uD83C\uDFFD", "\uD83E\uDD19\uD83C\uDFFE", "\uD83E\uDD19\uD83C\uDFFF", "\uD83E\uDD1A\uD83C\uDFFB", "\uD83E\uDD1A\uD83C\uDFFC", "\uD83E\uDD1A\uD83C\uDFFD", "\uD83E\uDD1A\uD83C\uDFFE", "\uD83E\uDD1A\uD83C\uDFFF", "\uD83E\uDD1B\uD83C\uDFFB", "\uD83E\uDD1B\uD83C\uDFFC", "\uD83E\uDD1B\uD83C\uDFFD", "\uD83E\uDD1B\uD83C\uDFFE", "\uD83E\uDD1B\uD83C\uDFFF", "\uD83E\uDD1C\uD83C\uDFFB", "\uD83E\uDD1C\uD83C\uDFFC", "\uD83E\uDD1C\uD83C\uDFFD", "\uD83E\uDD1C\uD83C\uDFFE", "\uD83E\uDD1C\uD83C\uDFFF", "\uD83E\uDD1D\uD83C\uDFFB", "\uD83E\uDD1D\uD83C\uDFFC", "\uD83E\uDD1D\uD83C\uDFFD", "\uD83E\uDD1D\uD83C\uDFFE", "\uD83E\uDD1D\uD83C\uDFFF", "\uD83E\uDD1E\uD83C\uDFFB", "\uD83E\uDD1E\uD83C\uDFFC", "\uD83E\uDD1E\uD83C\uDFFD", "\uD83E\uDD1E\uD83C\uDFFE", "\uD83E\uDD1E\uD83C\uDFFF", "\uD83E\uDD1F\uD83C\uDFFB", "\uD83E\uDD1F\uD83C\uDFFC", "\uD83E\uDD1F\uD83C\uDFFD", "\uD83E\uDD1F\uD83C\uDFFE", "\uD83E\uDD1F\uD83C\uDFFF", "\uD83E\uDD26\u200D\u2640\uFE0F", "\uD83E\uDD26\u200D\u2642\uFE0F", "\uD83E\uDD26\uD83C\uDFFB", "\uD83E\uDD26\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD26\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD26\uD83C\uDFFC", "\uD83E\uDD26\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD26\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD26\uD83C\uDFFD", "\uD83E\uDD26\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD26\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD26\uD83C\uDFFE", "\uD83E\uDD26\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD26\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD26\uD83C\uDFFF", "\uD83E\uDD26\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD26\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD30\uD83C\uDFFB", "\uD83E\uDD30\uD83C\uDFFC", "\uD83E\uDD30\uD83C\uDFFD", "\uD83E\uDD30\uD83C\uDFFE", "\uD83E\uDD30\uD83C\uDFFF", "\uD83E\uDD31\uD83C\uDFFB", "\uD83E\uDD31\uD83C\uDFFC", "\uD83E\uDD31\uD83C\uDFFD", "\uD83E\uDD31\uD83C\uDFFE", "\uD83E\uDD31\uD83C\uDFFF", "\uD83E\uDD32\uD83C\uDFFB", "\uD83E\uDD32\uD83C\uDFFC", "\uD83E\uDD32\uD83C\uDFFD", "\uD83E\uDD32\uD83C\uDFFE", "\uD83E\uDD32\uD83C\uDFFF", "\uD83E\uDD33\uD83C\uDFFB", "\uD83E\uDD33\uD83C\uDFFC", "\uD83E\uDD33\uD83C\uDFFD", "\uD83E\uDD33\uD83C\uDFFE", "\uD83E\uDD33\uD83C\uDFFF", "\uD83E\uDD34\uD83C\uDFFB", "\uD83E\uDD34\uD83C\uDFFC", "\uD83E\uDD34\uD83C\uDFFD", "\uD83E\uDD34\uD83C\uDFFE", "\uD83E\uDD34\uD83C\uDFFF", "\uD83E\uDD35\u200D\u2640\uFE0F", "\uD83E\uDD35\u200D\u2642\uFE0F", "\uD83E\uDD35\uD83C\uDFFB", "\uD83E\uDD35\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD35\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD35\uD83C\uDFFC", "\uD83E\uDD35\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD35\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD35\uD83C\uDFFD", "\uD83E\uDD35\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD35\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD35\uD83C\uDFFE", "\uD83E\uDD35\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD35\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD35\uD83C\uDFFF", "\uD83E\uDD35\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD35\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD36\uD83C\uDFFB", "\uD83E\uDD36\uD83C\uDFFC", "\uD83E\uDD36\uD83C\uDFFD", "\uD83E\uDD36\uD83C\uDFFE", "\uD83E\uDD36\uD83C\uDFFF", "\uD83E\uDD37\u200D\u2640\uFE0F", "\uD83E\uDD37\u200D\u2642\uFE0F", "\uD83E\uDD37\uD83C\uDFFB", "\uD83E\uDD37\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD37\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD37\uD83C\uDFFC", "\uD83E\uDD37\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD37\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD37\uD83C\uDFFD", "\uD83E\uDD37\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD37\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD37\uD83C\uDFFE", "\uD83E\uDD37\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD37\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD37\uD83C\uDFFF", "\uD83E\uDD37\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD37\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD38\u200D\u2640\uFE0F", "\uD83E\uDD38\u200D\u2642\uFE0F", "\uD83E\uDD38\uD83C\uDFFB", "\uD83E\uDD38\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD38\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD38\uD83C\uDFFC", "\uD83E\uDD38\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD38\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD38\uD83C\uDFFD", "\uD83E\uDD38\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD38\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD38\uD83C\uDFFE", "\uD83E\uDD38\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD38\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD38\uD83C\uDFFF", "\uD83E\uDD38\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD38\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD39\u200D\u2640\uFE0F", "\uD83E\uDD39\u200D\u2642\uFE0F", "\uD83E\uDD39\uD83C\uDFFB", "\uD83E\uDD39\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD39\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD39\uD83C\uDFFC", "\uD83E\uDD39\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD39\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD39\uD83C\uDFFD", "\uD83E\uDD39\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD39\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD39\uD83C\uDFFE", "\uD83E\uDD39\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD39\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD39\uD83C\uDFFF", "\uD83E\uDD39\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD39\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD3C\u200D\u2640\uFE0F", "\uD83E\uDD3C\u200D\u2642\uFE0F", "\uD83E\uDD3D\u200D\u2640\uFE0F", "\uD83E\uDD3D\u200D\u2642\uFE0F", "\uD83E\uDD3D\uD83C\uDFFB", "\uD83E\uDD3D\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD3D\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD3D\uD83C\uDFFC", "\uD83E\uDD3D\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD3D\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD3D\uD83C\uDFFD", "\uD83E\uDD3D\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD3D\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD3D\uD83C\uDFFE", "\uD83E\uDD3D\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD3D\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD3D\uD83C\uDFFF", "\uD83E\uDD3D\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD3D\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD3E\u200D\u2640\uFE0F", "\uD83E\uDD3E\u200D\u2642\uFE0F", "\uD83E\uDD3E\uD83C\uDFFB", "\uD83E\uDD3E\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDD3E\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDD3E\uD83C\uDFFC", "\uD83E\uDD3E\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDD3E\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDD3E\uD83C\uDFFD", "\uD83E\uDD3E\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDD3E\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDD3E\uD83C\uDFFE", "\uD83E\uDD3E\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDD3E\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDD3E\uD83C\uDFFF", "\uD83E\uDD3E\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDD3E\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDD77\uD83C\uDFFB", "\uD83E\uDD77\uD83C\uDFFC", "\uD83E\uDD77\uD83C\uDFFD", "\uD83E\uDD77\uD83C\uDFFE", "\uD83E\uDD77\uD83C\uDFFF", "\uD83E\uDDB5\uD83C\uDFFB", "\uD83E\uDDB5\uD83C\uDFFC", "\uD83E\uDDB5\uD83C\uDFFD", "\uD83E\uDDB5\uD83C\uDFFE", "\uD83E\uDDB5\uD83C\uDFFF", "\uD83E\uDDB6\uD83C\uDFFB", "\uD83E\uDDB6\uD83C\uDFFC", "\uD83E\uDDB6\uD83C\uDFFD", "\uD83E\uDDB6\uD83C\uDFFE", "\uD83E\uDDB6\uD83C\uDFFF", "\uD83E\uDDB8\u200D\u2640\uFE0F", "\uD83E\uDDB8\u200D\u2642\uFE0F", "\uD83E\uDDB8\uD83C\uDFFB", "\uD83E\uDDB8\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDB8\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDB8\uD83C\uDFFC", "\uD83E\uDDB8\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDB8\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDB8\uD83C\uDFFD", "\uD83E\uDDB8\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDB8\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDB8\uD83C\uDFFE", "\uD83E\uDDB8\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDB8\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDB8\uD83C\uDFFF", "\uD83E\uDDB8\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDB8\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDB9\u200D\u2640\uFE0F", "\uD83E\uDDB9\u200D\u2642\uFE0F", "\uD83E\uDDB9\uD83C\uDFFB", "\uD83E\uDDB9\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDB9\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDB9\uD83C\uDFFC", "\uD83E\uDDB9\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDB9\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDB9\uD83C\uDFFD", "\uD83E\uDDB9\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDB9\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDB9\uD83C\uDFFE", "\uD83E\uDDB9\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDB9\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDB9\uD83C\uDFFF", "\uD83E\uDDB9\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDB9\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDBB\uD83C\uDFFB", "\uD83E\uDDBB\uD83C\uDFFC", "\uD83E\uDDBB\uD83C\uDFFD", "\uD83E\uDDBB\uD83C\uDFFE", "\uD83E\uDDBB\uD83C\uDFFF", "\uD83E\uDDCD\u200D\u2640\uFE0F", "\uD83E\uDDCD\u200D\u2642\uFE0F", "\uD83E\uDDCD\uD83C\uDFFB", "\uD83E\uDDCD\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDCD\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDCD\uD83C\uDFFC", "\uD83E\uDDCD\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDCD\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDCD\uD83C\uDFFD", "\uD83E\uDDCD\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDCD\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDCD\uD83C\uDFFE", "\uD83E\uDDCD\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDCD\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDCD\uD83C\uDFFF", "\uD83E\uDDCD\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDCD\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDCE\u200D\u2640\uFE0F", "\uD83E\uDDCE\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\u200D\u2642\uFE0F", "\uD83E\uDDCE\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFB", "\uD83E\uDDCE\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDCE\uD83C\uDFFB\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDCE\uD83C\uDFFB\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFB\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFC", "\uD83E\uDDCE\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDCE\uD83C\uDFFC\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDCE\uD83C\uDFFC\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFC\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFD", "\uD83E\uDDCE\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDCE\uD83C\uDFFD\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDCE\uD83C\uDFFD\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFD\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFE", "\uD83E\uDDCE\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDCE\uD83C\uDFFE\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDCE\uD83C\uDFFE\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFE\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFF", "\uD83E\uDDCE\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDCE\uD83C\uDFFF\u200D\u2640\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDCE\uD83C\uDFFF\u200D\u2642\uFE0F\u200D\u27A1\uFE0F", "\uD83E\uDDCE\uD83C\uDFFF\u200D\u27A1\uFE0F", "\uD83E\uDDCF\u200D\u2640\uFE0F", "\uD83E\uDDCF\u200D\u2642\uFE0F", "\uD83E\uDDCF\uD83C\uDFFB", "\uD83E\uDDCF\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDCF\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDCF\uD83C\uDFFC", "\uD83E\uDDCF\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDCF\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDCF\uD83C\uDFFD", "\uD83E\uDDCF\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDCF\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDCF\uD83C\uDFFE", "\uD83E\uDDCF\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDCF\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDCF\uD83C\uDFFF", "\uD83E\uDDCF\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDCF\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDD1\u200D\u2695\uFE0F", "\uD83E\uDDD1\u200D\u2696\uFE0F", "\uD83E\uDDD1\u200D\u2708\uFE0F", "\uD83E\uDDD1\u200D\uD83C\uDF3E", "\uD83E\uDDD1\u200D\uD83C\uDF73", "\uD83E\uDDD1\u200D\uD83C\uDF7C", "\uD83E\uDDD1\u200D\uD83C\uDF84", "\uD83E\uDDD1\u200D\uD83C\uDF93", "\uD83E\uDDD1\u200D\uD83C\uDFA4", "\uD83E\uDDD1\u200D\uD83C\uDFA8", "\uD83E\uDDD1\u200D\uD83C\uDFEB", "\uD83E\uDDD1\u200D\uD83C\uDFED", "\uD83E\uDDD1\u200D\uD83D\uDCBB", "\uD83E\uDDD1\u200D\uD83D\uDCBC", "\uD83E\uDDD1\u200D\uD83D\uDD27", "\uD83E\uDDD1\u200D\uD83D\uDD2C", "\uD83E\uDDD1\u200D\uD83D\uDE80", "\uD83E\uDDD1\u200D\uD83D\uDE92", "\uD83E\uDDD1\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1", "\uD83E\uDDD1\u200D\uD83E\uDDAF", "\uD83E\uDDD1\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\u200D\uD83E\uDDB0", "\uD83E\uDDD1\u200D\uD83E\uDDB1", "\uD83E\uDDD1\u200D\uD83E\uDDB2", "\uD83E\uDDD1\u200D\uD83E\uDDB3", "\uD83E\uDDD1\u200D\uD83E\uDDBC", "\uD83E\uDDD1\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\u200D\uD83E\uDDBD", "\uD83E\uDDD1\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83E\uDDD1\u200D\uD83E\uDDD1\u200D\uD83E\uDDD2", "\uD83E\uDDD1\u200D\uD83E\uDDD1\u200D\uD83E\uDDD2\u200D\uD83E\uDDD2", "\uD83E\uDDD1\u200D\uD83E\uDDD2", "\uD83E\uDDD1\u200D\uD83E\uDDD2\u200D\uD83E\uDDD2", "\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2695\uFE0F", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2696\uFE0F", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2708\uFE0F", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDF3E", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDF73", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDF7C", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDF84", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDF93", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDFA4", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDFA8", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDFEB", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83C\uDFED", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDCBB", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDCBC", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDD27", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDD2C", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDE80", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83D\uDE92", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDAF", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDB0", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDB1", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDB2", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDB3", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDBC", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDBD", "\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2695\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2696\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2708\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDF3E", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDF73", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDF7C", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDF84", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDF93", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDFA4", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDFA8", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDFEB", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83C\uDFED", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDCBB", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDCBC", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDD27", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDD2C", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDE80", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83D\uDE92", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDAF", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDB0", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDB1", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDB2", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDB3", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDBC", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDBD", "\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2695\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2696\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2708\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDF3E", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDF73", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDF7C", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDF84", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDF93", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDFA4", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDFA8", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDFEB", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83C\uDFED", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDCBB", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDCBC", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDD27", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDD2C", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDE80", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83D\uDE92", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDAF", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDB0", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDB1", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDB2", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDB3", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDBC", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDBD", "\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2695\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2696\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2708\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDF3E", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDF73", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDF7C", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDF84", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDF93", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDFA4", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDFA8", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDFEB", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83C\uDFED", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDCBB", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDCBC", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDD27", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDD2C", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDE80", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83D\uDE92", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDAF", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDB0", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDB1", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDB2", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDB3", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDBC", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDBD", "\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2695\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2696\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2708\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83D\uDC8B\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDF3E", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDF73", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDF7C", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDF84", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDF93", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDFA4", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDFA8", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDFEB", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83C\uDFED", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDCBB", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDCBC", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDD27", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDD2C", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDE80", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83D\uDE92", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFB", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFC", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFD", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFE", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1\uD83C\uDFFF", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDAF", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDAF\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDB0", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDB1", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDB2", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDB3", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDBC", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDBC\u200D\u27A1\uFE0F", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDBD", "\uD83E\uDDD1\uD83C\uDFFF\u200D\uD83E\uDDBD\u200D\u27A1\uFE0F", "\uD83E\uDDD2\uD83C\uDFFB", "\uD83E\uDDD2\uD83C\uDFFC", "\uD83E\uDDD2\uD83C\uDFFD", "\uD83E\uDDD2\uD83C\uDFFE", "\uD83E\uDDD2\uD83C\uDFFF", "\uD83E\uDDD3\uD83C\uDFFB", "\uD83E\uDDD3\uD83C\uDFFC", "\uD83E\uDDD3\uD83C\uDFFD", "\uD83E\uDDD3\uD83C\uDFFE", "\uD83E\uDDD3\uD83C\uDFFF", "\uD83E\uDDD4\u200D\u2640\uFE0F", "\uD83E\uDDD4\u200D\u2642\uFE0F", "\uD83E\uDDD4\uD83C\uDFFB", "\uD83E\uDDD4\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDD4\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDD4\uD83C\uDFFC", "\uD83E\uDDD4\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDD4\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDD4\uD83C\uDFFD", "\uD83E\uDDD4\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDD4\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDD4\uD83C\uDFFE", "\uD83E\uDDD4\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDD4\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDD4\uD83C\uDFFF", "\uD83E\uDDD4\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDD4\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDD5\uD83C\uDFFB", "\uD83E\uDDD5\uD83C\uDFFC", "\uD83E\uDDD5\uD83C\uDFFD", "\uD83E\uDDD5\uD83C\uDFFE", "\uD83E\uDDD5\uD83C\uDFFF", "\uD83E\uDDD6\u200D\u2640\uFE0F", "\uD83E\uDDD6\u200D\u2642\uFE0F", "\uD83E\uDDD6\uD83C\uDFFB", "\uD83E\uDDD6\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDD6\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDD6\uD83C\uDFFC", "\uD83E\uDDD6\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDD6\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDD6\uD83C\uDFFD", "\uD83E\uDDD6\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDD6\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDD6\uD83C\uDFFE", "\uD83E\uDDD6\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDD6\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDD6\uD83C\uDFFF", "\uD83E\uDDD6\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDD6\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDD7\u200D\u2640\uFE0F", "\uD83E\uDDD7\u200D\u2642\uFE0F", "\uD83E\uDDD7\uD83C\uDFFB", "\uD83E\uDDD7\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDD7\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDD7\uD83C\uDFFC", "\uD83E\uDDD7\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDD7\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDD7\uD83C\uDFFD", "\uD83E\uDDD7\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDD7\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDD7\uD83C\uDFFE", "\uD83E\uDDD7\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDD7\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDD7\uD83C\uDFFF", "\uD83E\uDDD7\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDD7\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDD8\u200D\u2640\uFE0F", "\uD83E\uDDD8\u200D\u2642\uFE0F", "\uD83E\uDDD8\uD83C\uDFFB", "\uD83E\uDDD8\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDD8\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDD8\uD83C\uDFFC", "\uD83E\uDDD8\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDD8\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDD8\uD83C\uDFFD", "\uD83E\uDDD8\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDD8\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDD8\uD83C\uDFFE", "\uD83E\uDDD8\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDD8\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDD8\uD83C\uDFFF", "\uD83E\uDDD8\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDD8\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDD9\u200D\u2640\uFE0F", "\uD83E\uDDD9\u200D\u2642\uFE0F", "\uD83E\uDDD9\uD83C\uDFFB", "\uD83E\uDDD9\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDD9\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDD9\uD83C\uDFFC", "\uD83E\uDDD9\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDD9\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDD9\uD83C\uDFFD", "\uD83E\uDDD9\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDD9\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDD9\uD83C\uDFFE", "\uD83E\uDDD9\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDD9\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDD9\uD83C\uDFFF", "\uD83E\uDDD9\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDD9\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDDA\u200D\u2640\uFE0F", "\uD83E\uDDDA\u200D\u2642\uFE0F", "\uD83E\uDDDA\uD83C\uDFFB", "\uD83E\uDDDA\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDDA\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDDA\uD83C\uDFFC", "\uD83E\uDDDA\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDDA\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDDA\uD83C\uDFFD", "\uD83E\uDDDA\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDDA\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDDA\uD83C\uDFFE", "\uD83E\uDDDA\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDDA\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDDA\uD83C\uDFFF", "\uD83E\uDDDA\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDDA\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDDB\u200D\u2640\uFE0F", "\uD83E\uDDDB\u200D\u2642\uFE0F", "\uD83E\uDDDB\uD83C\uDFFB", "\uD83E\uDDDB\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDDB\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDDB\uD83C\uDFFC", "\uD83E\uDDDB\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDDB\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDDB\uD83C\uDFFD", "\uD83E\uDDDB\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDDB\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDDB\uD83C\uDFFE", "\uD83E\uDDDB\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDDB\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDDB\uD83C\uDFFF", "\uD83E\uDDDB\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDDB\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDDC\u200D\u2640\uFE0F", "\uD83E\uDDDC\u200D\u2642\uFE0F", "\uD83E\uDDDC\uD83C\uDFFB", "\uD83E\uDDDC\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDDC\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDDC\uD83C\uDFFC", "\uD83E\uDDDC\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDDC\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDDC\uD83C\uDFFD", "\uD83E\uDDDC\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDDC\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDDC\uD83C\uDFFE", "\uD83E\uDDDC\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDDC\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDDC\uD83C\uDFFF", "\uD83E\uDDDC\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDDC\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDDD\u200D\u2640\uFE0F", "\uD83E\uDDDD\u200D\u2642\uFE0F", "\uD83E\uDDDD\uD83C\uDFFB", "\uD83E\uDDDD\uD83C\uDFFB\u200D\u2640\uFE0F", "\uD83E\uDDDD\uD83C\uDFFB\u200D\u2642\uFE0F", "\uD83E\uDDDD\uD83C\uDFFC", "\uD83E\uDDDD\uD83C\uDFFC\u200D\u2640\uFE0F", "\uD83E\uDDDD\uD83C\uDFFC\u200D\u2642\uFE0F", "\uD83E\uDDDD\uD83C\uDFFD", "\uD83E\uDDDD\uD83C\uDFFD\u200D\u2640\uFE0F", "\uD83E\uDDDD\uD83C\uDFFD\u200D\u2642\uFE0F", "\uD83E\uDDDD\uD83C\uDFFE", "\uD83E\uDDDD\uD83C\uDFFE\u200D\u2640\uFE0F", "\uD83E\uDDDD\uD83C\uDFFE\u200D\u2642\uFE0F", "\uD83E\uDDDD\uD83C\uDFFF", "\uD83E\uDDDD\uD83C\uDFFF\u200D\u2640\uFE0F", "\uD83E\uDDDD\uD83C\uDFFF\u200D\u2642\uFE0F", "\uD83E\uDDDE\u200D\u2640\uFE0F", "\uD83E\uDDDE\u200D\u2642\uFE0F", "\uD83E\uDDDF\u200D\u2640\uFE0F", "\uD83E\uDDDF\u200D\u2642\uFE0F", "\uD83E\uDEC3\uD83C\uDFFB", "\uD83E\uDEC3\uD83C\uDFFC", "\uD83E\uDEC3\uD83C\uDFFD", "\uD83E\uDEC3\uD83C\uDFFE", "\uD83E\uDEC3\uD83C\uDFFF", "\uD83E\uDEC4\uD83C\uDFFB", "\uD83E\uDEC4\uD83C\uDFFC", "\uD83E\uDEC4\uD83C\uDFFD", "\uD83E\uDEC4\uD83C\uDFFE", "\uD83E\uDEC4\uD83C\uDFFF", "\uD83E\uDEC5\uD83C\uDFFB", "\uD83E\uDEC5\uD83C\uDFFC", "\uD83E\uDEC5\uD83C\uDFFD", "\uD83E\uDEC5\uD83C\uDFFE", "\uD83E\uDEC5\uD83C\uDFFF", "\uD83E\uDEF0\uD83C\uDFFB", "\uD83E\uDEF0\uD83C\uDFFC", "\uD83E\uDEF0\uD83C\uDFFD", "\uD83E\uDEF0\uD83C\uDFFE", "\uD83E\uDEF0\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFB", "\uD83E\uDEF1\uD83C\uDFFB\u200D\uD83E\uDEF2\uD83C\uDFFC", "\uD83E\uDEF1\uD83C\uDFFB\u200D\uD83E\uDEF2\uD83C\uDFFD", "\uD83E\uDEF1\uD83C\uDFFB\u200D\uD83E\uDEF2\uD83C\uDFFE", "\uD83E\uDEF1\uD83C\uDFFB\u200D\uD83E\uDEF2\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFC", "\uD83E\uDEF1\uD83C\uDFFC\u200D\uD83E\uDEF2\uD83C\uDFFB", "\uD83E\uDEF1\uD83C\uDFFC\u200D\uD83E\uDEF2\uD83C\uDFFD", "\uD83E\uDEF1\uD83C\uDFFC\u200D\uD83E\uDEF2\uD83C\uDFFE", "\uD83E\uDEF1\uD83C\uDFFC\u200D\uD83E\uDEF2\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFD", "\uD83E\uDEF1\uD83C\uDFFD\u200D\uD83E\uDEF2\uD83C\uDFFB", "\uD83E\uDEF1\uD83C\uDFFD\u200D\uD83E\uDEF2\uD83C\uDFFC", "\uD83E\uDEF1\uD83C\uDFFD\u200D\uD83E\uDEF2\uD83C\uDFFE", "\uD83E\uDEF1\uD83C\uDFFD\u200D\uD83E\uDEF2\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFE", "\uD83E\uDEF1\uD83C\uDFFE\u200D\uD83E\uDEF2\uD83C\uDFFB", "\uD83E\uDEF1\uD83C\uDFFE\u200D\uD83E\uDEF2\uD83C\uDFFC", "\uD83E\uDEF1\uD83C\uDFFE\u200D\uD83E\uDEF2\uD83C\uDFFD", "\uD83E\uDEF1\uD83C\uDFFE\u200D\uD83E\uDEF2\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFF", "\uD83E\uDEF1\uD83C\uDFFF\u200D\uD83E\uDEF2\uD83C\uDFFB", "\uD83E\uDEF1\uD83C\uDFFF\u200D\uD83E\uDEF2\uD83C\uDFFC", "\uD83E\uDEF1\uD83C\uDFFF\u200D\uD83E\uDEF2\uD83C\uDFFD", "\uD83E\uDEF1\uD83C\uDFFF\u200D\uD83E\uDEF2\uD83C\uDFFE", "\uD83E\uDEF2\uD83C\uDFFB", "\uD83E\uDEF2\uD83C\uDFFC", "\uD83E\uDEF2\uD83C\uDFFD", "\uD83E\uDEF2\uD83C\uDFFE", "\uD83E\uDEF2\uD83C\uDFFF", "\uD83E\uDEF3\uD83C\uDFFB", "\uD83E\uDEF3\uD83C\uDFFC", "\uD83E\uDEF3\uD83C\uDFFD", "\uD83E\uDEF3\uD83C\uDFFE", "\uD83E\uDEF3\uD83C\uDFFF", "\uD83E\uDEF4\uD83C\uDFFB", "\uD83E\uDEF4\uD83C\uDFFC", "\uD83E\uDEF4\uD83C\uDFFD", "\uD83E\uDEF4\uD83C\uDFFE", "\uD83E\uDEF4\uD83C\uDFFF", "\uD83E\uDEF5\uD83C\uDFFB", "\uD83E\uDEF5\uD83C\uDFFC", "\uD83E\uDEF5\uD83C\uDFFD", "\uD83E\uDEF5\uD83C\uDFFE", "\uD83E\uDEF5\uD83C\uDFFF", "\uD83E\uDEF6\uD83C\uDFFB", "\uD83E\uDEF6\uD83C\uDFFC", "\uD83E\uDEF6\uD83C\uDFFD", "\uD83E\uDEF6\uD83C\uDFFE", "\uD83E\uDEF6\uD83C\uDFFF", "\uD83E\uDEF7\uD83C\uDFFB", "\uD83E\uDEF7\uD83C\uDFFC", "\uD83E\uDEF7\uD83C\uDFFD", "\uD83E\uDEF7\uD83C\uDFFE", "\uD83E\uDEF7\uD83C\uDFFF", "\uD83E\uDEF8\uD83C\uDFFB", "\uD83E\uDEF8\uD83C\uDFFC", "\uD83E\uDEF8\uD83C\uDFFD", "\uD83E\uDEF8\uD83C\uDFFE", "\uD83E\uDEF8\uD83C\uDFFF"];
    return RGI_Emoji;
  }

var Adlam$1 = {};

var hasRequiredAdlam$1;
  function requireAdlam$1() {
    if (hasRequiredAdlam$1) return Adlam$1;
    hasRequiredAdlam$1 = 1;
    var set = regenerateExports(0x61F, 0x640, 0x204F, 0x2E41);
    set.addRange(0x1E900, 0x1E94B).addRange(0x1E950, 0x1E959).addRange(0x1E95E, 0x1E95F);
    Adlam$1.characters = set;
    return Adlam$1;
  }

var Ahom$1 = {};

var hasRequiredAhom$1;
  function requireAhom$1() {
    if (hasRequiredAhom$1) return Ahom$1;
    hasRequiredAhom$1 = 1;
    var set = regenerateExports();
    set.addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172B).addRange(0x11730, 0x11746);
    Ahom$1.characters = set;
    return Ahom$1;
  }

var Anatolian_Hieroglyphs$1 = {};

var hasRequiredAnatolian_Hieroglyphs$1;
  function requireAnatolian_Hieroglyphs$1() {
    if (hasRequiredAnatolian_Hieroglyphs$1) return Anatolian_Hieroglyphs$1;
    hasRequiredAnatolian_Hieroglyphs$1 = 1;
    var set = regenerateExports();
    set.addRange(0x14400, 0x14646);
    Anatolian_Hieroglyphs$1.characters = set;
    return Anatolian_Hieroglyphs$1;
  }

var Arabic$1 = {};

var hasRequiredArabic$1;
  function requireArabic$1() {
    if (hasRequiredArabic$1) return Arabic$1;
    hasRequiredArabic$1 = 1;
    var set = regenerateExports(0x204F, 0x2E41, 0xFDCF, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E);
    set.addRange(0x600, 0x604).addRange(0x606, 0x6DC).addRange(0x6DE, 0x6FF).addRange(0x750, 0x77F).addRange(0x870, 0x88E).addRange(0x890, 0x891).addRange(0x897, 0x8E1).addRange(0x8E3, 0x8FF).addRange(0xFB50, 0xFBC2).addRange(0xFBD3, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFF).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0x102E0, 0x102FB).addRange(0x10E60, 0x10E7E).addRange(0x10EC2, 0x10EC4).addRange(0x10EFC, 0x10EFF).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1EEF0, 0x1EEF1);
    Arabic$1.characters = set;
    return Arabic$1;
  }

var Armenian$1 = {};

var hasRequiredArmenian$1;
  function requireArmenian$1() {
    if (hasRequiredArmenian$1) return Armenian$1;
    hasRequiredArmenian$1 = 1;
    var set = regenerateExports(0x308);
    set.addRange(0x531, 0x556).addRange(0x559, 0x58A).addRange(0x58D, 0x58F).addRange(0xFB13, 0xFB17);
    Armenian$1.characters = set;
    return Armenian$1;
  }

var Avestan$1 = {};

var hasRequiredAvestan$1;
  function requireAvestan$1() {
    if (hasRequiredAvestan$1) return Avestan$1;
    hasRequiredAvestan$1 = 1;
    var set = regenerateExports(0xB7);
    set.addRange(0x2E30, 0x2E31).addRange(0x10B00, 0x10B35).addRange(0x10B39, 0x10B3F);
    Avestan$1.characters = set;
    return Avestan$1;
  }

var Balinese$1 = {};

var hasRequiredBalinese$1;
  function requireBalinese$1() {
    if (hasRequiredBalinese$1) return Balinese$1;
    hasRequiredBalinese$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1B00, 0x1B4C).addRange(0x1B4E, 0x1B7F);
    Balinese$1.characters = set;
    return Balinese$1;
  }

var Bamum$1 = {};

var hasRequiredBamum$1;
  function requireBamum$1() {
    if (hasRequiredBamum$1) return Bamum$1;
    hasRequiredBamum$1 = 1;
    var set = regenerateExports();
    set.addRange(0xA6A0, 0xA6F7).addRange(0x16800, 0x16A38);
    Bamum$1.characters = set;
    return Bamum$1;
  }

var Bassa_Vah$1 = {};

var hasRequiredBassa_Vah$1;
  function requireBassa_Vah$1() {
    if (hasRequiredBassa_Vah$1) return Bassa_Vah$1;
    hasRequiredBassa_Vah$1 = 1;
    var set = regenerateExports();
    set.addRange(0x16AD0, 0x16AED).addRange(0x16AF0, 0x16AF5);
    Bassa_Vah$1.characters = set;
    return Bassa_Vah$1;
  }

var Batak$1 = {};

var hasRequiredBatak$1;
  function requireBatak$1() {
    if (hasRequiredBatak$1) return Batak$1;
    hasRequiredBatak$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1BC0, 0x1BF3).addRange(0x1BFC, 0x1BFF);
    Batak$1.characters = set;
    return Batak$1;
  }

var Bengali$1 = {};

var hasRequiredBengali$1;
  function requireBengali$1() {
    if (hasRequiredBengali$1) return Bengali$1;
    hasRequiredBengali$1 = 1;
    var set = regenerateExports(0x2BC, 0x9B2, 0x9D7, 0x1CD0, 0x1CD2, 0x1CD8, 0x1CE1, 0x1CEA, 0x1CED, 0x1CF2, 0xA8F1);
    set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0x980, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BC, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CE).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E3).addRange(0x9E6, 0x9FE).addRange(0x1CD5, 0x1CD6).addRange(0x1CF5, 0x1CF7);
    Bengali$1.characters = set;
    return Bengali$1;
  }

var Bhaiksuki$1 = {};

var hasRequiredBhaiksuki$1;
  function requireBhaiksuki$1() {
    if (hasRequiredBhaiksuki$1) return Bhaiksuki$1;
    hasRequiredBhaiksuki$1 = 1;
    var set = regenerateExports();
    set.addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C45).addRange(0x11C50, 0x11C6C);
    Bhaiksuki$1.characters = set;
    return Bhaiksuki$1;
  }

var Bopomofo$1 = {};

var hasRequiredBopomofo$1;
  function requireBopomofo$1() {
    if (hasRequiredBopomofo$1) return Bopomofo$1;
    hasRequiredBopomofo$1 = 1;
    var set = regenerateExports(0x2C7, 0x2D9, 0x3030, 0x3037, 0x30FB);
    set.addRange(0x2C9, 0x2CB).addRange(0x2EA, 0x2EB).addRange(0x3001, 0x3003).addRange(0x3008, 0x3011).addRange(0x3013, 0x301F).addRange(0x302A, 0x302D).addRange(0x3105, 0x312F).addRange(0x31A0, 0x31BF).addRange(0xFE45, 0xFE46).addRange(0xFF61, 0xFF65);
    Bopomofo$1.characters = set;
    return Bopomofo$1;
  }

var Brahmi$1 = {};

var hasRequiredBrahmi$1;
  function requireBrahmi$1() {
    if (hasRequiredBrahmi$1) return Brahmi$1;
    hasRequiredBrahmi$1 = 1;
    var set = regenerateExports(0x1107F);
    set.addRange(0x11000, 0x1104D).addRange(0x11052, 0x11075);
    Brahmi$1.characters = set;
    return Brahmi$1;
  }

var Braille$1 = {};

var hasRequiredBraille$1;
  function requireBraille$1() {
    if (hasRequiredBraille$1) return Braille$1;
    hasRequiredBraille$1 = 1;
    var set = regenerateExports();
    set.addRange(0x2800, 0x28FF);
    Braille$1.characters = set;
    return Braille$1;
  }

var Buginese$1 = {};

var hasRequiredBuginese$1;
  function requireBuginese$1() {
    if (hasRequiredBuginese$1) return Buginese$1;
    hasRequiredBuginese$1 = 1;
    var set = regenerateExports(0xA9CF);
    set.addRange(0x1A00, 0x1A1B).addRange(0x1A1E, 0x1A1F);
    Buginese$1.characters = set;
    return Buginese$1;
  }

var Buhid$1 = {};

var hasRequiredBuhid$1;
  function requireBuhid$1() {
    if (hasRequiredBuhid$1) return Buhid$1;
    hasRequiredBuhid$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1735, 0x1736).addRange(0x1740, 0x1753);
    Buhid$1.characters = set;
    return Buhid$1;
  }

var Canadian_Aboriginal$1 = {};

var hasRequiredCanadian_Aboriginal$1;
  function requireCanadian_Aboriginal$1() {
    if (hasRequiredCanadian_Aboriginal$1) return Canadian_Aboriginal$1;
    hasRequiredCanadian_Aboriginal$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1400, 0x167F).addRange(0x18B0, 0x18F5).addRange(0x11AB0, 0x11ABF);
    Canadian_Aboriginal$1.characters = set;
    return Canadian_Aboriginal$1;
  }

var Carian$1 = {};

var hasRequiredCarian$1;
  function requireCarian$1() {
    if (hasRequiredCarian$1) return Carian$1;
    hasRequiredCarian$1 = 1;
    var set = regenerateExports(0xB7, 0x205A, 0x205D, 0x2E31);
    set.addRange(0x102A0, 0x102D0);
    Carian$1.characters = set;
    return Carian$1;
  }

var Caucasian_Albanian$1 = {};

var hasRequiredCaucasian_Albanian$1;
  function requireCaucasian_Albanian$1() {
    if (hasRequiredCaucasian_Albanian$1) return Caucasian_Albanian$1;
    hasRequiredCaucasian_Albanian$1 = 1;
    var set = regenerateExports(0x304, 0x331, 0x35E, 0x1056F);
    set.addRange(0x10530, 0x10563);
    Caucasian_Albanian$1.characters = set;
    return Caucasian_Albanian$1;
  }

var Chakma$1 = {};

var hasRequiredChakma$1;
  function requireChakma$1() {
    if (hasRequiredChakma$1) return Chakma$1;
    hasRequiredChakma$1 = 1;
    var set = regenerateExports();
    set.addRange(0x9E6, 0x9EF).addRange(0x1040, 0x1049).addRange(0x11100, 0x11134).addRange(0x11136, 0x11147);
    Chakma$1.characters = set;
    return Chakma$1;
  }

var Cham$1 = {};

var hasRequiredCham$1;
  function requireCham$1() {
    if (hasRequiredCham$1) return Cham$1;
    hasRequiredCham$1 = 1;
    var set = regenerateExports();
    set.addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA50, 0xAA59).addRange(0xAA5C, 0xAA5F);
    Cham$1.characters = set;
    return Cham$1;
  }

var Cherokee$1 = {};

var hasRequiredCherokee$1;
  function requireCherokee$1() {
    if (hasRequiredCherokee$1) return Cherokee$1;
    hasRequiredCherokee$1 = 1;
    var set = regenerateExports(0x304);
    set.addRange(0x300, 0x302).addRange(0x30B, 0x30C).addRange(0x323, 0x324).addRange(0x330, 0x331).addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0xAB70, 0xABBF);
    Cherokee$1.characters = set;
    return Cherokee$1;
  }

var Chorasmian$1 = {};

var hasRequiredChorasmian$1;
  function requireChorasmian$1() {
    if (hasRequiredChorasmian$1) return Chorasmian$1;
    hasRequiredChorasmian$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10FB0, 0x10FCB);
    Chorasmian$1.characters = set;
    return Chorasmian$1;
  }

var Common$1 = {};

var hasRequiredCommon$1;
  function requireCommon$1() {
    if (hasRequiredCommon$1) return Common$1;
    hasRequiredCommon$1 = 1;
    var set = regenerateExports(0xD7, 0xF7, 0x2C8, 0x2CC, 0x2D8, 0x37E, 0x385, 0x387, 0x605, 0x6DD, 0x8E2, 0xE3F, 0x2E42, 0x3000, 0x3004, 0x3012, 0x3020, 0x3036, 0x327F, 0x33FF, 0xAB5B, 0xFEFF, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1F7F0, 0xE0001);
    set.addRange(0x0, 0x40).addRange(0x5B, 0x60).addRange(0x7B, 0xA9).addRange(0xAB, 0xB6).addRange(0xB8, 0xB9).addRange(0xBB, 0xBF).addRange(0x2B9, 0x2BB).addRange(0x2BD, 0x2C6).addRange(0x2CE, 0x2D6).addRange(0x2DA, 0x2DF).addRange(0x2E5, 0x2E9).addRange(0x2EC, 0x2FF).addRange(0xFD5, 0xFD8).addRange(0x2000, 0x200B).addRange(0x200E, 0x202E).addRange(0x2030, 0x204E).addRange(0x2050, 0x2059).addRange(0x205B, 0x205C).addRange(0x205E, 0x2064).addRange(0x2066, 0x2070).addRange(0x2074, 0x207E).addRange(0x2080, 0x208E).addRange(0x20A0, 0x20C0).addRange(0x2100, 0x2125).addRange(0x2127, 0x2129).addRange(0x212C, 0x2131).addRange(0x2133, 0x214D).addRange(0x214F, 0x215F).addRange(0x2189, 0x218B).addRange(0x2190, 0x2429).addRange(0x2440, 0x244A).addRange(0x2460, 0x27FF).addRange(0x2900, 0x2B73).addRange(0x2B76, 0x2B95).addRange(0x2B97, 0x2BFF).addRange(0x2E00, 0x2E16).addRange(0x2E18, 0x2E2F).addRange(0x2E32, 0x2E3B).addRange(0x2E3D, 0x2E40).addRange(0x2E44, 0x2E5D).addRange(0x3248, 0x325F).addRange(0x32B1, 0x32BF).addRange(0x32CC, 0x32CF).addRange(0x3371, 0x337A).addRange(0x3380, 0x33DF).addRange(0x4DC0, 0x4DFF).addRange(0xA708, 0xA721).addRange(0xA788, 0xA78A).addRange(0xAB6A, 0xAB6B).addRange(0xFE10, 0xFE19).addRange(0xFE30, 0xFE44);
    set.addRange(0xFE47, 0xFE52).addRange(0xFE54, 0xFE66).addRange(0xFE68, 0xFE6B).addRange(0xFF01, 0xFF20).addRange(0xFF3B, 0xFF40).addRange(0xFF5B, 0xFF60).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFF9, 0xFFFD).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FC).addRange(0x1CC00, 0x1CCF9).addRange(0x1CD00, 0x1CEB3).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D166).addRange(0x1D16A, 0x1D17A).addRange(0x1D183, 0x1D184).addRange(0x1D18C, 0x1D1A9).addRange(0x1D1AE, 0x1D1EA).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D300, 0x1D356).addRange(0x1D372, 0x1D378).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D7CB).addRange(0x1D7CE, 0x1D7FF).addRange(0x1EC71, 0x1ECB4).addRange(0x1ED01, 0x1ED3D).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093).addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF).addRange(0x1F0D1, 0x1F0F5);
    set.addRange(0x1F100, 0x1F1AD).addRange(0x1F1E6, 0x1F1FF).addRange(0x1F201, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F6D7).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F776).addRange(0x1F77B, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F900, 0x1FA53).addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA89).addRange(0x1FA8F, 0x1FAC6).addRange(0x1FACE, 0x1FADC).addRange(0x1FADF, 0x1FAE9).addRange(0x1FAF0, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBF9).addRange(0xE0020, 0xE007F);
    Common$1.characters = set;
    return Common$1;
  }

var Coptic$1 = {};

var hasRequiredCoptic$1;
  function requireCoptic$1() {
    if (hasRequiredCoptic$1) return Coptic$1;
    hasRequiredCoptic$1 = 1;
    var set = regenerateExports(0xB7, 0x300, 0x307, 0x2E17);
    set.addRange(0x304, 0x305).addRange(0x374, 0x375).addRange(0x3E2, 0x3EF).addRange(0x2C80, 0x2CF3).addRange(0x2CF9, 0x2CFF).addRange(0x102E0, 0x102FB);
    Coptic$1.characters = set;
    return Coptic$1;
  }

var Cuneiform$1 = {};

var hasRequiredCuneiform$1;
  function requireCuneiform$1() {
    if (hasRequiredCuneiform$1) return Cuneiform$1;
    hasRequiredCuneiform$1 = 1;
    var set = regenerateExports();
    set.addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12470, 0x12474).addRange(0x12480, 0x12543);
    Cuneiform$1.characters = set;
    return Cuneiform$1;
  }

var Cypriot$1 = {};

var hasRequiredCypriot$1;
  function requireCypriot$1() {
    if (hasRequiredCypriot$1) return Cypriot$1;
    hasRequiredCypriot$1 = 1;
    var set = regenerateExports(0x10808, 0x1083C, 0x1083F);
    set.addRange(0x10100, 0x10102).addRange(0x10107, 0x10133).addRange(0x10137, 0x1013F).addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838);
    Cypriot$1.characters = set;
    return Cypriot$1;
  }

var Cypro_Minoan$1 = {};

var hasRequiredCypro_Minoan$1;
  function requireCypro_Minoan$1() {
    if (hasRequiredCypro_Minoan$1) return Cypro_Minoan$1;
    hasRequiredCypro_Minoan$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10100, 0x10101).addRange(0x12F90, 0x12FF2);
    Cypro_Minoan$1.characters = set;
    return Cypro_Minoan$1;
  }

var Cyrillic$1 = {};

var hasRequiredCyrillic$1;
  function requireCyrillic$1() {
    if (hasRequiredCyrillic$1) return Cyrillic$1;
    hasRequiredCyrillic$1 = 1;
    var set = regenerateExports(0x2BC, 0x304, 0x306, 0x308, 0x30B, 0x311, 0x1D2B, 0x1D78, 0x1DF8, 0x2E43, 0x1E08F);
    set.addRange(0x300, 0x302).addRange(0x400, 0x52F).addRange(0x1C80, 0x1C8A).addRange(0x2DE0, 0x2DFF).addRange(0xA640, 0xA69F).addRange(0xFE2E, 0xFE2F).addRange(0x1E030, 0x1E06D);
    Cyrillic$1.characters = set;
    return Cyrillic$1;
  }

var Deseret$1 = {};

var hasRequiredDeseret$1;
  function requireDeseret$1() {
    if (hasRequiredDeseret$1) return Deseret$1;
    hasRequiredDeseret$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10400, 0x1044F);
    Deseret$1.characters = set;
    return Deseret$1;
  }

var Devanagari$1 = {};

var hasRequiredDevanagari$1;
  function requireDevanagari$1() {
    if (hasRequiredDevanagari$1) return Devanagari$1;
    hasRequiredDevanagari$1 = 1;
    var set = regenerateExports(0x2BC, 0x20F0);
    set.addRange(0x900, 0x952).addRange(0x955, 0x97F).addRange(0x1CD0, 0x1CF6).addRange(0x1CF8, 0x1CF9).addRange(0xA830, 0xA839).addRange(0xA8E0, 0xA8FF).addRange(0x11B00, 0x11B09);
    Devanagari$1.characters = set;
    return Devanagari$1;
  }

var Dives_Akuru$1 = {};

var hasRequiredDives_Akuru$1;
  function requireDives_Akuru$1() {
    if (hasRequiredDives_Akuru$1) return Dives_Akuru$1;
    hasRequiredDives_Akuru$1 = 1;
    var set = regenerateExports(0x11909);
    set.addRange(0x11900, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x11946).addRange(0x11950, 0x11959);
    Dives_Akuru$1.characters = set;
    return Dives_Akuru$1;
  }

var Dogra$1 = {};

var hasRequiredDogra$1;
  function requireDogra$1() {
    if (hasRequiredDogra$1) return Dogra$1;
    hasRequiredDogra$1 = 1;
    var set = regenerateExports();
    set.addRange(0x964, 0x96F).addRange(0xA830, 0xA839).addRange(0x11800, 0x1183B);
    Dogra$1.characters = set;
    return Dogra$1;
  }

var Duployan$1 = {};

var hasRequiredDuployan$1;
  function requireDuployan$1() {
    if (hasRequiredDuployan$1) return Duployan$1;
    hasRequiredDuployan$1 = 1;
    var set = regenerateExports(0xB7, 0x30A, 0x2E3C);
    set.addRange(0x307, 0x308).addRange(0x323, 0x324).addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1BC9C, 0x1BCA3);
    Duployan$1.characters = set;
    return Duployan$1;
  }

var Egyptian_Hieroglyphs$1 = {};

var hasRequiredEgyptian_Hieroglyphs$1;
  function requireEgyptian_Hieroglyphs$1() {
    if (hasRequiredEgyptian_Hieroglyphs$1) return Egyptian_Hieroglyphs$1;
    hasRequiredEgyptian_Hieroglyphs$1 = 1;
    var set = regenerateExports();
    set.addRange(0x13000, 0x13455).addRange(0x13460, 0x143FA);
    Egyptian_Hieroglyphs$1.characters = set;
    return Egyptian_Hieroglyphs$1;
  }

var Elbasan$1 = {};

var hasRequiredElbasan$1;
  function requireElbasan$1() {
    if (hasRequiredElbasan$1) return Elbasan$1;
    hasRequiredElbasan$1 = 1;
    var set = regenerateExports(0xB7, 0x305);
    set.addRange(0x10500, 0x10527);
    Elbasan$1.characters = set;
    return Elbasan$1;
  }

var Elymaic$1 = {};

var hasRequiredElymaic$1;
  function requireElymaic$1() {
    if (hasRequiredElymaic$1) return Elymaic$1;
    hasRequiredElymaic$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10FE0, 0x10FF6);
    Elymaic$1.characters = set;
    return Elymaic$1;
  }

var Ethiopic$1 = {};

var hasRequiredEthiopic$1;
  function requireEthiopic$1() {
    if (hasRequiredEthiopic$1) return Ethiopic$1;
    hasRequiredEthiopic$1 = 1;
    var set = regenerateExports(0x30E, 0x1258, 0x12C0);
    set.addRange(0x1200, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x135D, 0x137C).addRange(0x1380, 0x1399).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE);
    Ethiopic$1.characters = set;
    return Ethiopic$1;
  }

var Garay$1 = {};

var hasRequiredGaray$1;
  function requireGaray$1() {
    if (hasRequiredGaray$1) return Garay$1;
    hasRequiredGaray$1 = 1;
    var set = regenerateExports(0x60C, 0x61B, 0x61F);
    set.addRange(0x10D40, 0x10D65).addRange(0x10D69, 0x10D85).addRange(0x10D8E, 0x10D8F);
    Garay$1.characters = set;
    return Garay$1;
  }

var Georgian$1 = {};

var hasRequiredGeorgian$1;
  function requireGeorgian$1() {
    if (hasRequiredGeorgian$1) return Georgian$1;
    hasRequiredGeorgian$1 = 1;
    var set = regenerateExports(0xB7, 0x589, 0x10C7, 0x10CD, 0x205A, 0x2D27, 0x2D2D, 0x2E31);
    set.addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FF).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x2D00, 0x2D25);
    Georgian$1.characters = set;
    return Georgian$1;
  }

var Glagolitic$1 = {};

var hasRequiredGlagolitic$1;
  function requireGlagolitic$1() {
    if (hasRequiredGlagolitic$1) return Glagolitic$1;
    hasRequiredGlagolitic$1 = 1;
    var set = regenerateExports(0xB7, 0x303, 0x305, 0x484, 0x487, 0x589, 0x10FB, 0x205A, 0x2E43, 0xA66F);
    set.addRange(0x2C00, 0x2C5F).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A);
    Glagolitic$1.characters = set;
    return Glagolitic$1;
  }

var Gothic$1 = {};

var hasRequiredGothic$1;
  function requireGothic$1() {
    if (hasRequiredGothic$1) return Gothic$1;
    hasRequiredGothic$1 = 1;
    var set = regenerateExports(0xB7, 0x308, 0x331);
    set.addRange(0x304, 0x305).addRange(0x10330, 0x1034A);
    Gothic$1.characters = set;
    return Gothic$1;
  }

var Grantha$1 = {};

var hasRequiredGrantha$1;
  function requireGrantha$1() {
    if (hasRequiredGrantha$1) return Grantha$1;
    hasRequiredGrantha$1 = 1;
    var set = regenerateExports(0x1CD0, 0x20F0, 0x11350, 0x11357, 0x11FD3);
    set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xBE6, 0xBF3).addRange(0x1CD2, 0x1CD3).addRange(0x1CF2, 0x1CF4).addRange(0x1CF8, 0x1CF9).addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133B, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x1135D, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374).addRange(0x11FD0, 0x11FD1);
    Grantha$1.characters = set;
    return Grantha$1;
  }

var Greek$1 = {};

var hasRequiredGreek$1;
  function requireGreek$1() {
    if (hasRequiredGreek$1) return Greek$1;
    hasRequiredGreek$1 = 1;
    var set = regenerateExports(0xB7, 0x304, 0x306, 0x308, 0x313, 0x342, 0x345, 0x37F, 0x384, 0x386, 0x38C, 0x1F59, 0x1F5B, 0x1F5D, 0x205D, 0x2126, 0xAB65, 0x101A0);
    set.addRange(0x300, 0x301).addRange(0x370, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3E1).addRange(0x3F0, 0x3FF).addRange(0x1D26, 0x1D2A).addRange(0x1D5D, 0x1D61).addRange(0x1D66, 0x1D6A).addRange(0x1DBF, 0x1DC1).addRange(0x1F00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FC4).addRange(0x1FC6, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FDD, 0x1FEF).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFE).addRange(0x10140, 0x1018E).addRange(0x1D200, 0x1D245);
    Greek$1.characters = set;
    return Greek$1;
  }

var Gujarati$1 = {};

var hasRequiredGujarati$1;
  function requireGujarati$1() {
    if (hasRequiredGujarati$1) return Gujarati$1;
    hasRequiredGujarati$1 = 1;
    var set = regenerateExports(0xAD0);
    set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABC, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE0, 0xAE3).addRange(0xAE6, 0xAF1).addRange(0xAF9, 0xAFF).addRange(0xA830, 0xA839);
    Gujarati$1.characters = set;
    return Gujarati$1;
  }

var Gunjala_Gondi$1 = {};

var hasRequiredGunjala_Gondi$1;
  function requireGunjala_Gondi$1() {
    if (hasRequiredGunjala_Gondi$1) return Gunjala_Gondi$1;
    hasRequiredGunjala_Gondi$1 = 1;
    var set = regenerateExports(0xB7);
    set.addRange(0x964, 0x965).addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D98).addRange(0x11DA0, 0x11DA9);
    Gunjala_Gondi$1.characters = set;
    return Gunjala_Gondi$1;
  }

var Gurmukhi$1 = {};

var hasRequiredGurmukhi$1;
  function requireGurmukhi$1() {
    if (hasRequiredGurmukhi$1) return Gurmukhi$1;
    hasRequiredGurmukhi$1 = 1;
    var set = regenerateExports(0xA3C, 0xA51, 0xA5E);
    set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA76).addRange(0xA830, 0xA839);
    Gurmukhi$1.characters = set;
    return Gurmukhi$1;
  }

var Gurung_Khema$1 = {};

var hasRequiredGurung_Khema$1;
  function requireGurung_Khema$1() {
    if (hasRequiredGurung_Khema$1) return Gurung_Khema$1;
    hasRequiredGurung_Khema$1 = 1;
    var set = regenerateExports(0x965);
    set.addRange(0x16100, 0x16139);
    Gurung_Khema$1.characters = set;
    return Gurung_Khema$1;
  }

var Han$1 = {};

var hasRequiredHan$1;
  function requireHan$1() {
    if (hasRequiredHan$1) return Han$1;
    hasRequiredHan$1 = 1;
    var set = regenerateExports(0xB7, 0x3030, 0x30FB, 0x31EF, 0x32FF);
    set.addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x2FF0, 0x2FFF).addRange(0x3001, 0x3003).addRange(0x3005, 0x3011).addRange(0x3013, 0x301F).addRange(0x3021, 0x302D).addRange(0x3037, 0x303F).addRange(0x3190, 0x319F).addRange(0x31C0, 0x31E5).addRange(0x3220, 0x3247).addRange(0x3280, 0x32B0).addRange(0x32C0, 0x32CB).addRange(0x3358, 0x3370).addRange(0x337B, 0x337F).addRange(0x33E0, 0x33FE).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0x9FFF).addRange(0xA700, 0xA707).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0xFE45, 0xFE46).addRange(0xFF61, 0xFF65).addRange(0x16FE2, 0x16FE3).addRange(0x16FF0, 0x16FF1).addRange(0x1D360, 0x1D371).addRange(0x1F250, 0x1F251).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF);
    Han$1.characters = set;
    return Han$1;
  }

var Hangul$1 = {};

var hasRequiredHangul$1;
  function requireHangul$1() {
    if (hasRequiredHangul$1) return Hangul$1;
    hasRequiredHangul$1 = 1;
    var set = regenerateExports(0x3037, 0x30FB);
    set.addRange(0x1100, 0x11FF).addRange(0x3001, 0x3003).addRange(0x3008, 0x3011).addRange(0x3013, 0x301F).addRange(0x302E, 0x3030).addRange(0x3131, 0x318E).addRange(0x3200, 0x321E).addRange(0x3260, 0x327E).addRange(0xA960, 0xA97C).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xFE45, 0xFE46).addRange(0xFF61, 0xFF65).addRange(0xFFA0, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC);
    Hangul$1.characters = set;
    return Hangul$1;
  }

var Hanifi_Rohingya$1 = {};

var hasRequiredHanifi_Rohingya$1;
  function requireHanifi_Rohingya$1() {
    if (hasRequiredHanifi_Rohingya$1) return Hanifi_Rohingya$1;
    hasRequiredHanifi_Rohingya$1 = 1;
    var set = regenerateExports(0x60C, 0x61B, 0x61F, 0x640, 0x6D4);
    set.addRange(0x10D00, 0x10D27).addRange(0x10D30, 0x10D39);
    Hanifi_Rohingya$1.characters = set;
    return Hanifi_Rohingya$1;
  }

var Hanunoo$1 = {};

var hasRequiredHanunoo$1;
  function requireHanunoo$1() {
    if (hasRequiredHanunoo$1) return Hanunoo$1;
    hasRequiredHanunoo$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1720, 0x1736);
    Hanunoo$1.characters = set;
    return Hanunoo$1;
  }

var Hatran$1 = {};

var hasRequiredHatran$1;
  function requireHatran$1() {
    if (hasRequiredHatran$1) return Hatran$1;
    hasRequiredHatran$1 = 1;
    var set = regenerateExports();
    set.addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x108FB, 0x108FF);
    Hatran$1.characters = set;
    return Hatran$1;
  }

var Hebrew$1 = {};

var hasRequiredHebrew$1;
  function requireHebrew$1() {
    if (hasRequiredHebrew$1) return Hebrew$1;
    hasRequiredHebrew$1 = 1;
    var set = regenerateExports(0xFB3E);
    set.addRange(0x307, 0x308).addRange(0x591, 0x5C7).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F4).addRange(0xFB1D, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFB4F);
    Hebrew$1.characters = set;
    return Hebrew$1;
  }

var Hiragana$1 = {};

var hasRequiredHiragana$1;
  function requireHiragana$1() {
    if (hasRequiredHiragana$1) return Hiragana$1;
    hasRequiredHiragana$1 = 1;
    var set = regenerateExports(0x3037, 0xFF70, 0x1B132, 0x1F200);
    set.addRange(0x3001, 0x3003).addRange(0x3008, 0x3011).addRange(0x3013, 0x301F).addRange(0x3030, 0x3035).addRange(0x303C, 0x303D).addRange(0x3041, 0x3096).addRange(0x3099, 0x30A0).addRange(0x30FB, 0x30FC).addRange(0xFE45, 0xFE46).addRange(0xFF61, 0xFF65).addRange(0xFF9E, 0xFF9F).addRange(0x1B001, 0x1B11F).addRange(0x1B150, 0x1B152);
    Hiragana$1.characters = set;
    return Hiragana$1;
  }

var Imperial_Aramaic$1 = {};

var hasRequiredImperial_Aramaic$1;
  function requireImperial_Aramaic$1() {
    if (hasRequiredImperial_Aramaic$1) return Imperial_Aramaic$1;
    hasRequiredImperial_Aramaic$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10840, 0x10855).addRange(0x10857, 0x1085F);
    Imperial_Aramaic$1.characters = set;
    return Imperial_Aramaic$1;
  }

var Inherited$1 = {};

var hasRequiredInherited$1;
  function requireInherited$1() {
    if (hasRequiredInherited$1) return Inherited$1;
    hasRequiredInherited$1 = 1;
    var set = regenerateExports(0x30F, 0x312, 0x32F, 0x1DF9, 0x101FD);
    set.addRange(0x314, 0x31F).addRange(0x321, 0x322).addRange(0x326, 0x32C).addRange(0x332, 0x341).addRange(0x343, 0x344).addRange(0x346, 0x357).addRange(0x359, 0x35D).addRange(0x35F, 0x362).addRange(0x953, 0x954).addRange(0x1AB0, 0x1ACE).addRange(0x1DC2, 0x1DF7).addRange(0x1DFB, 0x1DFF).addRange(0x200C, 0x200D).addRange(0x20D0, 0x20EF).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2D).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D167, 0x1D169).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0xE0100, 0xE01EF);
    Inherited$1.characters = set;
    return Inherited$1;
  }

var Inscriptional_Pahlavi$1 = {};

var hasRequiredInscriptional_Pahlavi$1;
  function requireInscriptional_Pahlavi$1() {
    if (hasRequiredInscriptional_Pahlavi$1) return Inscriptional_Pahlavi$1;
    hasRequiredInscriptional_Pahlavi$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10B60, 0x10B72).addRange(0x10B78, 0x10B7F);
    Inscriptional_Pahlavi$1.characters = set;
    return Inscriptional_Pahlavi$1;
  }

var Inscriptional_Parthian$1 = {};

var hasRequiredInscriptional_Parthian$1;
  function requireInscriptional_Parthian$1() {
    if (hasRequiredInscriptional_Parthian$1) return Inscriptional_Parthian$1;
    hasRequiredInscriptional_Parthian$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10B40, 0x10B55).addRange(0x10B58, 0x10B5F);
    Inscriptional_Parthian$1.characters = set;
    return Inscriptional_Parthian$1;
  }

var Javanese$1 = {};

var hasRequiredJavanese$1;
  function requireJavanese$1() {
    if (hasRequiredJavanese$1) return Javanese$1;
    hasRequiredJavanese$1 = 1;
    var set = regenerateExports();
    set.addRange(0xA980, 0xA9CD).addRange(0xA9CF, 0xA9D9).addRange(0xA9DE, 0xA9DF);
    Javanese$1.characters = set;
    return Javanese$1;
  }

var Kaithi$1 = {};

var hasRequiredKaithi$1;
  function requireKaithi$1() {
    if (hasRequiredKaithi$1) return Kaithi$1;
    hasRequiredKaithi$1 = 1;
    var set = regenerateExports(0x2E31, 0x110CD);
    set.addRange(0x966, 0x96F).addRange(0xA830, 0xA839).addRange(0x11080, 0x110C2);
    Kaithi$1.characters = set;
    return Kaithi$1;
  }

var Kannada$1 = {};

var hasRequiredKannada$1;
  function requireKannada$1() {
    if (hasRequiredKannada$1) return Kannada$1;
    hasRequiredKannada$1 = 1;
    var set = regenerateExports(0x1CD0, 0x1CDA, 0x1CF2, 0x1CF4);
    set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xC80, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBC, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCDD, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3).addRange(0x1CD2, 0x1CD3).addRange(0xA830, 0xA835);
    Kannada$1.characters = set;
    return Kannada$1;
  }

var Katakana$1 = {};

var hasRequiredKatakana$1;
  function requireKatakana$1() {
    if (hasRequiredKatakana$1) return Katakana$1;
    hasRequiredKatakana$1 = 1;
    var set = regenerateExports(0x305, 0x323, 0x3037, 0x1B000, 0x1B155);
    set.addRange(0x3001, 0x3003).addRange(0x3008, 0x3011).addRange(0x3013, 0x301F).addRange(0x3030, 0x3035).addRange(0x303C, 0x303D).addRange(0x3099, 0x309C).addRange(0x30A0, 0x30FF).addRange(0x31F0, 0x31FF).addRange(0x32D0, 0x32FE).addRange(0x3300, 0x3357).addRange(0xFE45, 0xFE46).addRange(0xFF61, 0xFF9F).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B120, 0x1B122).addRange(0x1B164, 0x1B167);
    Katakana$1.characters = set;
    return Katakana$1;
  }

var Kawi$1 = {};

var hasRequiredKawi$1;
  function requireKawi$1() {
    if (hasRequiredKawi$1) return Kawi$1;
    hasRequiredKawi$1 = 1;
    var set = regenerateExports();
    set.addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F5A);
    Kawi$1.characters = set;
    return Kawi$1;
  }

var Kayah_Li$1 = {};

var hasRequiredKayah_Li$1;
  function requireKayah_Li$1() {
    if (hasRequiredKayah_Li$1) return Kayah_Li$1;
    hasRequiredKayah_Li$1 = 1;
    var set = regenerateExports();
    set.addRange(0xA900, 0xA92F);
    Kayah_Li$1.characters = set;
    return Kayah_Li$1;
  }

var Kharoshthi$1 = {};

var hasRequiredKharoshthi$1;
  function requireKharoshthi$1() {
    if (hasRequiredKharoshthi$1) return Kharoshthi$1;
    hasRequiredKharoshthi$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10A00, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A38, 0x10A3A).addRange(0x10A3F, 0x10A48).addRange(0x10A50, 0x10A58);
    Kharoshthi$1.characters = set;
    return Kharoshthi$1;
  }

var Khitan_Small_Script$1 = {};

var hasRequiredKhitan_Small_Script$1;
  function requireKhitan_Small_Script$1() {
    if (hasRequiredKhitan_Small_Script$1) return Khitan_Small_Script$1;
    hasRequiredKhitan_Small_Script$1 = 1;
    var set = regenerateExports(0x16FE4, 0x18CFF);
    set.addRange(0x18B00, 0x18CD5);
    Khitan_Small_Script$1.characters = set;
    return Khitan_Small_Script$1;
  }

var Khmer$1 = {};

var hasRequiredKhmer$1;
  function requireKhmer$1() {
    if (hasRequiredKhmer$1) return Khmer$1;
    hasRequiredKhmer$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1780, 0x17DD).addRange(0x17E0, 0x17E9).addRange(0x17F0, 0x17F9).addRange(0x19E0, 0x19FF);
    Khmer$1.characters = set;
    return Khmer$1;
  }

var Khojki$1 = {};

var hasRequiredKhojki$1;
  function requireKhojki$1() {
    if (hasRequiredKhojki$1) return Khojki$1;
    hasRequiredKhojki$1 = 1;
    var set = regenerateExports();
    set.addRange(0xAE6, 0xAEF).addRange(0xA830, 0xA839).addRange(0x11200, 0x11211).addRange(0x11213, 0x11241);
    Khojki$1.characters = set;
    return Khojki$1;
  }

var Khudawadi$1 = {};

var hasRequiredKhudawadi$1;
  function requireKhudawadi$1() {
    if (hasRequiredKhudawadi$1) return Khudawadi$1;
    hasRequiredKhudawadi$1 = 1;
    var set = regenerateExports();
    set.addRange(0x964, 0x965).addRange(0xA830, 0xA839).addRange(0x112B0, 0x112EA).addRange(0x112F0, 0x112F9);
    Khudawadi$1.characters = set;
    return Khudawadi$1;
  }

var Kirat_Rai$1 = {};

var hasRequiredKirat_Rai$1;
  function requireKirat_Rai$1() {
    if (hasRequiredKirat_Rai$1) return Kirat_Rai$1;
    hasRequiredKirat_Rai$1 = 1;
    var set = regenerateExports();
    set.addRange(0x16D40, 0x16D79);
    Kirat_Rai$1.characters = set;
    return Kirat_Rai$1;
  }

var Lao$1 = {};

var hasRequiredLao$1;
  function requireLao$1() {
    if (hasRequiredLao$1) return Lao$1;
    hasRequiredLao$1 = 1;
    var set = regenerateExports(0xE84, 0xEA5, 0xEC6);
    set.addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEC8, 0xECE).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF);
    Lao$1.characters = set;
    return Lao$1;
  }

var Latin$1 = {};

var hasRequiredLatin$1;
  function requireLatin$1() {
    if (hasRequiredLatin$1) return Latin$1;
    hasRequiredLatin$1 = 1;
    var set = regenerateExports(0xAA, 0xB7, 0xBA, 0x2BC, 0x2C7, 0x2CD, 0x2D7, 0x2D9, 0x313, 0x320, 0x358, 0x35E, 0x10FB, 0x1DF8, 0x202F, 0x2071, 0x207F, 0x20F0, 0x2132, 0x214E, 0x2E17, 0xA7D3, 0xA92E);
    set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2B8).addRange(0x2C9, 0x2CB).addRange(0x2E0, 0x2E4).addRange(0x300, 0x30E).addRange(0x310, 0x311).addRange(0x323, 0x325).addRange(0x32D, 0x32E).addRange(0x330, 0x331).addRange(0x363, 0x36F).addRange(0x485, 0x486).addRange(0x951, 0x952).addRange(0x1D00, 0x1D25).addRange(0x1D2C, 0x1D5C).addRange(0x1D62, 0x1D65).addRange(0x1D6B, 0x1D77).addRange(0x1D79, 0x1DBE).addRange(0x1E00, 0x1EFF).addRange(0x2090, 0x209C).addRange(0x212A, 0x212B).addRange(0x2160, 0x2188).addRange(0x2C60, 0x2C7F).addRange(0xA700, 0xA707).addRange(0xA722, 0xA787).addRange(0xA78B, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F2, 0xA7FF).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB64).addRange(0xAB66, 0xAB69).addRange(0xFB00, 0xFB06).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A);
    Latin$1.characters = set;
    return Latin$1;
  }

var Lepcha$1 = {};

var hasRequiredLepcha$1;
  function requireLepcha$1() {
    if (hasRequiredLepcha$1) return Lepcha$1;
    hasRequiredLepcha$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1C00, 0x1C37).addRange(0x1C3B, 0x1C49).addRange(0x1C4D, 0x1C4F);
    Lepcha$1.characters = set;
    return Lepcha$1;
  }

var Limbu$1 = {};

var hasRequiredLimbu$1;
  function requireLimbu$1() {
    if (hasRequiredLimbu$1) return Limbu$1;
    hasRequiredLimbu$1 = 1;
    var set = regenerateExports(0x965, 0x1940);
    set.addRange(0x1900, 0x191E).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1944, 0x194F);
    Limbu$1.characters = set;
    return Limbu$1;
  }

var Linear_A$1 = {};

var hasRequiredLinear_A$1;
  function requireLinear_A$1() {
    if (hasRequiredLinear_A$1) return Linear_A$1;
    hasRequiredLinear_A$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10107, 0x10133).addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767);
    Linear_A$1.characters = set;
    return Linear_A$1;
  }

var Linear_B$1 = {};

var hasRequiredLinear_B$1;
  function requireLinear_B$1() {
    if (hasRequiredLinear_B$1) return Linear_B$1;
    hasRequiredLinear_B$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA).addRange(0x10100, 0x10102).addRange(0x10107, 0x10133).addRange(0x10137, 0x1013F);
    Linear_B$1.characters = set;
    return Linear_B$1;
  }

var Lisu$1 = {};

var hasRequiredLisu$1;
  function requireLisu$1() {
    if (hasRequiredLisu$1) return Lisu$1;
    hasRequiredLisu$1 = 1;
    var set = regenerateExports(0x2BC, 0x2CD, 0x11FB0);
    set.addRange(0x300A, 0x300B).addRange(0xA4D0, 0xA4FF);
    Lisu$1.characters = set;
    return Lisu$1;
  }

var Lycian$1 = {};

var hasRequiredLycian$1;
  function requireLycian$1() {
    if (hasRequiredLycian$1) return Lycian$1;
    hasRequiredLycian$1 = 1;
    var set = regenerateExports(0x205A);
    set.addRange(0x10280, 0x1029C);
    Lycian$1.characters = set;
    return Lycian$1;
  }

var Lydian$1 = {};

var hasRequiredLydian$1;
  function requireLydian$1() {
    if (hasRequiredLydian$1) return Lydian$1;
    hasRequiredLydian$1 = 1;
    var set = regenerateExports(0xB7, 0x2E31, 0x1093F);
    set.addRange(0x10920, 0x10939);
    Lydian$1.characters = set;
    return Lydian$1;
  }

var Mahajani$1 = {};

var hasRequiredMahajani$1;
  function requireMahajani$1() {
    if (hasRequiredMahajani$1) return Mahajani$1;
    hasRequiredMahajani$1 = 1;
    var set = regenerateExports(0xB7);
    set.addRange(0x964, 0x96F).addRange(0xA830, 0xA839).addRange(0x11150, 0x11176);
    Mahajani$1.characters = set;
    return Mahajani$1;
  }

var Makasar$1 = {};

var hasRequiredMakasar$1;
  function requireMakasar$1() {
    if (hasRequiredMakasar$1) return Makasar$1;
    hasRequiredMakasar$1 = 1;
    var set = regenerateExports();
    set.addRange(0x11EE0, 0x11EF8);
    Makasar$1.characters = set;
    return Makasar$1;
  }

var Malayalam$1 = {};

var hasRequiredMalayalam$1;
  function requireMalayalam$1() {
    if (hasRequiredMalayalam$1) return Malayalam$1;
    hasRequiredMalayalam$1 = 1;
    var set = regenerateExports(0x1CDA, 0x1CF2);
    set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4F).addRange(0xD54, 0xD63).addRange(0xD66, 0xD7F).addRange(0xA830, 0xA832);
    Malayalam$1.characters = set;
    return Malayalam$1;
  }

var Mandaic$1 = {};

var hasRequiredMandaic$1;
  function requireMandaic$1() {
    if (hasRequiredMandaic$1) return Mandaic$1;
    hasRequiredMandaic$1 = 1;
    var set = regenerateExports(0x640, 0x85E);
    set.addRange(0x840, 0x85B);
    Mandaic$1.characters = set;
    return Mandaic$1;
  }

var Manichaean$1 = {};

var hasRequiredManichaean$1;
  function requireManichaean$1() {
    if (hasRequiredManichaean$1) return Manichaean$1;
    hasRequiredManichaean$1 = 1;
    var set = regenerateExports(0x640);
    set.addRange(0x10AC0, 0x10AE6).addRange(0x10AEB, 0x10AF6);
    Manichaean$1.characters = set;
    return Manichaean$1;
  }

var Marchen$1 = {};

var hasRequiredMarchen$1;
  function requireMarchen$1() {
    if (hasRequiredMarchen$1) return Marchen$1;
    hasRequiredMarchen$1 = 1;
    var set = regenerateExports();
    set.addRange(0x11C70, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6);
    Marchen$1.characters = set;
    return Marchen$1;
  }

var Masaram_Gondi$1 = {};

var hasRequiredMasaram_Gondi$1;
  function requireMasaram_Gondi$1() {
    if (hasRequiredMasaram_Gondi$1) return Masaram_Gondi$1;
    hasRequiredMasaram_Gondi$1 = 1;
    var set = regenerateExports(0x11D3A);
    set.addRange(0x964, 0x965).addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D47).addRange(0x11D50, 0x11D59);
    Masaram_Gondi$1.characters = set;
    return Masaram_Gondi$1;
  }

var Medefaidrin$1 = {};

var hasRequiredMedefaidrin$1;
  function requireMedefaidrin$1() {
    if (hasRequiredMedefaidrin$1) return Medefaidrin$1;
    hasRequiredMedefaidrin$1 = 1;
    var set = regenerateExports();
    set.addRange(0x16E40, 0x16E9A);
    Medefaidrin$1.characters = set;
    return Medefaidrin$1;
  }

var Meetei_Mayek$1 = {};

var hasRequiredMeetei_Mayek$1;
  function requireMeetei_Mayek$1() {
    if (hasRequiredMeetei_Mayek$1) return Meetei_Mayek$1;
    hasRequiredMeetei_Mayek$1 = 1;
    var set = regenerateExports();
    set.addRange(0xAAE0, 0xAAF6).addRange(0xABC0, 0xABED).addRange(0xABF0, 0xABF9);
    Meetei_Mayek$1.characters = set;
    return Meetei_Mayek$1;
  }

var Mende_Kikakui$1 = {};

var hasRequiredMende_Kikakui$1;
  function requireMende_Kikakui$1() {
    if (hasRequiredMende_Kikakui$1) return Mende_Kikakui$1;
    hasRequiredMende_Kikakui$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1E800, 0x1E8C4).addRange(0x1E8C7, 0x1E8D6);
    Mende_Kikakui$1.characters = set;
    return Mende_Kikakui$1;
  }

var Meroitic_Cursive$1 = {};

var hasRequiredMeroitic_Cursive$1;
  function requireMeroitic_Cursive$1() {
    if (hasRequiredMeroitic_Cursive$1) return Meroitic_Cursive$1;
    hasRequiredMeroitic_Cursive$1 = 1;
    var set = regenerateExports();
    set.addRange(0x109A0, 0x109B7).addRange(0x109BC, 0x109CF).addRange(0x109D2, 0x109FF);
    Meroitic_Cursive$1.characters = set;
    return Meroitic_Cursive$1;
  }

var Meroitic_Hieroglyphs$1 = {};

var hasRequiredMeroitic_Hieroglyphs$1;
  function requireMeroitic_Hieroglyphs$1() {
    if (hasRequiredMeroitic_Hieroglyphs$1) return Meroitic_Hieroglyphs$1;
    hasRequiredMeroitic_Hieroglyphs$1 = 1;
    var set = regenerateExports(0x205D);
    set.addRange(0x10980, 0x1099F);
    Meroitic_Hieroglyphs$1.characters = set;
    return Meroitic_Hieroglyphs$1;
  }

var Miao$1 = {};

var hasRequiredMiao$1;
  function requireMiao$1() {
    if (hasRequiredMiao$1) return Miao$1;
    hasRequiredMiao$1 = 1;
    var set = regenerateExports();
    set.addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F);
    Miao$1.characters = set;
    return Miao$1;
  }

var Modi$1 = {};

var hasRequiredModi$1;
  function requireModi$1() {
    if (hasRequiredModi$1) return Modi$1;
    hasRequiredModi$1 = 1;
    var set = regenerateExports();
    set.addRange(0xA830, 0xA839).addRange(0x11600, 0x11644).addRange(0x11650, 0x11659);
    Modi$1.characters = set;
    return Modi$1;
  }

var Mongolian$1 = {};

var hasRequiredMongolian$1;
  function requireMongolian$1() {
    if (hasRequiredMongolian$1) return Mongolian$1;
    hasRequiredMongolian$1 = 1;
    var set = regenerateExports(0x202F);
    set.addRange(0x1800, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x3001, 0x3002).addRange(0x3008, 0x300B).addRange(0x11660, 0x1166C);
    Mongolian$1.characters = set;
    return Mongolian$1;
  }

var Mro$1 = {};

var hasRequiredMro$1;
  function requireMro$1() {
    if (hasRequiredMro$1) return Mro$1;
    hasRequiredMro$1 = 1;
    var set = regenerateExports();
    set.addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A6E, 0x16A6F);
    Mro$1.characters = set;
    return Mro$1;
  }

var Multani$1 = {};

var hasRequiredMultani$1;
  function requireMultani$1() {
    if (hasRequiredMultani$1) return Multani$1;
    hasRequiredMultani$1 = 1;
    var set = regenerateExports(0x11288);
    set.addRange(0xA66, 0xA6F).addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A9);
    Multani$1.characters = set;
    return Multani$1;
  }

var Myanmar$1 = {};

var hasRequiredMyanmar$1;
  function requireMyanmar$1() {
    if (hasRequiredMyanmar$1) return Myanmar$1;
    hasRequiredMyanmar$1 = 1;
    var set = regenerateExports(0xA92E);
    set.addRange(0x1000, 0x109F).addRange(0xA9E0, 0xA9FE).addRange(0xAA60, 0xAA7F).addRange(0x116D0, 0x116E3);
    Myanmar$1.characters = set;
    return Myanmar$1;
  }

var Nabataean$1 = {};

var hasRequiredNabataean$1;
  function requireNabataean$1() {
    if (hasRequiredNabataean$1) return Nabataean$1;
    hasRequiredNabataean$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10880, 0x1089E).addRange(0x108A7, 0x108AF);
    Nabataean$1.characters = set;
    return Nabataean$1;
  }

var Nag_Mundari$1 = {};

var hasRequiredNag_Mundari$1;
  function requireNag_Mundari$1() {
    if (hasRequiredNag_Mundari$1) return Nag_Mundari$1;
    hasRequiredNag_Mundari$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1E4D0, 0x1E4F9);
    Nag_Mundari$1.characters = set;
    return Nag_Mundari$1;
  }

var Nandinagari$1 = {};

var hasRequiredNandinagari$1;
  function requireNandinagari$1() {
    if (hasRequiredNandinagari$1) return Nandinagari$1;
    hasRequiredNandinagari$1 = 1;
    var set = regenerateExports(0x1CE9, 0x1CF2, 0x1CFA);
    set.addRange(0x964, 0x965).addRange(0xCE6, 0xCEF).addRange(0xA830, 0xA835).addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D7).addRange(0x119DA, 0x119E4);
    Nandinagari$1.characters = set;
    return Nandinagari$1;
  }

var New_Tai_Lue$1 = {};

var hasRequiredNew_Tai_Lue$1;
  function requireNew_Tai_Lue$1() {
    if (hasRequiredNew_Tai_Lue$1) return New_Tai_Lue$1;
    hasRequiredNew_Tai_Lue$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x19DE, 0x19DF);
    New_Tai_Lue$1.characters = set;
    return New_Tai_Lue$1;
  }

var Newa$1 = {};

var hasRequiredNewa$1;
  function requireNewa$1() {
    if (hasRequiredNewa$1) return Newa$1;
    hasRequiredNewa$1 = 1;
    var set = regenerateExports();
    set.addRange(0x11400, 0x1145B).addRange(0x1145D, 0x11461);
    Newa$1.characters = set;
    return Newa$1;
  }

var Nko$1 = {};

var hasRequiredNko$1;
  function requireNko$1() {
    if (hasRequiredNko$1) return Nko$1;
    hasRequiredNko$1 = 1;
    var set = regenerateExports(0x60C, 0x61B, 0x61F);
    set.addRange(0x7C0, 0x7FA).addRange(0x7FD, 0x7FF).addRange(0xFD3E, 0xFD3F);
    Nko$1.characters = set;
    return Nko$1;
  }

var Nushu$1 = {};

var hasRequiredNushu$1;
  function requireNushu$1() {
    if (hasRequiredNushu$1) return Nushu$1;
    hasRequiredNushu$1 = 1;
    var set = regenerateExports(0x16FE1);
    set.addRange(0x1B170, 0x1B2FB);
    Nushu$1.characters = set;
    return Nushu$1;
  }

var Nyiakeng_Puachue_Hmong$1 = {};

var hasRequiredNyiakeng_Puachue_Hmong$1;
  function requireNyiakeng_Puachue_Hmong$1() {
    if (hasRequiredNyiakeng_Puachue_Hmong$1) return Nyiakeng_Puachue_Hmong$1;
    hasRequiredNyiakeng_Puachue_Hmong$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1E100, 0x1E12C).addRange(0x1E130, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E14E, 0x1E14F);
    Nyiakeng_Puachue_Hmong$1.characters = set;
    return Nyiakeng_Puachue_Hmong$1;
  }

var Ogham$1 = {};

var hasRequiredOgham$1;
  function requireOgham$1() {
    if (hasRequiredOgham$1) return Ogham$1;
    hasRequiredOgham$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1680, 0x169C);
    Ogham$1.characters = set;
    return Ogham$1;
  }

var Ol_Chiki$1 = {};

var hasRequiredOl_Chiki$1;
  function requireOl_Chiki$1() {
    if (hasRequiredOl_Chiki$1) return Ol_Chiki$1;
    hasRequiredOl_Chiki$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1C50, 0x1C7F);
    Ol_Chiki$1.characters = set;
    return Ol_Chiki$1;
  }

var Ol_Onal$1 = {};

var hasRequiredOl_Onal$1;
  function requireOl_Onal$1() {
    if (hasRequiredOl_Onal$1) return Ol_Onal$1;
    hasRequiredOl_Onal$1 = 1;
    var set = regenerateExports(0x1E5FF);
    set.addRange(0x964, 0x965).addRange(0x1E5D0, 0x1E5FA);
    Ol_Onal$1.characters = set;
    return Ol_Onal$1;
  }

var Old_Hungarian$1 = {};

var hasRequiredOld_Hungarian$1;
  function requireOld_Hungarian$1() {
    if (hasRequiredOld_Hungarian$1) return Old_Hungarian$1;
    hasRequiredOld_Hungarian$1 = 1;
    var set = regenerateExports(0x205A, 0x205D, 0x2E31, 0x2E41);
    set.addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10CFA, 0x10CFF);
    Old_Hungarian$1.characters = set;
    return Old_Hungarian$1;
  }

var Old_Italic$1 = {};

var hasRequiredOld_Italic$1;
  function requireOld_Italic$1() {
    if (hasRequiredOld_Italic$1) return Old_Italic$1;
    hasRequiredOld_Italic$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10300, 0x10323).addRange(0x1032D, 0x1032F);
    Old_Italic$1.characters = set;
    return Old_Italic$1;
  }

var Old_North_Arabian$1 = {};

var hasRequiredOld_North_Arabian$1;
  function requireOld_North_Arabian$1() {
    if (hasRequiredOld_North_Arabian$1) return Old_North_Arabian$1;
    hasRequiredOld_North_Arabian$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10A80, 0x10A9F);
    Old_North_Arabian$1.characters = set;
    return Old_North_Arabian$1;
  }

var Old_Permic$1 = {};

var hasRequiredOld_Permic$1;
  function requireOld_Permic$1() {
    if (hasRequiredOld_Permic$1) return Old_Permic$1;
    hasRequiredOld_Permic$1 = 1;
    var set = regenerateExports(0xB7, 0x300, 0x313, 0x483);
    set.addRange(0x306, 0x308).addRange(0x10350, 0x1037A);
    Old_Permic$1.characters = set;
    return Old_Permic$1;
  }

var Old_Persian$1 = {};

var hasRequiredOld_Persian$1;
  function requireOld_Persian$1() {
    if (hasRequiredOld_Persian$1) return Old_Persian$1;
    hasRequiredOld_Persian$1 = 1;
    var set = regenerateExports();
    set.addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103D5);
    Old_Persian$1.characters = set;
    return Old_Persian$1;
  }

var Old_Sogdian$1 = {};

var hasRequiredOld_Sogdian$1;
  function requireOld_Sogdian$1() {
    if (hasRequiredOld_Sogdian$1) return Old_Sogdian$1;
    hasRequiredOld_Sogdian$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10F00, 0x10F27);
    Old_Sogdian$1.characters = set;
    return Old_Sogdian$1;
  }

var Old_South_Arabian$1 = {};

var hasRequiredOld_South_Arabian$1;
  function requireOld_South_Arabian$1() {
    if (hasRequiredOld_South_Arabian$1) return Old_South_Arabian$1;
    hasRequiredOld_South_Arabian$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10A60, 0x10A7F);
    Old_South_Arabian$1.characters = set;
    return Old_South_Arabian$1;
  }

var Old_Turkic$1 = {};

var hasRequiredOld_Turkic$1;
  function requireOld_Turkic$1() {
    if (hasRequiredOld_Turkic$1) return Old_Turkic$1;
    hasRequiredOld_Turkic$1 = 1;
    var set = regenerateExports(0x205A, 0x2E30);
    set.addRange(0x10C00, 0x10C48);
    Old_Turkic$1.characters = set;
    return Old_Turkic$1;
  }

var Old_Uyghur$1 = {};

var hasRequiredOld_Uyghur$1;
  function requireOld_Uyghur$1() {
    if (hasRequiredOld_Uyghur$1) return Old_Uyghur$1;
    hasRequiredOld_Uyghur$1 = 1;
    var set = regenerateExports(0x640, 0x10AF2);
    set.addRange(0x10F70, 0x10F89);
    Old_Uyghur$1.characters = set;
    return Old_Uyghur$1;
  }

var Oriya$1 = {};

var hasRequiredOriya$1;
  function requireOriya$1() {
    if (hasRequiredOriya$1) return Oriya$1;
    hasRequiredOriya$1 = 1;
    var set = regenerateExports(0x1CDA, 0x1CF2);
    set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3C, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB66, 0xB77);
    Oriya$1.characters = set;
    return Oriya$1;
  }

var Osage$1 = {};

var hasRequiredOsage$1;
  function requireOsage$1() {
    if (hasRequiredOsage$1) return Osage$1;
    hasRequiredOsage$1 = 1;
    var set = regenerateExports(0x301, 0x304, 0x30B, 0x358);
    set.addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB);
    Osage$1.characters = set;
    return Osage$1;
  }

var Osmanya$1 = {};

var hasRequiredOsmanya$1;
  function requireOsmanya$1() {
    if (hasRequiredOsmanya$1) return Osmanya$1;
    hasRequiredOsmanya$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10480, 0x1049D).addRange(0x104A0, 0x104A9);
    Osmanya$1.characters = set;
    return Osmanya$1;
  }

var Pahawh_Hmong$1 = {};

var hasRequiredPahawh_Hmong$1;
  function requirePahawh_Hmong$1() {
    if (hasRequiredPahawh_Hmong$1) return Pahawh_Hmong$1;
    hasRequiredPahawh_Hmong$1 = 1;
    var set = regenerateExports();
    set.addRange(0x16B00, 0x16B45).addRange(0x16B50, 0x16B59).addRange(0x16B5B, 0x16B61).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F);
    Pahawh_Hmong$1.characters = set;
    return Pahawh_Hmong$1;
  }

var Palmyrene$1 = {};

var hasRequiredPalmyrene$1;
  function requirePalmyrene$1() {
    if (hasRequiredPalmyrene$1) return Palmyrene$1;
    hasRequiredPalmyrene$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10860, 0x1087F);
    Palmyrene$1.characters = set;
    return Palmyrene$1;
  }

var Pau_Cin_Hau$1 = {};

var hasRequiredPau_Cin_Hau$1;
  function requirePau_Cin_Hau$1() {
    if (hasRequiredPau_Cin_Hau$1) return Pau_Cin_Hau$1;
    hasRequiredPau_Cin_Hau$1 = 1;
    var set = regenerateExports();
    set.addRange(0x11AC0, 0x11AF8);
    Pau_Cin_Hau$1.characters = set;
    return Pau_Cin_Hau$1;
  }

var Phags_Pa$1 = {};

var hasRequiredPhags_Pa$1;
  function requirePhags_Pa$1() {
    if (hasRequiredPhags_Pa$1) return Phags_Pa$1;
    hasRequiredPhags_Pa$1 = 1;
    var set = regenerateExports(0x1805, 0x202F, 0x3002);
    set.addRange(0x1802, 0x1803).addRange(0xA840, 0xA877);
    Phags_Pa$1.characters = set;
    return Phags_Pa$1;
  }

var Phoenician$1 = {};

var hasRequiredPhoenician$1;
  function requirePhoenician$1() {
    if (hasRequiredPhoenician$1) return Phoenician$1;
    hasRequiredPhoenician$1 = 1;
    var set = regenerateExports(0x1091F);
    set.addRange(0x10900, 0x1091B);
    Phoenician$1.characters = set;
    return Phoenician$1;
  }

var Psalter_Pahlavi$1 = {};

var hasRequiredPsalter_Pahlavi$1;
  function requirePsalter_Pahlavi$1() {
    if (hasRequiredPsalter_Pahlavi$1) return Psalter_Pahlavi$1;
    hasRequiredPsalter_Pahlavi$1 = 1;
    var set = regenerateExports(0x640);
    set.addRange(0x10B80, 0x10B91).addRange(0x10B99, 0x10B9C).addRange(0x10BA9, 0x10BAF);
    Psalter_Pahlavi$1.characters = set;
    return Psalter_Pahlavi$1;
  }

var Rejang$1 = {};

var hasRequiredRejang$1;
  function requireRejang$1() {
    if (hasRequiredRejang$1) return Rejang$1;
    hasRequiredRejang$1 = 1;
    var set = regenerateExports(0xA95F);
    set.addRange(0xA930, 0xA953);
    Rejang$1.characters = set;
    return Rejang$1;
  }

var Runic$1 = {};

var hasRequiredRunic$1;
  function requireRunic$1() {
    if (hasRequiredRunic$1) return Runic$1;
    hasRequiredRunic$1 = 1;
    var set = regenerateExports();
    set.addRange(0x16A0, 0x16F8);
    Runic$1.characters = set;
    return Runic$1;
  }

var Samaritan$1 = {};

var hasRequiredSamaritan$1;
  function requireSamaritan$1() {
    if (hasRequiredSamaritan$1) return Samaritan$1;
    hasRequiredSamaritan$1 = 1;
    var set = regenerateExports(0x2E31);
    set.addRange(0x800, 0x82D).addRange(0x830, 0x83E);
    Samaritan$1.characters = set;
    return Samaritan$1;
  }

var Saurashtra$1 = {};

var hasRequiredSaurashtra$1;
  function requireSaurashtra$1() {
    if (hasRequiredSaurashtra$1) return Saurashtra$1;
    hasRequiredSaurashtra$1 = 1;
    var set = regenerateExports();
    set.addRange(0xA880, 0xA8C5).addRange(0xA8CE, 0xA8D9);
    Saurashtra$1.characters = set;
    return Saurashtra$1;
  }

var Sharada$1 = {};

var hasRequiredSharada$1;
  function requireSharada$1() {
    if (hasRequiredSharada$1) return Sharada$1;
    hasRequiredSharada$1 = 1;
    var set = regenerateExports(0x951, 0x1CD7, 0x1CD9, 0x1CE0, 0xA838);
    set.addRange(0x1CDC, 0x1CDD).addRange(0xA830, 0xA835).addRange(0x11180, 0x111DF);
    Sharada$1.characters = set;
    return Sharada$1;
  }

var Shavian$1 = {};

var hasRequiredShavian$1;
  function requireShavian$1() {
    if (hasRequiredShavian$1) return Shavian$1;
    hasRequiredShavian$1 = 1;
    var set = regenerateExports(0xB7);
    set.addRange(0x10450, 0x1047F);
    Shavian$1.characters = set;
    return Shavian$1;
  }

var Siddham$1 = {};

var hasRequiredSiddham$1;
  function requireSiddham$1() {
    if (hasRequiredSiddham$1) return Siddham$1;
    hasRequiredSiddham$1 = 1;
    var set = regenerateExports();
    set.addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115DD);
    Siddham$1.characters = set;
    return Siddham$1;
  }

var SignWriting$1 = {};

var hasRequiredSignWriting$1;
  function requireSignWriting$1() {
    if (hasRequiredSignWriting$1) return SignWriting$1;
    hasRequiredSignWriting$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1D800, 0x1DA8B).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF);
    SignWriting$1.characters = set;
    return SignWriting$1;
  }

var Sinhala$1 = {};

var hasRequiredSinhala$1;
  function requireSinhala$1() {
    if (hasRequiredSinhala$1) return Sinhala$1;
    hasRequiredSinhala$1 = 1;
    var set = regenerateExports(0xDBD, 0xDCA, 0xDD6, 0x1CF2);
    set.addRange(0x964, 0x965).addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF4).addRange(0x111E1, 0x111F4);
    Sinhala$1.characters = set;
    return Sinhala$1;
  }

var Sogdian$1 = {};

var hasRequiredSogdian$1;
  function requireSogdian$1() {
    if (hasRequiredSogdian$1) return Sogdian$1;
    hasRequiredSogdian$1 = 1;
    var set = regenerateExports(0x640);
    set.addRange(0x10F30, 0x10F59);
    Sogdian$1.characters = set;
    return Sogdian$1;
  }

var Sora_Sompeng$1 = {};

var hasRequiredSora_Sompeng$1;
  function requireSora_Sompeng$1() {
    if (hasRequiredSora_Sompeng$1) return Sora_Sompeng$1;
    hasRequiredSora_Sompeng$1 = 1;
    var set = regenerateExports();
    set.addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9);
    Sora_Sompeng$1.characters = set;
    return Sora_Sompeng$1;
  }

var Soyombo$1 = {};

var hasRequiredSoyombo$1;
  function requireSoyombo$1() {
    if (hasRequiredSoyombo$1) return Soyombo$1;
    hasRequiredSoyombo$1 = 1;
    var set = regenerateExports();
    set.addRange(0x11A50, 0x11AA2);
    Soyombo$1.characters = set;
    return Soyombo$1;
  }

var Sundanese$1 = {};

var hasRequiredSundanese$1;
  function requireSundanese$1() {
    if (hasRequiredSundanese$1) return Sundanese$1;
    hasRequiredSundanese$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1B80, 0x1BBF).addRange(0x1CC0, 0x1CC7);
    Sundanese$1.characters = set;
    return Sundanese$1;
  }

var Sunuwar$1 = {};

var hasRequiredSunuwar$1;
  function requireSunuwar$1() {
    if (hasRequiredSunuwar$1) return Sunuwar$1;
    hasRequiredSunuwar$1 = 1;
    var set = regenerateExports(0x303, 0x30D, 0x310, 0x32D, 0x331);
    set.addRange(0x300, 0x301).addRange(0x11BC0, 0x11BE1).addRange(0x11BF0, 0x11BF9);
    Sunuwar$1.characters = set;
    return Sunuwar$1;
  }

var Syloti_Nagri$1 = {};

var hasRequiredSyloti_Nagri$1;
  function requireSyloti_Nagri$1() {
    if (hasRequiredSyloti_Nagri$1) return Syloti_Nagri$1;
    hasRequiredSyloti_Nagri$1 = 1;
    var set = regenerateExports();
    set.addRange(0x964, 0x965).addRange(0x9E6, 0x9EF).addRange(0xA800, 0xA82C);
    Syloti_Nagri$1.characters = set;
    return Syloti_Nagri$1;
  }

var Syriac$1 = {};

var hasRequiredSyriac$1;
  function requireSyriac$1() {
    if (hasRequiredSyriac$1) return Syriac$1;
    hasRequiredSyriac$1 = 1;
    var set = regenerateExports(0x30A, 0x320, 0x330, 0x60C, 0x61F, 0x640, 0x670, 0x1DF8, 0x1DFA);
    set.addRange(0x303, 0x304).addRange(0x307, 0x308).addRange(0x323, 0x325).addRange(0x32D, 0x32E).addRange(0x61B, 0x61C).addRange(0x64B, 0x655).addRange(0x700, 0x70D).addRange(0x70F, 0x74A).addRange(0x74D, 0x74F).addRange(0x860, 0x86A);
    Syriac$1.characters = set;
    return Syriac$1;
  }

var Tagalog$1 = {};

var hasRequiredTagalog$1;
  function requireTagalog$1() {
    if (hasRequiredTagalog$1) return Tagalog$1;
    hasRequiredTagalog$1 = 1;
    var set = regenerateExports(0x171F);
    set.addRange(0x1700, 0x1715).addRange(0x1735, 0x1736);
    Tagalog$1.characters = set;
    return Tagalog$1;
  }

var Tagbanwa$1 = {};

var hasRequiredTagbanwa$1;
  function requireTagbanwa$1() {
    if (hasRequiredTagbanwa$1) return Tagbanwa$1;
    hasRequiredTagbanwa$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1735, 0x1736).addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773);
    Tagbanwa$1.characters = set;
    return Tagbanwa$1;
  }

var Tai_Le$1 = {};

var hasRequiredTai_Le$1;
  function requireTai_Le$1() {
    if (hasRequiredTai_Le$1) return Tai_Le$1;
    hasRequiredTai_Le$1 = 1;
    var set = regenerateExports(0x30C);
    set.addRange(0x300, 0x301).addRange(0x307, 0x308).addRange(0x1040, 0x1049).addRange(0x1950, 0x196D).addRange(0x1970, 0x1974);
    Tai_Le$1.characters = set;
    return Tai_Le$1;
  }

var Tai_Tham$1 = {};

var hasRequiredTai_Tham$1;
  function requireTai_Tham$1() {
    if (hasRequiredTai_Tham$1) return Tai_Tham$1;
    hasRequiredTai_Tham$1 = 1;
    var set = regenerateExports();
    set.addRange(0x1A20, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1A7F, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AA0, 0x1AAD);
    Tai_Tham$1.characters = set;
    return Tai_Tham$1;
  }

var Tai_Viet$1 = {};

var hasRequiredTai_Viet$1;
  function requireTai_Viet$1() {
    if (hasRequiredTai_Viet$1) return Tai_Viet$1;
    hasRequiredTai_Viet$1 = 1;
    var set = regenerateExports();
    set.addRange(0xAA80, 0xAAC2).addRange(0xAADB, 0xAADF);
    Tai_Viet$1.characters = set;
    return Tai_Viet$1;
  }

var Takri$1 = {};

var hasRequiredTakri$1;
  function requireTakri$1() {
    if (hasRequiredTakri$1) return Takri$1;
    hasRequiredTakri$1 = 1;
    var set = regenerateExports();
    set.addRange(0x964, 0x965).addRange(0xA830, 0xA839).addRange(0x11680, 0x116B9).addRange(0x116C0, 0x116C9);
    Takri$1.characters = set;
    return Takri$1;
  }

var Tamil$1 = {};

var hasRequiredTamil$1;
  function requireTamil$1() {
    if (hasRequiredTamil$1) return Tamil$1;
    hasRequiredTamil$1 = 1;
    var set = regenerateExports(0xB9C, 0xBD0, 0xBD7, 0x1CDA, 0xA8F3, 0x11301, 0x11303, 0x11FFF);
    set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD).addRange(0xBE6, 0xBFA).addRange(0x1133B, 0x1133C).addRange(0x11FC0, 0x11FF1);
    Tamil$1.characters = set;
    return Tamil$1;
  }

var Tangsa$1 = {};

var hasRequiredTangsa$1;
  function requireTangsa$1() {
    if (hasRequiredTangsa$1) return Tangsa$1;
    hasRequiredTangsa$1 = 1;
    var set = regenerateExports();
    set.addRange(0x16A70, 0x16ABE).addRange(0x16AC0, 0x16AC9);
    Tangsa$1.characters = set;
    return Tangsa$1;
  }

var Tangut$1 = {};

var hasRequiredTangut$1;
  function requireTangut$1() {
    if (hasRequiredTangut$1) return Tangut$1;
    hasRequiredTangut$1 = 1;
    var set = regenerateExports(0x31EF, 0x16FE0);
    set.addRange(0x2FF0, 0x2FFF).addRange(0x17000, 0x187F7).addRange(0x18800, 0x18AFF).addRange(0x18D00, 0x18D08);
    Tangut$1.characters = set;
    return Tangut$1;
  }

var Telugu$1 = {};

var hasRequiredTelugu$1;
  function requireTelugu$1() {
    if (hasRequiredTelugu$1) return Telugu$1;
    hasRequiredTelugu$1 = 1;
    var set = regenerateExports(0xC5D, 0x1CDA, 0x1CF2);
    set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3C, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC60, 0xC63).addRange(0xC66, 0xC6F).addRange(0xC77, 0xC7F);
    Telugu$1.characters = set;
    return Telugu$1;
  }

var Thaana$1 = {};

var hasRequiredThaana$1;
  function requireThaana$1() {
    if (hasRequiredThaana$1) return Thaana$1;
    hasRequiredThaana$1 = 1;
    var set = regenerateExports(0x60C, 0x61F, 0xFDF2, 0xFDFD);
    set.addRange(0x61B, 0x61C).addRange(0x660, 0x669).addRange(0x780, 0x7B1);
    Thaana$1.characters = set;
    return Thaana$1;
  }

var Thai$1 = {};

var hasRequiredThai$1;
  function requireThai$1() {
    if (hasRequiredThai$1) return Thai$1;
    hasRequiredThai$1 = 1;
    var set = regenerateExports(0x2BC, 0x2D7, 0x303, 0x331);
    set.addRange(0xE01, 0xE3A).addRange(0xE40, 0xE5B);
    Thai$1.characters = set;
    return Thai$1;
  }

var Tibetan$1 = {};

var hasRequiredTibetan$1;
  function requireTibetan$1() {
    if (hasRequiredTibetan$1) return Tibetan$1;
    hasRequiredTibetan$1 = 1;
    var set = regenerateExports();
    set.addRange(0xF00, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF97).addRange(0xF99, 0xFBC).addRange(0xFBE, 0xFCC).addRange(0xFCE, 0xFD4).addRange(0xFD9, 0xFDA).addRange(0x3008, 0x300B);
    Tibetan$1.characters = set;
    return Tibetan$1;
  }

var Tifinagh$1 = {};

var hasRequiredTifinagh$1;
  function requireTifinagh$1() {
    if (hasRequiredTifinagh$1) return Tifinagh$1;
    hasRequiredTifinagh$1 = 1;
    var set = regenerateExports(0x302, 0x304, 0x307, 0x309, 0x2D7F);
    set.addRange(0x2D30, 0x2D67).addRange(0x2D6F, 0x2D70);
    Tifinagh$1.characters = set;
    return Tifinagh$1;
  }

var Tirhuta$1 = {};

var hasRequiredTirhuta$1;
  function requireTirhuta$1() {
    if (hasRequiredTirhuta$1) return Tirhuta$1;
    hasRequiredTirhuta$1 = 1;
    var set = regenerateExports(0x1CF2);
    set.addRange(0x951, 0x952).addRange(0x964, 0x965).addRange(0xA830, 0xA839).addRange(0x11480, 0x114C7).addRange(0x114D0, 0x114D9);
    Tirhuta$1.characters = set;
    return Tirhuta$1;
  }

var Todhri$1 = {};

var hasRequiredTodhri$1;
  function requireTodhri$1() {
    if (hasRequiredTodhri$1) return Todhri$1;
    hasRequiredTodhri$1 = 1;
    var set = regenerateExports(0x301, 0x304, 0x307, 0x311, 0x313, 0x35E);
    set.addRange(0x105C0, 0x105F3);
    Todhri$1.characters = set;
    return Todhri$1;
  }

var Toto$1 = {};

var hasRequiredToto$1;
  function requireToto$1() {
    if (hasRequiredToto$1) return Toto$1;
    hasRequiredToto$1 = 1;
    var set = regenerateExports(0x2BC);
    set.addRange(0x1E290, 0x1E2AE);
    Toto$1.characters = set;
    return Toto$1;
  }

var Tulu_Tigalari$1 = {};

var hasRequiredTulu_Tigalari$1;
  function requireTulu_Tigalari$1() {
    if (hasRequiredTulu_Tigalari$1) return Tulu_Tigalari$1;
    hasRequiredTulu_Tigalari$1 = 1;
    var set = regenerateExports(0x1CF2, 0x1CF4, 0xA8F1, 0x1138B, 0x1138E, 0x113C2, 0x113C5);
    set.addRange(0xCE6, 0xCEF).addRange(0xA830, 0xA835).addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x113E1, 0x113E2);
    Tulu_Tigalari$1.characters = set;
    return Tulu_Tigalari$1;
  }

var Ugaritic$1 = {};

var hasRequiredUgaritic$1;
  function requireUgaritic$1() {
    if (hasRequiredUgaritic$1) return Ugaritic$1;
    hasRequiredUgaritic$1 = 1;
    var set = regenerateExports(0x1039F);
    set.addRange(0x10380, 0x1039D);
    Ugaritic$1.characters = set;
    return Ugaritic$1;
  }

var Vai$1 = {};

var hasRequiredVai$1;
  function requireVai$1() {
    if (hasRequiredVai$1) return Vai$1;
    hasRequiredVai$1 = 1;
    var set = regenerateExports();
    set.addRange(0xA500, 0xA62B);
    Vai$1.characters = set;
    return Vai$1;
  }

var Vithkuqi$1 = {};

var hasRequiredVithkuqi$1;
  function requireVithkuqi$1() {
    if (hasRequiredVithkuqi$1) return Vithkuqi$1;
    hasRequiredVithkuqi$1 = 1;
    var set = regenerateExports();
    set.addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC);
    Vithkuqi$1.characters = set;
    return Vithkuqi$1;
  }

var Wancho$1 = {};

var hasRequiredWancho$1;
  function requireWancho$1() {
    if (hasRequiredWancho$1) return Wancho$1;
    hasRequiredWancho$1 = 1;
    var set = regenerateExports(0x1E2FF);
    set.addRange(0x1E2C0, 0x1E2F9);
    Wancho$1.characters = set;
    return Wancho$1;
  }

var Warang_Citi$1 = {};

var hasRequiredWarang_Citi$1;
  function requireWarang_Citi$1() {
    if (hasRequiredWarang_Citi$1) return Warang_Citi$1;
    hasRequiredWarang_Citi$1 = 1;
    var set = regenerateExports(0x118FF);
    set.addRange(0x118A0, 0x118F2);
    Warang_Citi$1.characters = set;
    return Warang_Citi$1;
  }

var Yezidi$1 = {};

var hasRequiredYezidi$1;
  function requireYezidi$1() {
    if (hasRequiredYezidi$1) return Yezidi$1;
    hasRequiredYezidi$1 = 1;
    var set = regenerateExports(0x60C, 0x61B, 0x61F);
    set.addRange(0x660, 0x669).addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAD).addRange(0x10EB0, 0x10EB1);
    Yezidi$1.characters = set;
    return Yezidi$1;
  }

var Yi$1 = {};

var hasRequiredYi$1;
  function requireYi$1() {
    if (hasRequiredYi$1) return Yi$1;
    hasRequiredYi$1 = 1;
    var set = regenerateExports(0x30FB);
    set.addRange(0x3001, 0x3002).addRange(0x3008, 0x3011).addRange(0x3014, 0x301B).addRange(0xA000, 0xA48C).addRange(0xA490, 0xA4C6).addRange(0xFF61, 0xFF65);
    Yi$1.characters = set;
    return Yi$1;
  }

var Zanabazar_Square$1 = {};

var hasRequiredZanabazar_Square$1;
  function requireZanabazar_Square$1() {
    if (hasRequiredZanabazar_Square$1) return Zanabazar_Square$1;
    hasRequiredZanabazar_Square$1 = 1;
    var set = regenerateExports();
    set.addRange(0x11A00, 0x11A47);
    Zanabazar_Square$1.characters = set;
    return Zanabazar_Square$1;
  }

var Adlam = {};

var hasRequiredAdlam;
  function requireAdlam() {
    if (hasRequiredAdlam) return Adlam;
    hasRequiredAdlam = 1;
    var set = regenerateExports();
    set.addRange(0x1E900, 0x1E94B).addRange(0x1E950, 0x1E959).addRange(0x1E95E, 0x1E95F);
    Adlam.characters = set;
    return Adlam;
  }

var Ahom = {};

var hasRequiredAhom;
  function requireAhom() {
    if (hasRequiredAhom) return Ahom;
    hasRequiredAhom = 1;
    var set = regenerateExports();
    set.addRange(0x11700, 0x1171A).addRange(0x1171D, 0x1172B).addRange(0x11730, 0x11746);
    Ahom.characters = set;
    return Ahom;
  }

var Anatolian_Hieroglyphs = {};

var hasRequiredAnatolian_Hieroglyphs;
  function requireAnatolian_Hieroglyphs() {
    if (hasRequiredAnatolian_Hieroglyphs) return Anatolian_Hieroglyphs;
    hasRequiredAnatolian_Hieroglyphs = 1;
    var set = regenerateExports();
    set.addRange(0x14400, 0x14646);
    Anatolian_Hieroglyphs.characters = set;
    return Anatolian_Hieroglyphs;
  }

var Arabic = {};

var hasRequiredArabic;
  function requireArabic() {
    if (hasRequiredArabic) return Arabic;
    hasRequiredArabic = 1;
    var set = regenerateExports(0xFDCF, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE64, 0x1EE7E);
    set.addRange(0x600, 0x604).addRange(0x606, 0x60B).addRange(0x60D, 0x61A).addRange(0x61C, 0x61E).addRange(0x620, 0x63F).addRange(0x641, 0x64A).addRange(0x656, 0x66F).addRange(0x671, 0x6DC).addRange(0x6DE, 0x6FF).addRange(0x750, 0x77F).addRange(0x870, 0x88E).addRange(0x890, 0x891).addRange(0x897, 0x8E1).addRange(0x8E3, 0x8FF).addRange(0xFB50, 0xFBC2).addRange(0xFBD3, 0xFD3D).addRange(0xFD40, 0xFD8F).addRange(0xFD92, 0xFDC7).addRange(0xFDF0, 0xFDFF).addRange(0xFE70, 0xFE74).addRange(0xFE76, 0xFEFC).addRange(0x10E60, 0x10E7E).addRange(0x10EC2, 0x10EC4).addRange(0x10EFC, 0x10EFF).addRange(0x1EE00, 0x1EE03).addRange(0x1EE05, 0x1EE1F).addRange(0x1EE21, 0x1EE22).addRange(0x1EE29, 0x1EE32).addRange(0x1EE34, 0x1EE37).addRange(0x1EE4D, 0x1EE4F).addRange(0x1EE51, 0x1EE52).addRange(0x1EE61, 0x1EE62).addRange(0x1EE67, 0x1EE6A).addRange(0x1EE6C, 0x1EE72).addRange(0x1EE74, 0x1EE77).addRange(0x1EE79, 0x1EE7C).addRange(0x1EE80, 0x1EE89).addRange(0x1EE8B, 0x1EE9B).addRange(0x1EEA1, 0x1EEA3).addRange(0x1EEA5, 0x1EEA9).addRange(0x1EEAB, 0x1EEBB).addRange(0x1EEF0, 0x1EEF1);
    Arabic.characters = set;
    return Arabic;
  }

var Armenian = {};

var hasRequiredArmenian;
  function requireArmenian() {
    if (hasRequiredArmenian) return Armenian;
    hasRequiredArmenian = 1;
    var set = regenerateExports();
    set.addRange(0x531, 0x556).addRange(0x559, 0x58A).addRange(0x58D, 0x58F).addRange(0xFB13, 0xFB17);
    Armenian.characters = set;
    return Armenian;
  }

var Avestan = {};

var hasRequiredAvestan;
  function requireAvestan() {
    if (hasRequiredAvestan) return Avestan;
    hasRequiredAvestan = 1;
    var set = regenerateExports();
    set.addRange(0x10B00, 0x10B35).addRange(0x10B39, 0x10B3F);
    Avestan.characters = set;
    return Avestan;
  }

var Balinese = {};

var hasRequiredBalinese;
  function requireBalinese() {
    if (hasRequiredBalinese) return Balinese;
    hasRequiredBalinese = 1;
    var set = regenerateExports();
    set.addRange(0x1B00, 0x1B4C).addRange(0x1B4E, 0x1B7F);
    Balinese.characters = set;
    return Balinese;
  }

var Bamum = {};

var hasRequiredBamum;
  function requireBamum() {
    if (hasRequiredBamum) return Bamum;
    hasRequiredBamum = 1;
    var set = regenerateExports();
    set.addRange(0xA6A0, 0xA6F7).addRange(0x16800, 0x16A38);
    Bamum.characters = set;
    return Bamum;
  }

var Bassa_Vah = {};

var hasRequiredBassa_Vah;
  function requireBassa_Vah() {
    if (hasRequiredBassa_Vah) return Bassa_Vah;
    hasRequiredBassa_Vah = 1;
    var set = regenerateExports();
    set.addRange(0x16AD0, 0x16AED).addRange(0x16AF0, 0x16AF5);
    Bassa_Vah.characters = set;
    return Bassa_Vah;
  }

var Batak = {};

var hasRequiredBatak;
  function requireBatak() {
    if (hasRequiredBatak) return Batak;
    hasRequiredBatak = 1;
    var set = regenerateExports();
    set.addRange(0x1BC0, 0x1BF3).addRange(0x1BFC, 0x1BFF);
    Batak.characters = set;
    return Batak;
  }

var Bengali = {};

var hasRequiredBengali;
  function requireBengali() {
    if (hasRequiredBengali) return Bengali;
    hasRequiredBengali = 1;
    var set = regenerateExports(0x9B2, 0x9D7);
    set.addRange(0x980, 0x983).addRange(0x985, 0x98C).addRange(0x98F, 0x990).addRange(0x993, 0x9A8).addRange(0x9AA, 0x9B0).addRange(0x9B6, 0x9B9).addRange(0x9BC, 0x9C4).addRange(0x9C7, 0x9C8).addRange(0x9CB, 0x9CE).addRange(0x9DC, 0x9DD).addRange(0x9DF, 0x9E3).addRange(0x9E6, 0x9FE);
    Bengali.characters = set;
    return Bengali;
  }

var Bhaiksuki = {};

var hasRequiredBhaiksuki;
  function requireBhaiksuki() {
    if (hasRequiredBhaiksuki) return Bhaiksuki;
    hasRequiredBhaiksuki = 1;
    var set = regenerateExports();
    set.addRange(0x11C00, 0x11C08).addRange(0x11C0A, 0x11C36).addRange(0x11C38, 0x11C45).addRange(0x11C50, 0x11C6C);
    Bhaiksuki.characters = set;
    return Bhaiksuki;
  }

var Bopomofo = {};

var hasRequiredBopomofo;
  function requireBopomofo() {
    if (hasRequiredBopomofo) return Bopomofo;
    hasRequiredBopomofo = 1;
    var set = regenerateExports();
    set.addRange(0x2EA, 0x2EB).addRange(0x3105, 0x312F).addRange(0x31A0, 0x31BF);
    Bopomofo.characters = set;
    return Bopomofo;
  }

var Brahmi = {};

var hasRequiredBrahmi;
  function requireBrahmi() {
    if (hasRequiredBrahmi) return Brahmi;
    hasRequiredBrahmi = 1;
    var set = regenerateExports(0x1107F);
    set.addRange(0x11000, 0x1104D).addRange(0x11052, 0x11075);
    Brahmi.characters = set;
    return Brahmi;
  }

var Braille = {};

var hasRequiredBraille;
  function requireBraille() {
    if (hasRequiredBraille) return Braille;
    hasRequiredBraille = 1;
    var set = regenerateExports();
    set.addRange(0x2800, 0x28FF);
    Braille.characters = set;
    return Braille;
  }

var Buginese = {};

var hasRequiredBuginese;
  function requireBuginese() {
    if (hasRequiredBuginese) return Buginese;
    hasRequiredBuginese = 1;
    var set = regenerateExports();
    set.addRange(0x1A00, 0x1A1B).addRange(0x1A1E, 0x1A1F);
    Buginese.characters = set;
    return Buginese;
  }

var Buhid = {};

var hasRequiredBuhid;
  function requireBuhid() {
    if (hasRequiredBuhid) return Buhid;
    hasRequiredBuhid = 1;
    var set = regenerateExports();
    set.addRange(0x1740, 0x1753);
    Buhid.characters = set;
    return Buhid;
  }

var Canadian_Aboriginal = {};

var hasRequiredCanadian_Aboriginal;
  function requireCanadian_Aboriginal() {
    if (hasRequiredCanadian_Aboriginal) return Canadian_Aboriginal;
    hasRequiredCanadian_Aboriginal = 1;
    var set = regenerateExports();
    set.addRange(0x1400, 0x167F).addRange(0x18B0, 0x18F5).addRange(0x11AB0, 0x11ABF);
    Canadian_Aboriginal.characters = set;
    return Canadian_Aboriginal;
  }

var Carian = {};

var hasRequiredCarian;
  function requireCarian() {
    if (hasRequiredCarian) return Carian;
    hasRequiredCarian = 1;
    var set = regenerateExports();
    set.addRange(0x102A0, 0x102D0);
    Carian.characters = set;
    return Carian;
  }

var Caucasian_Albanian = {};

var hasRequiredCaucasian_Albanian;
  function requireCaucasian_Albanian() {
    if (hasRequiredCaucasian_Albanian) return Caucasian_Albanian;
    hasRequiredCaucasian_Albanian = 1;
    var set = regenerateExports(0x1056F);
    set.addRange(0x10530, 0x10563);
    Caucasian_Albanian.characters = set;
    return Caucasian_Albanian;
  }

var Chakma = {};

var hasRequiredChakma;
  function requireChakma() {
    if (hasRequiredChakma) return Chakma;
    hasRequiredChakma = 1;
    var set = regenerateExports();
    set.addRange(0x11100, 0x11134).addRange(0x11136, 0x11147);
    Chakma.characters = set;
    return Chakma;
  }

var Cham = {};

var hasRequiredCham;
  function requireCham() {
    if (hasRequiredCham) return Cham;
    hasRequiredCham = 1;
    var set = regenerateExports();
    set.addRange(0xAA00, 0xAA36).addRange(0xAA40, 0xAA4D).addRange(0xAA50, 0xAA59).addRange(0xAA5C, 0xAA5F);
    Cham.characters = set;
    return Cham;
  }

var Cherokee = {};

var hasRequiredCherokee;
  function requireCherokee() {
    if (hasRequiredCherokee) return Cherokee;
    hasRequiredCherokee = 1;
    var set = regenerateExports();
    set.addRange(0x13A0, 0x13F5).addRange(0x13F8, 0x13FD).addRange(0xAB70, 0xABBF);
    Cherokee.characters = set;
    return Cherokee;
  }

var Chorasmian = {};

var hasRequiredChorasmian;
  function requireChorasmian() {
    if (hasRequiredChorasmian) return Chorasmian;
    hasRequiredChorasmian = 1;
    var set = regenerateExports();
    set.addRange(0x10FB0, 0x10FCB);
    Chorasmian.characters = set;
    return Chorasmian;
  }

var Common = {};

var hasRequiredCommon;
  function requireCommon() {
    if (hasRequiredCommon) return Common;
    hasRequiredCommon = 1;
    var set = regenerateExports(0xD7, 0xF7, 0x374, 0x37E, 0x385, 0x387, 0x605, 0x60C, 0x61B, 0x61F, 0x640, 0x6DD, 0x8E2, 0xE3F, 0x10FB, 0x1805, 0x1CD3, 0x1CE1, 0x1CFA, 0x3006, 0x30A0, 0x31EF, 0x32FF, 0xA92E, 0xA9CF, 0xAB5B, 0xFEFF, 0xFF70, 0x1D4A2, 0x1D4BB, 0x1D546, 0x1F7F0, 0xE0001);
    set.addRange(0x0, 0x40).addRange(0x5B, 0x60).addRange(0x7B, 0xA9).addRange(0xAB, 0xB9).addRange(0xBB, 0xBF).addRange(0x2B9, 0x2DF).addRange(0x2E5, 0x2E9).addRange(0x2EC, 0x2FF).addRange(0x964, 0x965).addRange(0xFD5, 0xFD8).addRange(0x16EB, 0x16ED).addRange(0x1735, 0x1736).addRange(0x1802, 0x1803).addRange(0x1CE9, 0x1CEC).addRange(0x1CEE, 0x1CF3).addRange(0x1CF5, 0x1CF7).addRange(0x2000, 0x200B).addRange(0x200E, 0x2064).addRange(0x2066, 0x2070).addRange(0x2074, 0x207E).addRange(0x2080, 0x208E).addRange(0x20A0, 0x20C0).addRange(0x2100, 0x2125).addRange(0x2127, 0x2129).addRange(0x212C, 0x2131).addRange(0x2133, 0x214D).addRange(0x214F, 0x215F).addRange(0x2189, 0x218B).addRange(0x2190, 0x2429).addRange(0x2440, 0x244A).addRange(0x2460, 0x27FF).addRange(0x2900, 0x2B73).addRange(0x2B76, 0x2B95).addRange(0x2B97, 0x2BFF).addRange(0x2E00, 0x2E5D).addRange(0x2FF0, 0x3004).addRange(0x3008, 0x3020).addRange(0x3030, 0x3037).addRange(0x303C, 0x303F).addRange(0x309B, 0x309C).addRange(0x30FB, 0x30FC).addRange(0x3190, 0x319F).addRange(0x31C0, 0x31E5).addRange(0x3220, 0x325F).addRange(0x327F, 0x32CF).addRange(0x3358, 0x33FF).addRange(0x4DC0, 0x4DFF).addRange(0xA700, 0xA721).addRange(0xA788, 0xA78A).addRange(0xA830, 0xA839).addRange(0xAB6A, 0xAB6B);
    set.addRange(0xFD3E, 0xFD3F).addRange(0xFE10, 0xFE19).addRange(0xFE30, 0xFE52).addRange(0xFE54, 0xFE66).addRange(0xFE68, 0xFE6B).addRange(0xFF01, 0xFF20).addRange(0xFF3B, 0xFF40).addRange(0xFF5B, 0xFF65).addRange(0xFF9E, 0xFF9F).addRange(0xFFE0, 0xFFE6).addRange(0xFFE8, 0xFFEE).addRange(0xFFF9, 0xFFFD).addRange(0x10100, 0x10102).addRange(0x10107, 0x10133).addRange(0x10137, 0x1013F).addRange(0x10190, 0x1019C).addRange(0x101D0, 0x101FC).addRange(0x102E1, 0x102FB).addRange(0x1BCA0, 0x1BCA3).addRange(0x1CC00, 0x1CCF9).addRange(0x1CD00, 0x1CEB3).addRange(0x1CF50, 0x1CFC3).addRange(0x1D000, 0x1D0F5).addRange(0x1D100, 0x1D126).addRange(0x1D129, 0x1D166).addRange(0x1D16A, 0x1D17A).addRange(0x1D183, 0x1D184).addRange(0x1D18C, 0x1D1A9).addRange(0x1D1AE, 0x1D1EA).addRange(0x1D2C0, 0x1D2D3).addRange(0x1D2E0, 0x1D2F3).addRange(0x1D300, 0x1D356).addRange(0x1D360, 0x1D378).addRange(0x1D400, 0x1D454).addRange(0x1D456, 0x1D49C).addRange(0x1D49E, 0x1D49F).addRange(0x1D4A5, 0x1D4A6).addRange(0x1D4A9, 0x1D4AC).addRange(0x1D4AE, 0x1D4B9).addRange(0x1D4BD, 0x1D4C3).addRange(0x1D4C5, 0x1D505).addRange(0x1D507, 0x1D50A).addRange(0x1D50D, 0x1D514).addRange(0x1D516, 0x1D51C).addRange(0x1D51E, 0x1D539).addRange(0x1D53B, 0x1D53E).addRange(0x1D540, 0x1D544).addRange(0x1D54A, 0x1D550).addRange(0x1D552, 0x1D6A5).addRange(0x1D6A8, 0x1D7CB).addRange(0x1D7CE, 0x1D7FF);
    set.addRange(0x1EC71, 0x1ECB4).addRange(0x1ED01, 0x1ED3D).addRange(0x1F000, 0x1F02B).addRange(0x1F030, 0x1F093).addRange(0x1F0A0, 0x1F0AE).addRange(0x1F0B1, 0x1F0BF).addRange(0x1F0C1, 0x1F0CF).addRange(0x1F0D1, 0x1F0F5).addRange(0x1F100, 0x1F1AD).addRange(0x1F1E6, 0x1F1FF).addRange(0x1F201, 0x1F202).addRange(0x1F210, 0x1F23B).addRange(0x1F240, 0x1F248).addRange(0x1F250, 0x1F251).addRange(0x1F260, 0x1F265).addRange(0x1F300, 0x1F6D7).addRange(0x1F6DC, 0x1F6EC).addRange(0x1F6F0, 0x1F6FC).addRange(0x1F700, 0x1F776).addRange(0x1F77B, 0x1F7D9).addRange(0x1F7E0, 0x1F7EB).addRange(0x1F800, 0x1F80B).addRange(0x1F810, 0x1F847).addRange(0x1F850, 0x1F859).addRange(0x1F860, 0x1F887).addRange(0x1F890, 0x1F8AD).addRange(0x1F8B0, 0x1F8BB).addRange(0x1F8C0, 0x1F8C1).addRange(0x1F900, 0x1FA53).addRange(0x1FA60, 0x1FA6D).addRange(0x1FA70, 0x1FA7C).addRange(0x1FA80, 0x1FA89).addRange(0x1FA8F, 0x1FAC6).addRange(0x1FACE, 0x1FADC).addRange(0x1FADF, 0x1FAE9).addRange(0x1FAF0, 0x1FAF8).addRange(0x1FB00, 0x1FB92).addRange(0x1FB94, 0x1FBF9).addRange(0xE0020, 0xE007F);
    Common.characters = set;
    return Common;
  }

var Coptic = {};

var hasRequiredCoptic;
  function requireCoptic() {
    if (hasRequiredCoptic) return Coptic;
    hasRequiredCoptic = 1;
    var set = regenerateExports();
    set.addRange(0x3E2, 0x3EF).addRange(0x2C80, 0x2CF3).addRange(0x2CF9, 0x2CFF);
    Coptic.characters = set;
    return Coptic;
  }

var Cuneiform = {};

var hasRequiredCuneiform;
  function requireCuneiform() {
    if (hasRequiredCuneiform) return Cuneiform;
    hasRequiredCuneiform = 1;
    var set = regenerateExports();
    set.addRange(0x12000, 0x12399).addRange(0x12400, 0x1246E).addRange(0x12470, 0x12474).addRange(0x12480, 0x12543);
    Cuneiform.characters = set;
    return Cuneiform;
  }

var Cypriot = {};

var hasRequiredCypriot;
  function requireCypriot() {
    if (hasRequiredCypriot) return Cypriot;
    hasRequiredCypriot = 1;
    var set = regenerateExports(0x10808, 0x1083C, 0x1083F);
    set.addRange(0x10800, 0x10805).addRange(0x1080A, 0x10835).addRange(0x10837, 0x10838);
    Cypriot.characters = set;
    return Cypriot;
  }

var Cypro_Minoan = {};

var hasRequiredCypro_Minoan;
  function requireCypro_Minoan() {
    if (hasRequiredCypro_Minoan) return Cypro_Minoan;
    hasRequiredCypro_Minoan = 1;
    var set = regenerateExports();
    set.addRange(0x12F90, 0x12FF2);
    Cypro_Minoan.characters = set;
    return Cypro_Minoan;
  }

var Cyrillic = {};

var hasRequiredCyrillic;
  function requireCyrillic() {
    if (hasRequiredCyrillic) return Cyrillic;
    hasRequiredCyrillic = 1;
    var set = regenerateExports(0x1D2B, 0x1D78, 0x1E08F);
    set.addRange(0x400, 0x484).addRange(0x487, 0x52F).addRange(0x1C80, 0x1C8A).addRange(0x2DE0, 0x2DFF).addRange(0xA640, 0xA69F).addRange(0xFE2E, 0xFE2F).addRange(0x1E030, 0x1E06D);
    Cyrillic.characters = set;
    return Cyrillic;
  }

var Deseret = {};

var hasRequiredDeseret;
  function requireDeseret() {
    if (hasRequiredDeseret) return Deseret;
    hasRequiredDeseret = 1;
    var set = regenerateExports();
    set.addRange(0x10400, 0x1044F);
    Deseret.characters = set;
    return Deseret;
  }

var Devanagari = {};

var hasRequiredDevanagari;
  function requireDevanagari() {
    if (hasRequiredDevanagari) return Devanagari;
    hasRequiredDevanagari = 1;
    var set = regenerateExports();
    set.addRange(0x900, 0x950).addRange(0x955, 0x963).addRange(0x966, 0x97F).addRange(0xA8E0, 0xA8FF).addRange(0x11B00, 0x11B09);
    Devanagari.characters = set;
    return Devanagari;
  }

var Dives_Akuru = {};

var hasRequiredDives_Akuru;
  function requireDives_Akuru() {
    if (hasRequiredDives_Akuru) return Dives_Akuru;
    hasRequiredDives_Akuru = 1;
    var set = regenerateExports(0x11909);
    set.addRange(0x11900, 0x11906).addRange(0x1190C, 0x11913).addRange(0x11915, 0x11916).addRange(0x11918, 0x11935).addRange(0x11937, 0x11938).addRange(0x1193B, 0x11946).addRange(0x11950, 0x11959);
    Dives_Akuru.characters = set;
    return Dives_Akuru;
  }

var Dogra = {};

var hasRequiredDogra;
  function requireDogra() {
    if (hasRequiredDogra) return Dogra;
    hasRequiredDogra = 1;
    var set = regenerateExports();
    set.addRange(0x11800, 0x1183B);
    Dogra.characters = set;
    return Dogra;
  }

var Duployan = {};

var hasRequiredDuployan;
  function requireDuployan() {
    if (hasRequiredDuployan) return Duployan;
    hasRequiredDuployan = 1;
    var set = regenerateExports();
    set.addRange(0x1BC00, 0x1BC6A).addRange(0x1BC70, 0x1BC7C).addRange(0x1BC80, 0x1BC88).addRange(0x1BC90, 0x1BC99).addRange(0x1BC9C, 0x1BC9F);
    Duployan.characters = set;
    return Duployan;
  }

var Egyptian_Hieroglyphs = {};

var hasRequiredEgyptian_Hieroglyphs;
  function requireEgyptian_Hieroglyphs() {
    if (hasRequiredEgyptian_Hieroglyphs) return Egyptian_Hieroglyphs;
    hasRequiredEgyptian_Hieroglyphs = 1;
    var set = regenerateExports();
    set.addRange(0x13000, 0x13455).addRange(0x13460, 0x143FA);
    Egyptian_Hieroglyphs.characters = set;
    return Egyptian_Hieroglyphs;
  }

var Elbasan = {};

var hasRequiredElbasan;
  function requireElbasan() {
    if (hasRequiredElbasan) return Elbasan;
    hasRequiredElbasan = 1;
    var set = regenerateExports();
    set.addRange(0x10500, 0x10527);
    Elbasan.characters = set;
    return Elbasan;
  }

var Elymaic = {};

var hasRequiredElymaic;
  function requireElymaic() {
    if (hasRequiredElymaic) return Elymaic;
    hasRequiredElymaic = 1;
    var set = regenerateExports();
    set.addRange(0x10FE0, 0x10FF6);
    Elymaic.characters = set;
    return Elymaic;
  }

var Ethiopic = {};

var hasRequiredEthiopic;
  function requireEthiopic() {
    if (hasRequiredEthiopic) return Ethiopic;
    hasRequiredEthiopic = 1;
    var set = regenerateExports(0x1258, 0x12C0);
    set.addRange(0x1200, 0x1248).addRange(0x124A, 0x124D).addRange(0x1250, 0x1256).addRange(0x125A, 0x125D).addRange(0x1260, 0x1288).addRange(0x128A, 0x128D).addRange(0x1290, 0x12B0).addRange(0x12B2, 0x12B5).addRange(0x12B8, 0x12BE).addRange(0x12C2, 0x12C5).addRange(0x12C8, 0x12D6).addRange(0x12D8, 0x1310).addRange(0x1312, 0x1315).addRange(0x1318, 0x135A).addRange(0x135D, 0x137C).addRange(0x1380, 0x1399).addRange(0x2D80, 0x2D96).addRange(0x2DA0, 0x2DA6).addRange(0x2DA8, 0x2DAE).addRange(0x2DB0, 0x2DB6).addRange(0x2DB8, 0x2DBE).addRange(0x2DC0, 0x2DC6).addRange(0x2DC8, 0x2DCE).addRange(0x2DD0, 0x2DD6).addRange(0x2DD8, 0x2DDE).addRange(0xAB01, 0xAB06).addRange(0xAB09, 0xAB0E).addRange(0xAB11, 0xAB16).addRange(0xAB20, 0xAB26).addRange(0xAB28, 0xAB2E).addRange(0x1E7E0, 0x1E7E6).addRange(0x1E7E8, 0x1E7EB).addRange(0x1E7ED, 0x1E7EE).addRange(0x1E7F0, 0x1E7FE);
    Ethiopic.characters = set;
    return Ethiopic;
  }

var Garay = {};

var hasRequiredGaray;
  function requireGaray() {
    if (hasRequiredGaray) return Garay;
    hasRequiredGaray = 1;
    var set = regenerateExports();
    set.addRange(0x10D40, 0x10D65).addRange(0x10D69, 0x10D85).addRange(0x10D8E, 0x10D8F);
    Garay.characters = set;
    return Garay;
  }

var Georgian = {};

var hasRequiredGeorgian;
  function requireGeorgian() {
    if (hasRequiredGeorgian) return Georgian;
    hasRequiredGeorgian = 1;
    var set = regenerateExports(0x10C7, 0x10CD, 0x2D27, 0x2D2D);
    set.addRange(0x10A0, 0x10C5).addRange(0x10D0, 0x10FA).addRange(0x10FC, 0x10FF).addRange(0x1C90, 0x1CBA).addRange(0x1CBD, 0x1CBF).addRange(0x2D00, 0x2D25);
    Georgian.characters = set;
    return Georgian;
  }

var Glagolitic = {};

var hasRequiredGlagolitic;
  function requireGlagolitic() {
    if (hasRequiredGlagolitic) return Glagolitic;
    hasRequiredGlagolitic = 1;
    var set = regenerateExports();
    set.addRange(0x2C00, 0x2C5F).addRange(0x1E000, 0x1E006).addRange(0x1E008, 0x1E018).addRange(0x1E01B, 0x1E021).addRange(0x1E023, 0x1E024).addRange(0x1E026, 0x1E02A);
    Glagolitic.characters = set;
    return Glagolitic;
  }

var Gothic = {};

var hasRequiredGothic;
  function requireGothic() {
    if (hasRequiredGothic) return Gothic;
    hasRequiredGothic = 1;
    var set = regenerateExports();
    set.addRange(0x10330, 0x1034A);
    Gothic.characters = set;
    return Gothic;
  }

var Grantha = {};

var hasRequiredGrantha;
  function requireGrantha() {
    if (hasRequiredGrantha) return Grantha;
    hasRequiredGrantha = 1;
    var set = regenerateExports(0x11350, 0x11357);
    set.addRange(0x11300, 0x11303).addRange(0x11305, 0x1130C).addRange(0x1130F, 0x11310).addRange(0x11313, 0x11328).addRange(0x1132A, 0x11330).addRange(0x11332, 0x11333).addRange(0x11335, 0x11339).addRange(0x1133C, 0x11344).addRange(0x11347, 0x11348).addRange(0x1134B, 0x1134D).addRange(0x1135D, 0x11363).addRange(0x11366, 0x1136C).addRange(0x11370, 0x11374);
    Grantha.characters = set;
    return Grantha;
  }

var Greek = {};

var hasRequiredGreek;
  function requireGreek() {
    if (hasRequiredGreek) return Greek;
    hasRequiredGreek = 1;
    var set = regenerateExports(0x37F, 0x384, 0x386, 0x38C, 0x1DBF, 0x1F59, 0x1F5B, 0x1F5D, 0x2126, 0xAB65, 0x101A0);
    set.addRange(0x370, 0x373).addRange(0x375, 0x377).addRange(0x37A, 0x37D).addRange(0x388, 0x38A).addRange(0x38E, 0x3A1).addRange(0x3A3, 0x3E1).addRange(0x3F0, 0x3FF).addRange(0x1D26, 0x1D2A).addRange(0x1D5D, 0x1D61).addRange(0x1D66, 0x1D6A).addRange(0x1F00, 0x1F15).addRange(0x1F18, 0x1F1D).addRange(0x1F20, 0x1F45).addRange(0x1F48, 0x1F4D).addRange(0x1F50, 0x1F57).addRange(0x1F5F, 0x1F7D).addRange(0x1F80, 0x1FB4).addRange(0x1FB6, 0x1FC4).addRange(0x1FC6, 0x1FD3).addRange(0x1FD6, 0x1FDB).addRange(0x1FDD, 0x1FEF).addRange(0x1FF2, 0x1FF4).addRange(0x1FF6, 0x1FFE).addRange(0x10140, 0x1018E).addRange(0x1D200, 0x1D245);
    Greek.characters = set;
    return Greek;
  }

var Gujarati = {};

var hasRequiredGujarati;
  function requireGujarati() {
    if (hasRequiredGujarati) return Gujarati;
    hasRequiredGujarati = 1;
    var set = regenerateExports(0xAD0);
    set.addRange(0xA81, 0xA83).addRange(0xA85, 0xA8D).addRange(0xA8F, 0xA91).addRange(0xA93, 0xAA8).addRange(0xAAA, 0xAB0).addRange(0xAB2, 0xAB3).addRange(0xAB5, 0xAB9).addRange(0xABC, 0xAC5).addRange(0xAC7, 0xAC9).addRange(0xACB, 0xACD).addRange(0xAE0, 0xAE3).addRange(0xAE6, 0xAF1).addRange(0xAF9, 0xAFF);
    Gujarati.characters = set;
    return Gujarati;
  }

var Gunjala_Gondi = {};

var hasRequiredGunjala_Gondi;
  function requireGunjala_Gondi() {
    if (hasRequiredGunjala_Gondi) return Gunjala_Gondi;
    hasRequiredGunjala_Gondi = 1;
    var set = regenerateExports();
    set.addRange(0x11D60, 0x11D65).addRange(0x11D67, 0x11D68).addRange(0x11D6A, 0x11D8E).addRange(0x11D90, 0x11D91).addRange(0x11D93, 0x11D98).addRange(0x11DA0, 0x11DA9);
    Gunjala_Gondi.characters = set;
    return Gunjala_Gondi;
  }

var Gurmukhi = {};

var hasRequiredGurmukhi;
  function requireGurmukhi() {
    if (hasRequiredGurmukhi) return Gurmukhi;
    hasRequiredGurmukhi = 1;
    var set = regenerateExports(0xA3C, 0xA51, 0xA5E);
    set.addRange(0xA01, 0xA03).addRange(0xA05, 0xA0A).addRange(0xA0F, 0xA10).addRange(0xA13, 0xA28).addRange(0xA2A, 0xA30).addRange(0xA32, 0xA33).addRange(0xA35, 0xA36).addRange(0xA38, 0xA39).addRange(0xA3E, 0xA42).addRange(0xA47, 0xA48).addRange(0xA4B, 0xA4D).addRange(0xA59, 0xA5C).addRange(0xA66, 0xA76);
    Gurmukhi.characters = set;
    return Gurmukhi;
  }

var Gurung_Khema = {};

var hasRequiredGurung_Khema;
  function requireGurung_Khema() {
    if (hasRequiredGurung_Khema) return Gurung_Khema;
    hasRequiredGurung_Khema = 1;
    var set = regenerateExports();
    set.addRange(0x16100, 0x16139);
    Gurung_Khema.characters = set;
    return Gurung_Khema;
  }

var Han = {};

var hasRequiredHan;
  function requireHan() {
    if (hasRequiredHan) return Han;
    hasRequiredHan = 1;
    var set = regenerateExports(0x3005, 0x3007);
    set.addRange(0x2E80, 0x2E99).addRange(0x2E9B, 0x2EF3).addRange(0x2F00, 0x2FD5).addRange(0x3021, 0x3029).addRange(0x3038, 0x303B).addRange(0x3400, 0x4DBF).addRange(0x4E00, 0x9FFF).addRange(0xF900, 0xFA6D).addRange(0xFA70, 0xFAD9).addRange(0x16FE2, 0x16FE3).addRange(0x16FF0, 0x16FF1).addRange(0x20000, 0x2A6DF).addRange(0x2A700, 0x2B739).addRange(0x2B740, 0x2B81D).addRange(0x2B820, 0x2CEA1).addRange(0x2CEB0, 0x2EBE0).addRange(0x2EBF0, 0x2EE5D).addRange(0x2F800, 0x2FA1D).addRange(0x30000, 0x3134A).addRange(0x31350, 0x323AF);
    Han.characters = set;
    return Han;
  }

var Hangul = {};

var hasRequiredHangul;
  function requireHangul() {
    if (hasRequiredHangul) return Hangul;
    hasRequiredHangul = 1;
    var set = regenerateExports();
    set.addRange(0x1100, 0x11FF).addRange(0x302E, 0x302F).addRange(0x3131, 0x318E).addRange(0x3200, 0x321E).addRange(0x3260, 0x327E).addRange(0xA960, 0xA97C).addRange(0xAC00, 0xD7A3).addRange(0xD7B0, 0xD7C6).addRange(0xD7CB, 0xD7FB).addRange(0xFFA0, 0xFFBE).addRange(0xFFC2, 0xFFC7).addRange(0xFFCA, 0xFFCF).addRange(0xFFD2, 0xFFD7).addRange(0xFFDA, 0xFFDC);
    Hangul.characters = set;
    return Hangul;
  }

var Hanifi_Rohingya = {};

var hasRequiredHanifi_Rohingya;
  function requireHanifi_Rohingya() {
    if (hasRequiredHanifi_Rohingya) return Hanifi_Rohingya;
    hasRequiredHanifi_Rohingya = 1;
    var set = regenerateExports();
    set.addRange(0x10D00, 0x10D27).addRange(0x10D30, 0x10D39);
    Hanifi_Rohingya.characters = set;
    return Hanifi_Rohingya;
  }

var Hanunoo = {};

var hasRequiredHanunoo;
  function requireHanunoo() {
    if (hasRequiredHanunoo) return Hanunoo;
    hasRequiredHanunoo = 1;
    var set = regenerateExports();
    set.addRange(0x1720, 0x1734);
    Hanunoo.characters = set;
    return Hanunoo;
  }

var Hatran = {};

var hasRequiredHatran;
  function requireHatran() {
    if (hasRequiredHatran) return Hatran;
    hasRequiredHatran = 1;
    var set = regenerateExports();
    set.addRange(0x108E0, 0x108F2).addRange(0x108F4, 0x108F5).addRange(0x108FB, 0x108FF);
    Hatran.characters = set;
    return Hatran;
  }

var Hebrew = {};

var hasRequiredHebrew;
  function requireHebrew() {
    if (hasRequiredHebrew) return Hebrew;
    hasRequiredHebrew = 1;
    var set = regenerateExports(0xFB3E);
    set.addRange(0x591, 0x5C7).addRange(0x5D0, 0x5EA).addRange(0x5EF, 0x5F4).addRange(0xFB1D, 0xFB36).addRange(0xFB38, 0xFB3C).addRange(0xFB40, 0xFB41).addRange(0xFB43, 0xFB44).addRange(0xFB46, 0xFB4F);
    Hebrew.characters = set;
    return Hebrew;
  }

var Hiragana = {};

var hasRequiredHiragana;
  function requireHiragana() {
    if (hasRequiredHiragana) return Hiragana;
    hasRequiredHiragana = 1;
    var set = regenerateExports(0x1B132, 0x1F200);
    set.addRange(0x3041, 0x3096).addRange(0x309D, 0x309F).addRange(0x1B001, 0x1B11F).addRange(0x1B150, 0x1B152);
    Hiragana.characters = set;
    return Hiragana;
  }

var Imperial_Aramaic = {};

var hasRequiredImperial_Aramaic;
  function requireImperial_Aramaic() {
    if (hasRequiredImperial_Aramaic) return Imperial_Aramaic;
    hasRequiredImperial_Aramaic = 1;
    var set = regenerateExports();
    set.addRange(0x10840, 0x10855).addRange(0x10857, 0x1085F);
    Imperial_Aramaic.characters = set;
    return Imperial_Aramaic;
  }

var Inherited = {};

var hasRequiredInherited;
  function requireInherited() {
    if (hasRequiredInherited) return Inherited;
    hasRequiredInherited = 1;
    var set = regenerateExports(0x670, 0x1CED, 0x1CF4, 0x101FD, 0x102E0, 0x1133B);
    set.addRange(0x300, 0x36F).addRange(0x485, 0x486).addRange(0x64B, 0x655).addRange(0x951, 0x954).addRange(0x1AB0, 0x1ACE).addRange(0x1CD0, 0x1CD2).addRange(0x1CD4, 0x1CE0).addRange(0x1CE2, 0x1CE8).addRange(0x1CF8, 0x1CF9).addRange(0x1DC0, 0x1DFF).addRange(0x200C, 0x200D).addRange(0x20D0, 0x20F0).addRange(0x302A, 0x302D).addRange(0x3099, 0x309A).addRange(0xFE00, 0xFE0F).addRange(0xFE20, 0xFE2D).addRange(0x1CF00, 0x1CF2D).addRange(0x1CF30, 0x1CF46).addRange(0x1D167, 0x1D169).addRange(0x1D17B, 0x1D182).addRange(0x1D185, 0x1D18B).addRange(0x1D1AA, 0x1D1AD).addRange(0xE0100, 0xE01EF);
    Inherited.characters = set;
    return Inherited;
  }

var Inscriptional_Pahlavi = {};

var hasRequiredInscriptional_Pahlavi;
  function requireInscriptional_Pahlavi() {
    if (hasRequiredInscriptional_Pahlavi) return Inscriptional_Pahlavi;
    hasRequiredInscriptional_Pahlavi = 1;
    var set = regenerateExports();
    set.addRange(0x10B60, 0x10B72).addRange(0x10B78, 0x10B7F);
    Inscriptional_Pahlavi.characters = set;
    return Inscriptional_Pahlavi;
  }

var Inscriptional_Parthian = {};

var hasRequiredInscriptional_Parthian;
  function requireInscriptional_Parthian() {
    if (hasRequiredInscriptional_Parthian) return Inscriptional_Parthian;
    hasRequiredInscriptional_Parthian = 1;
    var set = regenerateExports();
    set.addRange(0x10B40, 0x10B55).addRange(0x10B58, 0x10B5F);
    Inscriptional_Parthian.characters = set;
    return Inscriptional_Parthian;
  }

var Javanese = {};

var hasRequiredJavanese;
  function requireJavanese() {
    if (hasRequiredJavanese) return Javanese;
    hasRequiredJavanese = 1;
    var set = regenerateExports();
    set.addRange(0xA980, 0xA9CD).addRange(0xA9D0, 0xA9D9).addRange(0xA9DE, 0xA9DF);
    Javanese.characters = set;
    return Javanese;
  }

var Kaithi = {};

var hasRequiredKaithi;
  function requireKaithi() {
    if (hasRequiredKaithi) return Kaithi;
    hasRequiredKaithi = 1;
    var set = regenerateExports(0x110CD);
    set.addRange(0x11080, 0x110C2);
    Kaithi.characters = set;
    return Kaithi;
  }

var Kannada = {};

var hasRequiredKannada;
  function requireKannada() {
    if (hasRequiredKannada) return Kannada;
    hasRequiredKannada = 1;
    var set = regenerateExports();
    set.addRange(0xC80, 0xC8C).addRange(0xC8E, 0xC90).addRange(0xC92, 0xCA8).addRange(0xCAA, 0xCB3).addRange(0xCB5, 0xCB9).addRange(0xCBC, 0xCC4).addRange(0xCC6, 0xCC8).addRange(0xCCA, 0xCCD).addRange(0xCD5, 0xCD6).addRange(0xCDD, 0xCDE).addRange(0xCE0, 0xCE3).addRange(0xCE6, 0xCEF).addRange(0xCF1, 0xCF3);
    Kannada.characters = set;
    return Kannada;
  }

var Katakana = {};

var hasRequiredKatakana;
  function requireKatakana() {
    if (hasRequiredKatakana) return Katakana;
    hasRequiredKatakana = 1;
    var set = regenerateExports(0x1B000, 0x1B155);
    set.addRange(0x30A1, 0x30FA).addRange(0x30FD, 0x30FF).addRange(0x31F0, 0x31FF).addRange(0x32D0, 0x32FE).addRange(0x3300, 0x3357).addRange(0xFF66, 0xFF6F).addRange(0xFF71, 0xFF9D).addRange(0x1AFF0, 0x1AFF3).addRange(0x1AFF5, 0x1AFFB).addRange(0x1AFFD, 0x1AFFE).addRange(0x1B120, 0x1B122).addRange(0x1B164, 0x1B167);
    Katakana.characters = set;
    return Katakana;
  }

var Kawi = {};

var hasRequiredKawi;
  function requireKawi() {
    if (hasRequiredKawi) return Kawi;
    hasRequiredKawi = 1;
    var set = regenerateExports();
    set.addRange(0x11F00, 0x11F10).addRange(0x11F12, 0x11F3A).addRange(0x11F3E, 0x11F5A);
    Kawi.characters = set;
    return Kawi;
  }

var Kayah_Li = {};

var hasRequiredKayah_Li;
  function requireKayah_Li() {
    if (hasRequiredKayah_Li) return Kayah_Li;
    hasRequiredKayah_Li = 1;
    var set = regenerateExports(0xA92F);
    set.addRange(0xA900, 0xA92D);
    Kayah_Li.characters = set;
    return Kayah_Li;
  }

var Kharoshthi = {};

var hasRequiredKharoshthi;
  function requireKharoshthi() {
    if (hasRequiredKharoshthi) return Kharoshthi;
    hasRequiredKharoshthi = 1;
    var set = regenerateExports();
    set.addRange(0x10A00, 0x10A03).addRange(0x10A05, 0x10A06).addRange(0x10A0C, 0x10A13).addRange(0x10A15, 0x10A17).addRange(0x10A19, 0x10A35).addRange(0x10A38, 0x10A3A).addRange(0x10A3F, 0x10A48).addRange(0x10A50, 0x10A58);
    Kharoshthi.characters = set;
    return Kharoshthi;
  }

var Khitan_Small_Script = {};

var hasRequiredKhitan_Small_Script;
  function requireKhitan_Small_Script() {
    if (hasRequiredKhitan_Small_Script) return Khitan_Small_Script;
    hasRequiredKhitan_Small_Script = 1;
    var set = regenerateExports(0x16FE4, 0x18CFF);
    set.addRange(0x18B00, 0x18CD5);
    Khitan_Small_Script.characters = set;
    return Khitan_Small_Script;
  }

var Khmer = {};

var hasRequiredKhmer;
  function requireKhmer() {
    if (hasRequiredKhmer) return Khmer;
    hasRequiredKhmer = 1;
    var set = regenerateExports();
    set.addRange(0x1780, 0x17DD).addRange(0x17E0, 0x17E9).addRange(0x17F0, 0x17F9).addRange(0x19E0, 0x19FF);
    Khmer.characters = set;
    return Khmer;
  }

var Khojki = {};

var hasRequiredKhojki;
  function requireKhojki() {
    if (hasRequiredKhojki) return Khojki;
    hasRequiredKhojki = 1;
    var set = regenerateExports();
    set.addRange(0x11200, 0x11211).addRange(0x11213, 0x11241);
    Khojki.characters = set;
    return Khojki;
  }

var Khudawadi = {};

var hasRequiredKhudawadi;
  function requireKhudawadi() {
    if (hasRequiredKhudawadi) return Khudawadi;
    hasRequiredKhudawadi = 1;
    var set = regenerateExports();
    set.addRange(0x112B0, 0x112EA).addRange(0x112F0, 0x112F9);
    Khudawadi.characters = set;
    return Khudawadi;
  }

var Kirat_Rai = {};

var hasRequiredKirat_Rai;
  function requireKirat_Rai() {
    if (hasRequiredKirat_Rai) return Kirat_Rai;
    hasRequiredKirat_Rai = 1;
    var set = regenerateExports();
    set.addRange(0x16D40, 0x16D79);
    Kirat_Rai.characters = set;
    return Kirat_Rai;
  }

var Lao = {};

var hasRequiredLao;
  function requireLao() {
    if (hasRequiredLao) return Lao;
    hasRequiredLao = 1;
    var set = regenerateExports(0xE84, 0xEA5, 0xEC6);
    set.addRange(0xE81, 0xE82).addRange(0xE86, 0xE8A).addRange(0xE8C, 0xEA3).addRange(0xEA7, 0xEBD).addRange(0xEC0, 0xEC4).addRange(0xEC8, 0xECE).addRange(0xED0, 0xED9).addRange(0xEDC, 0xEDF);
    Lao.characters = set;
    return Lao;
  }

var Latin = {};

var hasRequiredLatin;
  function requireLatin() {
    if (hasRequiredLatin) return Latin;
    hasRequiredLatin = 1;
    var set = regenerateExports(0xAA, 0xBA, 0x2071, 0x207F, 0x2132, 0x214E, 0xA7D3);
    set.addRange(0x41, 0x5A).addRange(0x61, 0x7A).addRange(0xC0, 0xD6).addRange(0xD8, 0xF6).addRange(0xF8, 0x2B8).addRange(0x2E0, 0x2E4).addRange(0x1D00, 0x1D25).addRange(0x1D2C, 0x1D5C).addRange(0x1D62, 0x1D65).addRange(0x1D6B, 0x1D77).addRange(0x1D79, 0x1DBE).addRange(0x1E00, 0x1EFF).addRange(0x2090, 0x209C).addRange(0x212A, 0x212B).addRange(0x2160, 0x2188).addRange(0x2C60, 0x2C7F).addRange(0xA722, 0xA787).addRange(0xA78B, 0xA7CD).addRange(0xA7D0, 0xA7D1).addRange(0xA7D5, 0xA7DC).addRange(0xA7F2, 0xA7FF).addRange(0xAB30, 0xAB5A).addRange(0xAB5C, 0xAB64).addRange(0xAB66, 0xAB69).addRange(0xFB00, 0xFB06).addRange(0xFF21, 0xFF3A).addRange(0xFF41, 0xFF5A).addRange(0x10780, 0x10785).addRange(0x10787, 0x107B0).addRange(0x107B2, 0x107BA).addRange(0x1DF00, 0x1DF1E).addRange(0x1DF25, 0x1DF2A);
    Latin.characters = set;
    return Latin;
  }

var Lepcha = {};

var hasRequiredLepcha;
  function requireLepcha() {
    if (hasRequiredLepcha) return Lepcha;
    hasRequiredLepcha = 1;
    var set = regenerateExports();
    set.addRange(0x1C00, 0x1C37).addRange(0x1C3B, 0x1C49).addRange(0x1C4D, 0x1C4F);
    Lepcha.characters = set;
    return Lepcha;
  }

var Limbu = {};

var hasRequiredLimbu;
  function requireLimbu() {
    if (hasRequiredLimbu) return Limbu;
    hasRequiredLimbu = 1;
    var set = regenerateExports(0x1940);
    set.addRange(0x1900, 0x191E).addRange(0x1920, 0x192B).addRange(0x1930, 0x193B).addRange(0x1944, 0x194F);
    Limbu.characters = set;
    return Limbu;
  }

var Linear_A = {};

var hasRequiredLinear_A;
  function requireLinear_A() {
    if (hasRequiredLinear_A) return Linear_A;
    hasRequiredLinear_A = 1;
    var set = regenerateExports();
    set.addRange(0x10600, 0x10736).addRange(0x10740, 0x10755).addRange(0x10760, 0x10767);
    Linear_A.characters = set;
    return Linear_A;
  }

var Linear_B = {};

var hasRequiredLinear_B;
  function requireLinear_B() {
    if (hasRequiredLinear_B) return Linear_B;
    hasRequiredLinear_B = 1;
    var set = regenerateExports();
    set.addRange(0x10000, 0x1000B).addRange(0x1000D, 0x10026).addRange(0x10028, 0x1003A).addRange(0x1003C, 0x1003D).addRange(0x1003F, 0x1004D).addRange(0x10050, 0x1005D).addRange(0x10080, 0x100FA);
    Linear_B.characters = set;
    return Linear_B;
  }

var Lisu = {};

var hasRequiredLisu;
  function requireLisu() {
    if (hasRequiredLisu) return Lisu;
    hasRequiredLisu = 1;
    var set = regenerateExports(0x11FB0);
    set.addRange(0xA4D0, 0xA4FF);
    Lisu.characters = set;
    return Lisu;
  }

var Lycian = {};

var hasRequiredLycian;
  function requireLycian() {
    if (hasRequiredLycian) return Lycian;
    hasRequiredLycian = 1;
    var set = regenerateExports();
    set.addRange(0x10280, 0x1029C);
    Lycian.characters = set;
    return Lycian;
  }

var Lydian = {};

var hasRequiredLydian;
  function requireLydian() {
    if (hasRequiredLydian) return Lydian;
    hasRequiredLydian = 1;
    var set = regenerateExports(0x1093F);
    set.addRange(0x10920, 0x10939);
    Lydian.characters = set;
    return Lydian;
  }

var Mahajani = {};

var hasRequiredMahajani;
  function requireMahajani() {
    if (hasRequiredMahajani) return Mahajani;
    hasRequiredMahajani = 1;
    var set = regenerateExports();
    set.addRange(0x11150, 0x11176);
    Mahajani.characters = set;
    return Mahajani;
  }

var Makasar = {};

var hasRequiredMakasar;
  function requireMakasar() {
    if (hasRequiredMakasar) return Makasar;
    hasRequiredMakasar = 1;
    var set = regenerateExports();
    set.addRange(0x11EE0, 0x11EF8);
    Makasar.characters = set;
    return Makasar;
  }

var Malayalam = {};

var hasRequiredMalayalam;
  function requireMalayalam() {
    if (hasRequiredMalayalam) return Malayalam;
    hasRequiredMalayalam = 1;
    var set = regenerateExports();
    set.addRange(0xD00, 0xD0C).addRange(0xD0E, 0xD10).addRange(0xD12, 0xD44).addRange(0xD46, 0xD48).addRange(0xD4A, 0xD4F).addRange(0xD54, 0xD63).addRange(0xD66, 0xD7F);
    Malayalam.characters = set;
    return Malayalam;
  }

var Mandaic = {};

var hasRequiredMandaic;
  function requireMandaic() {
    if (hasRequiredMandaic) return Mandaic;
    hasRequiredMandaic = 1;
    var set = regenerateExports(0x85E);
    set.addRange(0x840, 0x85B);
    Mandaic.characters = set;
    return Mandaic;
  }

var Manichaean = {};

var hasRequiredManichaean;
  function requireManichaean() {
    if (hasRequiredManichaean) return Manichaean;
    hasRequiredManichaean = 1;
    var set = regenerateExports();
    set.addRange(0x10AC0, 0x10AE6).addRange(0x10AEB, 0x10AF6);
    Manichaean.characters = set;
    return Manichaean;
  }

var Marchen = {};

var hasRequiredMarchen;
  function requireMarchen() {
    if (hasRequiredMarchen) return Marchen;
    hasRequiredMarchen = 1;
    var set = regenerateExports();
    set.addRange(0x11C70, 0x11C8F).addRange(0x11C92, 0x11CA7).addRange(0x11CA9, 0x11CB6);
    Marchen.characters = set;
    return Marchen;
  }

var Masaram_Gondi = {};

var hasRequiredMasaram_Gondi;
  function requireMasaram_Gondi() {
    if (hasRequiredMasaram_Gondi) return Masaram_Gondi;
    hasRequiredMasaram_Gondi = 1;
    var set = regenerateExports(0x11D3A);
    set.addRange(0x11D00, 0x11D06).addRange(0x11D08, 0x11D09).addRange(0x11D0B, 0x11D36).addRange(0x11D3C, 0x11D3D).addRange(0x11D3F, 0x11D47).addRange(0x11D50, 0x11D59);
    Masaram_Gondi.characters = set;
    return Masaram_Gondi;
  }

var Medefaidrin = {};

var hasRequiredMedefaidrin;
  function requireMedefaidrin() {
    if (hasRequiredMedefaidrin) return Medefaidrin;
    hasRequiredMedefaidrin = 1;
    var set = regenerateExports();
    set.addRange(0x16E40, 0x16E9A);
    Medefaidrin.characters = set;
    return Medefaidrin;
  }

var Meetei_Mayek = {};

var hasRequiredMeetei_Mayek;
  function requireMeetei_Mayek() {
    if (hasRequiredMeetei_Mayek) return Meetei_Mayek;
    hasRequiredMeetei_Mayek = 1;
    var set = regenerateExports();
    set.addRange(0xAAE0, 0xAAF6).addRange(0xABC0, 0xABED).addRange(0xABF0, 0xABF9);
    Meetei_Mayek.characters = set;
    return Meetei_Mayek;
  }

var Mende_Kikakui = {};

var hasRequiredMende_Kikakui;
  function requireMende_Kikakui() {
    if (hasRequiredMende_Kikakui) return Mende_Kikakui;
    hasRequiredMende_Kikakui = 1;
    var set = regenerateExports();
    set.addRange(0x1E800, 0x1E8C4).addRange(0x1E8C7, 0x1E8D6);
    Mende_Kikakui.characters = set;
    return Mende_Kikakui;
  }

var Meroitic_Cursive = {};

var hasRequiredMeroitic_Cursive;
  function requireMeroitic_Cursive() {
    if (hasRequiredMeroitic_Cursive) return Meroitic_Cursive;
    hasRequiredMeroitic_Cursive = 1;
    var set = regenerateExports();
    set.addRange(0x109A0, 0x109B7).addRange(0x109BC, 0x109CF).addRange(0x109D2, 0x109FF);
    Meroitic_Cursive.characters = set;
    return Meroitic_Cursive;
  }

var Meroitic_Hieroglyphs = {};

var hasRequiredMeroitic_Hieroglyphs;
  function requireMeroitic_Hieroglyphs() {
    if (hasRequiredMeroitic_Hieroglyphs) return Meroitic_Hieroglyphs;
    hasRequiredMeroitic_Hieroglyphs = 1;
    var set = regenerateExports();
    set.addRange(0x10980, 0x1099F);
    Meroitic_Hieroglyphs.characters = set;
    return Meroitic_Hieroglyphs;
  }

var Miao = {};

var hasRequiredMiao;
  function requireMiao() {
    if (hasRequiredMiao) return Miao;
    hasRequiredMiao = 1;
    var set = regenerateExports();
    set.addRange(0x16F00, 0x16F4A).addRange(0x16F4F, 0x16F87).addRange(0x16F8F, 0x16F9F);
    Miao.characters = set;
    return Miao;
  }

var Modi = {};

var hasRequiredModi;
  function requireModi() {
    if (hasRequiredModi) return Modi;
    hasRequiredModi = 1;
    var set = regenerateExports();
    set.addRange(0x11600, 0x11644).addRange(0x11650, 0x11659);
    Modi.characters = set;
    return Modi;
  }

var Mongolian = {};

var hasRequiredMongolian;
  function requireMongolian() {
    if (hasRequiredMongolian) return Mongolian;
    hasRequiredMongolian = 1;
    var set = regenerateExports(0x1804);
    set.addRange(0x1800, 0x1801).addRange(0x1806, 0x1819).addRange(0x1820, 0x1878).addRange(0x1880, 0x18AA).addRange(0x11660, 0x1166C);
    Mongolian.characters = set;
    return Mongolian;
  }

var Mro = {};

var hasRequiredMro;
  function requireMro() {
    if (hasRequiredMro) return Mro;
    hasRequiredMro = 1;
    var set = regenerateExports();
    set.addRange(0x16A40, 0x16A5E).addRange(0x16A60, 0x16A69).addRange(0x16A6E, 0x16A6F);
    Mro.characters = set;
    return Mro;
  }

var Multani = {};

var hasRequiredMultani;
  function requireMultani() {
    if (hasRequiredMultani) return Multani;
    hasRequiredMultani = 1;
    var set = regenerateExports(0x11288);
    set.addRange(0x11280, 0x11286).addRange(0x1128A, 0x1128D).addRange(0x1128F, 0x1129D).addRange(0x1129F, 0x112A9);
    Multani.characters = set;
    return Multani;
  }

var Myanmar = {};

var hasRequiredMyanmar;
  function requireMyanmar() {
    if (hasRequiredMyanmar) return Myanmar;
    hasRequiredMyanmar = 1;
    var set = regenerateExports();
    set.addRange(0x1000, 0x109F).addRange(0xA9E0, 0xA9FE).addRange(0xAA60, 0xAA7F).addRange(0x116D0, 0x116E3);
    Myanmar.characters = set;
    return Myanmar;
  }

var Nabataean = {};

var hasRequiredNabataean;
  function requireNabataean() {
    if (hasRequiredNabataean) return Nabataean;
    hasRequiredNabataean = 1;
    var set = regenerateExports();
    set.addRange(0x10880, 0x1089E).addRange(0x108A7, 0x108AF);
    Nabataean.characters = set;
    return Nabataean;
  }

var Nag_Mundari = {};

var hasRequiredNag_Mundari;
  function requireNag_Mundari() {
    if (hasRequiredNag_Mundari) return Nag_Mundari;
    hasRequiredNag_Mundari = 1;
    var set = regenerateExports();
    set.addRange(0x1E4D0, 0x1E4F9);
    Nag_Mundari.characters = set;
    return Nag_Mundari;
  }

var Nandinagari = {};

var hasRequiredNandinagari;
  function requireNandinagari() {
    if (hasRequiredNandinagari) return Nandinagari;
    hasRequiredNandinagari = 1;
    var set = regenerateExports();
    set.addRange(0x119A0, 0x119A7).addRange(0x119AA, 0x119D7).addRange(0x119DA, 0x119E4);
    Nandinagari.characters = set;
    return Nandinagari;
  }

var New_Tai_Lue = {};

var hasRequiredNew_Tai_Lue;
  function requireNew_Tai_Lue() {
    if (hasRequiredNew_Tai_Lue) return New_Tai_Lue;
    hasRequiredNew_Tai_Lue = 1;
    var set = regenerateExports();
    set.addRange(0x1980, 0x19AB).addRange(0x19B0, 0x19C9).addRange(0x19D0, 0x19DA).addRange(0x19DE, 0x19DF);
    New_Tai_Lue.characters = set;
    return New_Tai_Lue;
  }

var Newa = {};

var hasRequiredNewa;
  function requireNewa() {
    if (hasRequiredNewa) return Newa;
    hasRequiredNewa = 1;
    var set = regenerateExports();
    set.addRange(0x11400, 0x1145B).addRange(0x1145D, 0x11461);
    Newa.characters = set;
    return Newa;
  }

var Nko = {};

var hasRequiredNko;
  function requireNko() {
    if (hasRequiredNko) return Nko;
    hasRequiredNko = 1;
    var set = regenerateExports();
    set.addRange(0x7C0, 0x7FA).addRange(0x7FD, 0x7FF);
    Nko.characters = set;
    return Nko;
  }

var Nushu = {};

var hasRequiredNushu;
  function requireNushu() {
    if (hasRequiredNushu) return Nushu;
    hasRequiredNushu = 1;
    var set = regenerateExports(0x16FE1);
    set.addRange(0x1B170, 0x1B2FB);
    Nushu.characters = set;
    return Nushu;
  }

var Nyiakeng_Puachue_Hmong = {};

var hasRequiredNyiakeng_Puachue_Hmong;
  function requireNyiakeng_Puachue_Hmong() {
    if (hasRequiredNyiakeng_Puachue_Hmong) return Nyiakeng_Puachue_Hmong;
    hasRequiredNyiakeng_Puachue_Hmong = 1;
    var set = regenerateExports();
    set.addRange(0x1E100, 0x1E12C).addRange(0x1E130, 0x1E13D).addRange(0x1E140, 0x1E149).addRange(0x1E14E, 0x1E14F);
    Nyiakeng_Puachue_Hmong.characters = set;
    return Nyiakeng_Puachue_Hmong;
  }

var Ogham = {};

var hasRequiredOgham;
  function requireOgham() {
    if (hasRequiredOgham) return Ogham;
    hasRequiredOgham = 1;
    var set = regenerateExports();
    set.addRange(0x1680, 0x169C);
    Ogham.characters = set;
    return Ogham;
  }

var Ol_Chiki = {};

var hasRequiredOl_Chiki;
  function requireOl_Chiki() {
    if (hasRequiredOl_Chiki) return Ol_Chiki;
    hasRequiredOl_Chiki = 1;
    var set = regenerateExports();
    set.addRange(0x1C50, 0x1C7F);
    Ol_Chiki.characters = set;
    return Ol_Chiki;
  }

var Ol_Onal = {};

var hasRequiredOl_Onal;
  function requireOl_Onal() {
    if (hasRequiredOl_Onal) return Ol_Onal;
    hasRequiredOl_Onal = 1;
    var set = regenerateExports(0x1E5FF);
    set.addRange(0x1E5D0, 0x1E5FA);
    Ol_Onal.characters = set;
    return Ol_Onal;
  }

var Old_Hungarian = {};

var hasRequiredOld_Hungarian;
  function requireOld_Hungarian() {
    if (hasRequiredOld_Hungarian) return Old_Hungarian;
    hasRequiredOld_Hungarian = 1;
    var set = regenerateExports();
    set.addRange(0x10C80, 0x10CB2).addRange(0x10CC0, 0x10CF2).addRange(0x10CFA, 0x10CFF);
    Old_Hungarian.characters = set;
    return Old_Hungarian;
  }

var Old_Italic = {};

var hasRequiredOld_Italic;
  function requireOld_Italic() {
    if (hasRequiredOld_Italic) return Old_Italic;
    hasRequiredOld_Italic = 1;
    var set = regenerateExports();
    set.addRange(0x10300, 0x10323).addRange(0x1032D, 0x1032F);
    Old_Italic.characters = set;
    return Old_Italic;
  }

var Old_North_Arabian = {};

var hasRequiredOld_North_Arabian;
  function requireOld_North_Arabian() {
    if (hasRequiredOld_North_Arabian) return Old_North_Arabian;
    hasRequiredOld_North_Arabian = 1;
    var set = regenerateExports();
    set.addRange(0x10A80, 0x10A9F);
    Old_North_Arabian.characters = set;
    return Old_North_Arabian;
  }

var Old_Permic = {};

var hasRequiredOld_Permic;
  function requireOld_Permic() {
    if (hasRequiredOld_Permic) return Old_Permic;
    hasRequiredOld_Permic = 1;
    var set = regenerateExports();
    set.addRange(0x10350, 0x1037A);
    Old_Permic.characters = set;
    return Old_Permic;
  }

var Old_Persian = {};

var hasRequiredOld_Persian;
  function requireOld_Persian() {
    if (hasRequiredOld_Persian) return Old_Persian;
    hasRequiredOld_Persian = 1;
    var set = regenerateExports();
    set.addRange(0x103A0, 0x103C3).addRange(0x103C8, 0x103D5);
    Old_Persian.characters = set;
    return Old_Persian;
  }

var Old_Sogdian = {};

var hasRequiredOld_Sogdian;
  function requireOld_Sogdian() {
    if (hasRequiredOld_Sogdian) return Old_Sogdian;
    hasRequiredOld_Sogdian = 1;
    var set = regenerateExports();
    set.addRange(0x10F00, 0x10F27);
    Old_Sogdian.characters = set;
    return Old_Sogdian;
  }

var Old_South_Arabian = {};

var hasRequiredOld_South_Arabian;
  function requireOld_South_Arabian() {
    if (hasRequiredOld_South_Arabian) return Old_South_Arabian;
    hasRequiredOld_South_Arabian = 1;
    var set = regenerateExports();
    set.addRange(0x10A60, 0x10A7F);
    Old_South_Arabian.characters = set;
    return Old_South_Arabian;
  }

var Old_Turkic = {};

var hasRequiredOld_Turkic;
  function requireOld_Turkic() {
    if (hasRequiredOld_Turkic) return Old_Turkic;
    hasRequiredOld_Turkic = 1;
    var set = regenerateExports();
    set.addRange(0x10C00, 0x10C48);
    Old_Turkic.characters = set;
    return Old_Turkic;
  }

var Old_Uyghur = {};

var hasRequiredOld_Uyghur;
  function requireOld_Uyghur() {
    if (hasRequiredOld_Uyghur) return Old_Uyghur;
    hasRequiredOld_Uyghur = 1;
    var set = regenerateExports();
    set.addRange(0x10F70, 0x10F89);
    Old_Uyghur.characters = set;
    return Old_Uyghur;
  }

var Oriya = {};

var hasRequiredOriya;
  function requireOriya() {
    if (hasRequiredOriya) return Oriya;
    hasRequiredOriya = 1;
    var set = regenerateExports();
    set.addRange(0xB01, 0xB03).addRange(0xB05, 0xB0C).addRange(0xB0F, 0xB10).addRange(0xB13, 0xB28).addRange(0xB2A, 0xB30).addRange(0xB32, 0xB33).addRange(0xB35, 0xB39).addRange(0xB3C, 0xB44).addRange(0xB47, 0xB48).addRange(0xB4B, 0xB4D).addRange(0xB55, 0xB57).addRange(0xB5C, 0xB5D).addRange(0xB5F, 0xB63).addRange(0xB66, 0xB77);
    Oriya.characters = set;
    return Oriya;
  }

var Osage = {};

var hasRequiredOsage;
  function requireOsage() {
    if (hasRequiredOsage) return Osage;
    hasRequiredOsage = 1;
    var set = regenerateExports();
    set.addRange(0x104B0, 0x104D3).addRange(0x104D8, 0x104FB);
    Osage.characters = set;
    return Osage;
  }

var Osmanya = {};

var hasRequiredOsmanya;
  function requireOsmanya() {
    if (hasRequiredOsmanya) return Osmanya;
    hasRequiredOsmanya = 1;
    var set = regenerateExports();
    set.addRange(0x10480, 0x1049D).addRange(0x104A0, 0x104A9);
    Osmanya.characters = set;
    return Osmanya;
  }

var Pahawh_Hmong = {};

var hasRequiredPahawh_Hmong;
  function requirePahawh_Hmong() {
    if (hasRequiredPahawh_Hmong) return Pahawh_Hmong;
    hasRequiredPahawh_Hmong = 1;
    var set = regenerateExports();
    set.addRange(0x16B00, 0x16B45).addRange(0x16B50, 0x16B59).addRange(0x16B5B, 0x16B61).addRange(0x16B63, 0x16B77).addRange(0x16B7D, 0x16B8F);
    Pahawh_Hmong.characters = set;
    return Pahawh_Hmong;
  }

var Palmyrene = {};

var hasRequiredPalmyrene;
  function requirePalmyrene() {
    if (hasRequiredPalmyrene) return Palmyrene;
    hasRequiredPalmyrene = 1;
    var set = regenerateExports();
    set.addRange(0x10860, 0x1087F);
    Palmyrene.characters = set;
    return Palmyrene;
  }

var Pau_Cin_Hau = {};

var hasRequiredPau_Cin_Hau;
  function requirePau_Cin_Hau() {
    if (hasRequiredPau_Cin_Hau) return Pau_Cin_Hau;
    hasRequiredPau_Cin_Hau = 1;
    var set = regenerateExports();
    set.addRange(0x11AC0, 0x11AF8);
    Pau_Cin_Hau.characters = set;
    return Pau_Cin_Hau;
  }

var Phags_Pa = {};

var hasRequiredPhags_Pa;
  function requirePhags_Pa() {
    if (hasRequiredPhags_Pa) return Phags_Pa;
    hasRequiredPhags_Pa = 1;
    var set = regenerateExports();
    set.addRange(0xA840, 0xA877);
    Phags_Pa.characters = set;
    return Phags_Pa;
  }

var Phoenician = {};

var hasRequiredPhoenician;
  function requirePhoenician() {
    if (hasRequiredPhoenician) return Phoenician;
    hasRequiredPhoenician = 1;
    var set = regenerateExports(0x1091F);
    set.addRange(0x10900, 0x1091B);
    Phoenician.characters = set;
    return Phoenician;
  }

var Psalter_Pahlavi = {};

var hasRequiredPsalter_Pahlavi;
  function requirePsalter_Pahlavi() {
    if (hasRequiredPsalter_Pahlavi) return Psalter_Pahlavi;
    hasRequiredPsalter_Pahlavi = 1;
    var set = regenerateExports();
    set.addRange(0x10B80, 0x10B91).addRange(0x10B99, 0x10B9C).addRange(0x10BA9, 0x10BAF);
    Psalter_Pahlavi.characters = set;
    return Psalter_Pahlavi;
  }

var Rejang = {};

var hasRequiredRejang;
  function requireRejang() {
    if (hasRequiredRejang) return Rejang;
    hasRequiredRejang = 1;
    var set = regenerateExports(0xA95F);
    set.addRange(0xA930, 0xA953);
    Rejang.characters = set;
    return Rejang;
  }

var Runic = {};

var hasRequiredRunic;
  function requireRunic() {
    if (hasRequiredRunic) return Runic;
    hasRequiredRunic = 1;
    var set = regenerateExports();
    set.addRange(0x16A0, 0x16EA).addRange(0x16EE, 0x16F8);
    Runic.characters = set;
    return Runic;
  }

var Samaritan = {};

var hasRequiredSamaritan;
  function requireSamaritan() {
    if (hasRequiredSamaritan) return Samaritan;
    hasRequiredSamaritan = 1;
    var set = regenerateExports();
    set.addRange(0x800, 0x82D).addRange(0x830, 0x83E);
    Samaritan.characters = set;
    return Samaritan;
  }

var Saurashtra = {};

var hasRequiredSaurashtra;
  function requireSaurashtra() {
    if (hasRequiredSaurashtra) return Saurashtra;
    hasRequiredSaurashtra = 1;
    var set = regenerateExports();
    set.addRange(0xA880, 0xA8C5).addRange(0xA8CE, 0xA8D9);
    Saurashtra.characters = set;
    return Saurashtra;
  }

var Sharada = {};

var hasRequiredSharada;
  function requireSharada() {
    if (hasRequiredSharada) return Sharada;
    hasRequiredSharada = 1;
    var set = regenerateExports();
    set.addRange(0x11180, 0x111DF);
    Sharada.characters = set;
    return Sharada;
  }

var Shavian = {};

var hasRequiredShavian;
  function requireShavian() {
    if (hasRequiredShavian) return Shavian;
    hasRequiredShavian = 1;
    var set = regenerateExports();
    set.addRange(0x10450, 0x1047F);
    Shavian.characters = set;
    return Shavian;
  }

var Siddham = {};

var hasRequiredSiddham;
  function requireSiddham() {
    if (hasRequiredSiddham) return Siddham;
    hasRequiredSiddham = 1;
    var set = regenerateExports();
    set.addRange(0x11580, 0x115B5).addRange(0x115B8, 0x115DD);
    Siddham.characters = set;
    return Siddham;
  }

var SignWriting = {};

var hasRequiredSignWriting;
  function requireSignWriting() {
    if (hasRequiredSignWriting) return SignWriting;
    hasRequiredSignWriting = 1;
    var set = regenerateExports();
    set.addRange(0x1D800, 0x1DA8B).addRange(0x1DA9B, 0x1DA9F).addRange(0x1DAA1, 0x1DAAF);
    SignWriting.characters = set;
    return SignWriting;
  }

var Sinhala = {};

var hasRequiredSinhala;
  function requireSinhala() {
    if (hasRequiredSinhala) return Sinhala;
    hasRequiredSinhala = 1;
    var set = regenerateExports(0xDBD, 0xDCA, 0xDD6);
    set.addRange(0xD81, 0xD83).addRange(0xD85, 0xD96).addRange(0xD9A, 0xDB1).addRange(0xDB3, 0xDBB).addRange(0xDC0, 0xDC6).addRange(0xDCF, 0xDD4).addRange(0xDD8, 0xDDF).addRange(0xDE6, 0xDEF).addRange(0xDF2, 0xDF4).addRange(0x111E1, 0x111F4);
    Sinhala.characters = set;
    return Sinhala;
  }

var Sogdian = {};

var hasRequiredSogdian;
  function requireSogdian() {
    if (hasRequiredSogdian) return Sogdian;
    hasRequiredSogdian = 1;
    var set = regenerateExports();
    set.addRange(0x10F30, 0x10F59);
    Sogdian.characters = set;
    return Sogdian;
  }

var Sora_Sompeng = {};

var hasRequiredSora_Sompeng;
  function requireSora_Sompeng() {
    if (hasRequiredSora_Sompeng) return Sora_Sompeng;
    hasRequiredSora_Sompeng = 1;
    var set = regenerateExports();
    set.addRange(0x110D0, 0x110E8).addRange(0x110F0, 0x110F9);
    Sora_Sompeng.characters = set;
    return Sora_Sompeng;
  }

var Soyombo = {};

var hasRequiredSoyombo;
  function requireSoyombo() {
    if (hasRequiredSoyombo) return Soyombo;
    hasRequiredSoyombo = 1;
    var set = regenerateExports();
    set.addRange(0x11A50, 0x11AA2);
    Soyombo.characters = set;
    return Soyombo;
  }

var Sundanese = {};

var hasRequiredSundanese;
  function requireSundanese() {
    if (hasRequiredSundanese) return Sundanese;
    hasRequiredSundanese = 1;
    var set = regenerateExports();
    set.addRange(0x1B80, 0x1BBF).addRange(0x1CC0, 0x1CC7);
    Sundanese.characters = set;
    return Sundanese;
  }

var Sunuwar = {};

var hasRequiredSunuwar;
  function requireSunuwar() {
    if (hasRequiredSunuwar) return Sunuwar;
    hasRequiredSunuwar = 1;
    var set = regenerateExports();
    set.addRange(0x11BC0, 0x11BE1).addRange(0x11BF0, 0x11BF9);
    Sunuwar.characters = set;
    return Sunuwar;
  }

var Syloti_Nagri = {};

var hasRequiredSyloti_Nagri;
  function requireSyloti_Nagri() {
    if (hasRequiredSyloti_Nagri) return Syloti_Nagri;
    hasRequiredSyloti_Nagri = 1;
    var set = regenerateExports();
    set.addRange(0xA800, 0xA82C);
    Syloti_Nagri.characters = set;
    return Syloti_Nagri;
  }

var Syriac = {};

var hasRequiredSyriac;
  function requireSyriac() {
    if (hasRequiredSyriac) return Syriac;
    hasRequiredSyriac = 1;
    var set = regenerateExports();
    set.addRange(0x700, 0x70D).addRange(0x70F, 0x74A).addRange(0x74D, 0x74F).addRange(0x860, 0x86A);
    Syriac.characters = set;
    return Syriac;
  }

var Tagalog = {};

var hasRequiredTagalog;
  function requireTagalog() {
    if (hasRequiredTagalog) return Tagalog;
    hasRequiredTagalog = 1;
    var set = regenerateExports(0x171F);
    set.addRange(0x1700, 0x1715);
    Tagalog.characters = set;
    return Tagalog;
  }

var Tagbanwa = {};

var hasRequiredTagbanwa;
  function requireTagbanwa() {
    if (hasRequiredTagbanwa) return Tagbanwa;
    hasRequiredTagbanwa = 1;
    var set = regenerateExports();
    set.addRange(0x1760, 0x176C).addRange(0x176E, 0x1770).addRange(0x1772, 0x1773);
    Tagbanwa.characters = set;
    return Tagbanwa;
  }

var Tai_Le = {};

var hasRequiredTai_Le;
  function requireTai_Le() {
    if (hasRequiredTai_Le) return Tai_Le;
    hasRequiredTai_Le = 1;
    var set = regenerateExports();
    set.addRange(0x1950, 0x196D).addRange(0x1970, 0x1974);
    Tai_Le.characters = set;
    return Tai_Le;
  }

var Tai_Tham = {};

var hasRequiredTai_Tham;
  function requireTai_Tham() {
    if (hasRequiredTai_Tham) return Tai_Tham;
    hasRequiredTai_Tham = 1;
    var set = regenerateExports();
    set.addRange(0x1A20, 0x1A5E).addRange(0x1A60, 0x1A7C).addRange(0x1A7F, 0x1A89).addRange(0x1A90, 0x1A99).addRange(0x1AA0, 0x1AAD);
    Tai_Tham.characters = set;
    return Tai_Tham;
  }

var Tai_Viet = {};

var hasRequiredTai_Viet;
  function requireTai_Viet() {
    if (hasRequiredTai_Viet) return Tai_Viet;
    hasRequiredTai_Viet = 1;
    var set = regenerateExports();
    set.addRange(0xAA80, 0xAAC2).addRange(0xAADB, 0xAADF);
    Tai_Viet.characters = set;
    return Tai_Viet;
  }

var Takri = {};

var hasRequiredTakri;
  function requireTakri() {
    if (hasRequiredTakri) return Takri;
    hasRequiredTakri = 1;
    var set = regenerateExports();
    set.addRange(0x11680, 0x116B9).addRange(0x116C0, 0x116C9);
    Takri.characters = set;
    return Takri;
  }

var Tamil = {};

var hasRequiredTamil;
  function requireTamil() {
    if (hasRequiredTamil) return Tamil;
    hasRequiredTamil = 1;
    var set = regenerateExports(0xB9C, 0xBD0, 0xBD7, 0x11FFF);
    set.addRange(0xB82, 0xB83).addRange(0xB85, 0xB8A).addRange(0xB8E, 0xB90).addRange(0xB92, 0xB95).addRange(0xB99, 0xB9A).addRange(0xB9E, 0xB9F).addRange(0xBA3, 0xBA4).addRange(0xBA8, 0xBAA).addRange(0xBAE, 0xBB9).addRange(0xBBE, 0xBC2).addRange(0xBC6, 0xBC8).addRange(0xBCA, 0xBCD).addRange(0xBE6, 0xBFA).addRange(0x11FC0, 0x11FF1);
    Tamil.characters = set;
    return Tamil;
  }

var Tangsa = {};

var hasRequiredTangsa;
  function requireTangsa() {
    if (hasRequiredTangsa) return Tangsa;
    hasRequiredTangsa = 1;
    var set = regenerateExports();
    set.addRange(0x16A70, 0x16ABE).addRange(0x16AC0, 0x16AC9);
    Tangsa.characters = set;
    return Tangsa;
  }

var Tangut = {};

var hasRequiredTangut;
  function requireTangut() {
    if (hasRequiredTangut) return Tangut;
    hasRequiredTangut = 1;
    var set = regenerateExports(0x16FE0);
    set.addRange(0x17000, 0x187F7).addRange(0x18800, 0x18AFF).addRange(0x18D00, 0x18D08);
    Tangut.characters = set;
    return Tangut;
  }

var Telugu = {};

var hasRequiredTelugu;
  function requireTelugu() {
    if (hasRequiredTelugu) return Telugu;
    hasRequiredTelugu = 1;
    var set = regenerateExports(0xC5D);
    set.addRange(0xC00, 0xC0C).addRange(0xC0E, 0xC10).addRange(0xC12, 0xC28).addRange(0xC2A, 0xC39).addRange(0xC3C, 0xC44).addRange(0xC46, 0xC48).addRange(0xC4A, 0xC4D).addRange(0xC55, 0xC56).addRange(0xC58, 0xC5A).addRange(0xC60, 0xC63).addRange(0xC66, 0xC6F).addRange(0xC77, 0xC7F);
    Telugu.characters = set;
    return Telugu;
  }

var Thaana = {};

var hasRequiredThaana;
  function requireThaana() {
    if (hasRequiredThaana) return Thaana;
    hasRequiredThaana = 1;
    var set = regenerateExports();
    set.addRange(0x780, 0x7B1);
    Thaana.characters = set;
    return Thaana;
  }

var Thai = {};

var hasRequiredThai;
  function requireThai() {
    if (hasRequiredThai) return Thai;
    hasRequiredThai = 1;
    var set = regenerateExports();
    set.addRange(0xE01, 0xE3A).addRange(0xE40, 0xE5B);
    Thai.characters = set;
    return Thai;
  }

var Tibetan = {};

var hasRequiredTibetan;
  function requireTibetan() {
    if (hasRequiredTibetan) return Tibetan;
    hasRequiredTibetan = 1;
    var set = regenerateExports();
    set.addRange(0xF00, 0xF47).addRange(0xF49, 0xF6C).addRange(0xF71, 0xF97).addRange(0xF99, 0xFBC).addRange(0xFBE, 0xFCC).addRange(0xFCE, 0xFD4).addRange(0xFD9, 0xFDA);
    Tibetan.characters = set;
    return Tibetan;
  }

var Tifinagh = {};

var hasRequiredTifinagh;
  function requireTifinagh() {
    if (hasRequiredTifinagh) return Tifinagh;
    hasRequiredTifinagh = 1;
    var set = regenerateExports(0x2D7F);
    set.addRange(0x2D30, 0x2D67).addRange(0x2D6F, 0x2D70);
    Tifinagh.characters = set;
    return Tifinagh;
  }

var Tirhuta = {};

var hasRequiredTirhuta;
  function requireTirhuta() {
    if (hasRequiredTirhuta) return Tirhuta;
    hasRequiredTirhuta = 1;
    var set = regenerateExports();
    set.addRange(0x11480, 0x114C7).addRange(0x114D0, 0x114D9);
    Tirhuta.characters = set;
    return Tirhuta;
  }

var Todhri = {};

var hasRequiredTodhri;
  function requireTodhri() {
    if (hasRequiredTodhri) return Todhri;
    hasRequiredTodhri = 1;
    var set = regenerateExports();
    set.addRange(0x105C0, 0x105F3);
    Todhri.characters = set;
    return Todhri;
  }

var Toto = {};

var hasRequiredToto;
  function requireToto() {
    if (hasRequiredToto) return Toto;
    hasRequiredToto = 1;
    var set = regenerateExports();
    set.addRange(0x1E290, 0x1E2AE);
    Toto.characters = set;
    return Toto;
  }

var Tulu_Tigalari = {};

var hasRequiredTulu_Tigalari;
  function requireTulu_Tigalari() {
    if (hasRequiredTulu_Tigalari) return Tulu_Tigalari;
    hasRequiredTulu_Tigalari = 1;
    var set = regenerateExports(0x1138B, 0x1138E, 0x113C2, 0x113C5);
    set.addRange(0x11380, 0x11389).addRange(0x11390, 0x113B5).addRange(0x113B7, 0x113C0).addRange(0x113C7, 0x113CA).addRange(0x113CC, 0x113D5).addRange(0x113D7, 0x113D8).addRange(0x113E1, 0x113E2);
    Tulu_Tigalari.characters = set;
    return Tulu_Tigalari;
  }

var Ugaritic = {};

var hasRequiredUgaritic;
  function requireUgaritic() {
    if (hasRequiredUgaritic) return Ugaritic;
    hasRequiredUgaritic = 1;
    var set = regenerateExports(0x1039F);
    set.addRange(0x10380, 0x1039D);
    Ugaritic.characters = set;
    return Ugaritic;
  }

var Vai = {};

var hasRequiredVai;
  function requireVai() {
    if (hasRequiredVai) return Vai;
    hasRequiredVai = 1;
    var set = regenerateExports();
    set.addRange(0xA500, 0xA62B);
    Vai.characters = set;
    return Vai;
  }

var Vithkuqi = {};

var hasRequiredVithkuqi;
  function requireVithkuqi() {
    if (hasRequiredVithkuqi) return Vithkuqi;
    hasRequiredVithkuqi = 1;
    var set = regenerateExports();
    set.addRange(0x10570, 0x1057A).addRange(0x1057C, 0x1058A).addRange(0x1058C, 0x10592).addRange(0x10594, 0x10595).addRange(0x10597, 0x105A1).addRange(0x105A3, 0x105B1).addRange(0x105B3, 0x105B9).addRange(0x105BB, 0x105BC);
    Vithkuqi.characters = set;
    return Vithkuqi;
  }

var Wancho = {};

var hasRequiredWancho;
  function requireWancho() {
    if (hasRequiredWancho) return Wancho;
    hasRequiredWancho = 1;
    var set = regenerateExports(0x1E2FF);
    set.addRange(0x1E2C0, 0x1E2F9);
    Wancho.characters = set;
    return Wancho;
  }

var Warang_Citi = {};

var hasRequiredWarang_Citi;
  function requireWarang_Citi() {
    if (hasRequiredWarang_Citi) return Warang_Citi;
    hasRequiredWarang_Citi = 1;
    var set = regenerateExports(0x118FF);
    set.addRange(0x118A0, 0x118F2);
    Warang_Citi.characters = set;
    return Warang_Citi;
  }

var Yezidi = {};

var hasRequiredYezidi;
  function requireYezidi() {
    if (hasRequiredYezidi) return Yezidi;
    hasRequiredYezidi = 1;
    var set = regenerateExports();
    set.addRange(0x10E80, 0x10EA9).addRange(0x10EAB, 0x10EAD).addRange(0x10EB0, 0x10EB1);
    Yezidi.characters = set;
    return Yezidi;
  }

var Yi = {};

var hasRequiredYi;
  function requireYi() {
    if (hasRequiredYi) return Yi;
    hasRequiredYi = 1;
    var set = regenerateExports();
    set.addRange(0xA000, 0xA48C).addRange(0xA490, 0xA4C6);
    Yi.characters = set;
    return Yi;
  }

var Zanabazar_Square = {};

var hasRequiredZanabazar_Square;
  function requireZanabazar_Square() {
    if (hasRequiredZanabazar_Square) return Zanabazar_Square;
    hasRequiredZanabazar_Square = 1;
    var set = regenerateExports();
    set.addRange(0x11A00, 0x11A47);
    Zanabazar_Square.characters = set;
    return Zanabazar_Square;
  }

var unicodeVersion;
  var hasRequiredUnicodeVersion;
  function requireUnicodeVersion() {
    if (hasRequiredUnicodeVersion) return unicodeVersion;
    hasRequiredUnicodeVersion = 1;
    unicodeVersion = '16.0.0';
    return unicodeVersion;
  }

var dynamicModules;

function getDynamicModules() {
  	return dynamicModules || (dynamicModules = {
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Alphabetic.js": requireAlphabetic,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Any.js": requireAny,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/ASCII_Hex_Digit.js": requireASCII_Hex_Digit,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/ASCII.js": requireASCII,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Assigned.js": requireAssigned,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Bidi_Control.js": requireBidi_Control,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Bidi_Mirrored.js": requireBidi_Mirrored,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Case_Ignorable.js": requireCase_Ignorable,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Cased.js": requireCased,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Casefolded.js": requireChanges_When_Casefolded,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Casemapped.js": requireChanges_When_Casemapped,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Lowercased.js": requireChanges_When_Lowercased,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_NFKC_Casefolded.js": requireChanges_When_NFKC_Casefolded,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Titlecased.js": requireChanges_When_Titlecased,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Changes_When_Uppercased.js": requireChanges_When_Uppercased,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Dash.js": requireDash,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Default_Ignorable_Code_Point.js": requireDefault_Ignorable_Code_Point,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Deprecated.js": requireDeprecated,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Diacritic.js": requireDiacritic,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Component.js": requireEmoji_Component,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Modifier_Base.js": requireEmoji_Modifier_Base,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Modifier.js": requireEmoji_Modifier,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Emoji_Presentation.js": requireEmoji_Presentation,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Emoji.js": requireEmoji,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Extended_Pictographic.js": requireExtended_Pictographic,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Extender.js": requireExtender,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Grapheme_Base.js": requireGrapheme_Base,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Grapheme_Extend.js": requireGrapheme_Extend,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Hex_Digit.js": requireHex_Digit,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/ID_Continue.js": requireID_Continue,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/ID_Start.js": requireID_Start,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Ideographic.js": requireIdeographic,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/IDS_Binary_Operator.js": requireIDS_Binary_Operator,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/IDS_Trinary_Operator.js": requireIDS_Trinary_Operator,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Join_Control.js": requireJoin_Control,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Logical_Order_Exception.js": requireLogical_Order_Exception,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Lowercase.js": requireLowercase,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Math.js": require_Math,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Noncharacter_Code_Point.js": requireNoncharacter_Code_Point,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Pattern_Syntax.js": requirePattern_Syntax,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Pattern_White_Space.js": requirePattern_White_Space,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Quotation_Mark.js": requireQuotation_Mark,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Radical.js": requireRadical,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Regional_Indicator.js": requireRegional_Indicator,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Sentence_Terminal.js": requireSentence_Terminal,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Soft_Dotted.js": requireSoft_Dotted,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Terminal_Punctuation.js": requireTerminal_Punctuation,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Unified_Ideograph.js": requireUnified_Ideograph,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Uppercase.js": requireUppercase,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/Variation_Selector.js": requireVariation_Selector,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/White_Space.js": requireWhite_Space,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/XID_Continue.js": requireXID_Continue,
  		"/node_modules/regenerate-unicode-properties/Binary_Property/XID_Start.js": requireXID_Start,
  		"/node_modules/regenerate-unicode-properties/General_Category/Cased_Letter.js": requireCased_Letter,
  		"/node_modules/regenerate-unicode-properties/General_Category/Close_Punctuation.js": requireClose_Punctuation,
  		"/node_modules/regenerate-unicode-properties/General_Category/Connector_Punctuation.js": requireConnector_Punctuation,
  		"/node_modules/regenerate-unicode-properties/General_Category/Control.js": requireControl,
  		"/node_modules/regenerate-unicode-properties/General_Category/Currency_Symbol.js": requireCurrency_Symbol,
  		"/node_modules/regenerate-unicode-properties/General_Category/Dash_Punctuation.js": requireDash_Punctuation,
  		"/node_modules/regenerate-unicode-properties/General_Category/Decimal_Number.js": requireDecimal_Number,
  		"/node_modules/regenerate-unicode-properties/General_Category/Enclosing_Mark.js": requireEnclosing_Mark,
  		"/node_modules/regenerate-unicode-properties/General_Category/Final_Punctuation.js": requireFinal_Punctuation,
  		"/node_modules/regenerate-unicode-properties/General_Category/Format.js": requireFormat,
  		"/node_modules/regenerate-unicode-properties/General_Category/Initial_Punctuation.js": requireInitial_Punctuation,
  		"/node_modules/regenerate-unicode-properties/General_Category/Letter_Number.js": requireLetter_Number,
  		"/node_modules/regenerate-unicode-properties/General_Category/Letter.js": requireLetter,
  		"/node_modules/regenerate-unicode-properties/General_Category/Line_Separator.js": requireLine_Separator,
  		"/node_modules/regenerate-unicode-properties/General_Category/Lowercase_Letter.js": requireLowercase_Letter,
  		"/node_modules/regenerate-unicode-properties/General_Category/Mark.js": requireMark,
  		"/node_modules/regenerate-unicode-properties/General_Category/Math_Symbol.js": requireMath_Symbol,
  		"/node_modules/regenerate-unicode-properties/General_Category/Modifier_Letter.js": requireModifier_Letter,
  		"/node_modules/regenerate-unicode-properties/General_Category/Modifier_Symbol.js": requireModifier_Symbol,
  		"/node_modules/regenerate-unicode-properties/General_Category/Nonspacing_Mark.js": requireNonspacing_Mark,
  		"/node_modules/regenerate-unicode-properties/General_Category/Number.js": require_Number,
  		"/node_modules/regenerate-unicode-properties/General_Category/Open_Punctuation.js": requireOpen_Punctuation,
  		"/node_modules/regenerate-unicode-properties/General_Category/Other_Letter.js": requireOther_Letter,
  		"/node_modules/regenerate-unicode-properties/General_Category/Other_Number.js": requireOther_Number,
  		"/node_modules/regenerate-unicode-properties/General_Category/Other_Punctuation.js": requireOther_Punctuation,
  		"/node_modules/regenerate-unicode-properties/General_Category/Other_Symbol.js": requireOther_Symbol,
  		"/node_modules/regenerate-unicode-properties/General_Category/Other.js": requireOther,
  		"/node_modules/regenerate-unicode-properties/General_Category/Paragraph_Separator.js": requireParagraph_Separator,
  		"/node_modules/regenerate-unicode-properties/General_Category/Private_Use.js": requirePrivate_Use,
  		"/node_modules/regenerate-unicode-properties/General_Category/Punctuation.js": requirePunctuation,
  		"/node_modules/regenerate-unicode-properties/General_Category/Separator.js": requireSeparator,
  		"/node_modules/regenerate-unicode-properties/General_Category/Space_Separator.js": requireSpace_Separator,
  		"/node_modules/regenerate-unicode-properties/General_Category/Spacing_Mark.js": requireSpacing_Mark,
  		"/node_modules/regenerate-unicode-properties/General_Category/Surrogate.js": requireSurrogate,
  		"/node_modules/regenerate-unicode-properties/General_Category/Symbol.js": require_Symbol,
  		"/node_modules/regenerate-unicode-properties/General_Category/Titlecase_Letter.js": requireTitlecase_Letter,
  		"/node_modules/regenerate-unicode-properties/General_Category/Unassigned.js": requireUnassigned,
  		"/node_modules/regenerate-unicode-properties/General_Category/Uppercase_Letter.js": requireUppercase_Letter,
  		"/node_modules/regenerate-unicode-properties/index.js": requireRegenerateUnicodeProperties,
  		"/node_modules/regenerate-unicode-properties/Property_of_Strings/Basic_Emoji.js": requireBasic_Emoji,
  		"/node_modules/regenerate-unicode-properties/Property_of_Strings/Emoji_Keycap_Sequence.js": requireEmoji_Keycap_Sequence,
  		"/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Flag_Sequence.js": requireRGI_Emoji_Flag_Sequence,
  		"/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Modifier_Sequence.js": requireRGI_Emoji_Modifier_Sequence,
  		"/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_Tag_Sequence.js": requireRGI_Emoji_Tag_Sequence,
  		"/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji_ZWJ_Sequence.js": requireRGI_Emoji_ZWJ_Sequence,
  		"/node_modules/regenerate-unicode-properties/Property_of_Strings/RGI_Emoji.js": requireRGI_Emoji,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Adlam.js": requireAdlam$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Ahom.js": requireAhom$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Anatolian_Hieroglyphs.js": requireAnatolian_Hieroglyphs$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Arabic.js": requireArabic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Armenian.js": requireArmenian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Avestan.js": requireAvestan$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Balinese.js": requireBalinese$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Bamum.js": requireBamum$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Bassa_Vah.js": requireBassa_Vah$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Batak.js": requireBatak$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Bengali.js": requireBengali$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Bhaiksuki.js": requireBhaiksuki$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Bopomofo.js": requireBopomofo$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Brahmi.js": requireBrahmi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Braille.js": requireBraille$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Buginese.js": requireBuginese$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Buhid.js": requireBuhid$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Canadian_Aboriginal.js": requireCanadian_Aboriginal$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Carian.js": requireCarian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Caucasian_Albanian.js": requireCaucasian_Albanian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Chakma.js": requireChakma$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Cham.js": requireCham$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Cherokee.js": requireCherokee$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Chorasmian.js": requireChorasmian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Common.js": requireCommon$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Coptic.js": requireCoptic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Cuneiform.js": requireCuneiform$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Cypriot.js": requireCypriot$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Cypro_Minoan.js": requireCypro_Minoan$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Cyrillic.js": requireCyrillic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Deseret.js": requireDeseret$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Devanagari.js": requireDevanagari$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Dives_Akuru.js": requireDives_Akuru$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Dogra.js": requireDogra$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Duployan.js": requireDuployan$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Egyptian_Hieroglyphs.js": requireEgyptian_Hieroglyphs$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Elbasan.js": requireElbasan$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Elymaic.js": requireElymaic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Ethiopic.js": requireEthiopic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Garay.js": requireGaray$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Georgian.js": requireGeorgian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Glagolitic.js": requireGlagolitic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Gothic.js": requireGothic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Grantha.js": requireGrantha$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Greek.js": requireGreek$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Gujarati.js": requireGujarati$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Gunjala_Gondi.js": requireGunjala_Gondi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Gurmukhi.js": requireGurmukhi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Gurung_Khema.js": requireGurung_Khema$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Han.js": requireHan$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Hangul.js": requireHangul$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Hanifi_Rohingya.js": requireHanifi_Rohingya$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Hanunoo.js": requireHanunoo$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Hatran.js": requireHatran$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Hebrew.js": requireHebrew$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Hiragana.js": requireHiragana$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Imperial_Aramaic.js": requireImperial_Aramaic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Inherited.js": requireInherited$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Inscriptional_Pahlavi.js": requireInscriptional_Pahlavi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Inscriptional_Parthian.js": requireInscriptional_Parthian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Javanese.js": requireJavanese$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Kaithi.js": requireKaithi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Kannada.js": requireKannada$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Katakana.js": requireKatakana$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Kawi.js": requireKawi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Kayah_Li.js": requireKayah_Li$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Kharoshthi.js": requireKharoshthi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Khitan_Small_Script.js": requireKhitan_Small_Script$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Khmer.js": requireKhmer$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Khojki.js": requireKhojki$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Khudawadi.js": requireKhudawadi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Kirat_Rai.js": requireKirat_Rai$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Lao.js": requireLao$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Latin.js": requireLatin$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Lepcha.js": requireLepcha$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Limbu.js": requireLimbu$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Linear_A.js": requireLinear_A$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Linear_B.js": requireLinear_B$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Lisu.js": requireLisu$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Lycian.js": requireLycian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Lydian.js": requireLydian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Mahajani.js": requireMahajani$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Makasar.js": requireMakasar$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Malayalam.js": requireMalayalam$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Mandaic.js": requireMandaic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Manichaean.js": requireManichaean$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Marchen.js": requireMarchen$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Masaram_Gondi.js": requireMasaram_Gondi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Medefaidrin.js": requireMedefaidrin$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Meetei_Mayek.js": requireMeetei_Mayek$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Mende_Kikakui.js": requireMende_Kikakui$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Meroitic_Cursive.js": requireMeroitic_Cursive$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Meroitic_Hieroglyphs.js": requireMeroitic_Hieroglyphs$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Miao.js": requireMiao$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Modi.js": requireModi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Mongolian.js": requireMongolian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Mro.js": requireMro$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Multani.js": requireMultani$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Myanmar.js": requireMyanmar$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Nabataean.js": requireNabataean$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Nag_Mundari.js": requireNag_Mundari$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Nandinagari.js": requireNandinagari$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/New_Tai_Lue.js": requireNew_Tai_Lue$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Newa.js": requireNewa$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Nko.js": requireNko$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Nushu.js": requireNushu$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Nyiakeng_Puachue_Hmong.js": requireNyiakeng_Puachue_Hmong$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Ogham.js": requireOgham$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Ol_Chiki.js": requireOl_Chiki$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Ol_Onal.js": requireOl_Onal$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Hungarian.js": requireOld_Hungarian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Italic.js": requireOld_Italic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Old_North_Arabian.js": requireOld_North_Arabian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Permic.js": requireOld_Permic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Persian.js": requireOld_Persian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Sogdian.js": requireOld_Sogdian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Old_South_Arabian.js": requireOld_South_Arabian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Turkic.js": requireOld_Turkic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Old_Uyghur.js": requireOld_Uyghur$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Oriya.js": requireOriya$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Osage.js": requireOsage$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Osmanya.js": requireOsmanya$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Pahawh_Hmong.js": requirePahawh_Hmong$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Palmyrene.js": requirePalmyrene$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Pau_Cin_Hau.js": requirePau_Cin_Hau$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Phags_Pa.js": requirePhags_Pa$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Phoenician.js": requirePhoenician$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Psalter_Pahlavi.js": requirePsalter_Pahlavi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Rejang.js": requireRejang$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Runic.js": requireRunic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Samaritan.js": requireSamaritan$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Saurashtra.js": requireSaurashtra$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Sharada.js": requireSharada$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Shavian.js": requireShavian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Siddham.js": requireSiddham$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/SignWriting.js": requireSignWriting$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Sinhala.js": requireSinhala$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Sogdian.js": requireSogdian$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Sora_Sompeng.js": requireSora_Sompeng$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Soyombo.js": requireSoyombo$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Sundanese.js": requireSundanese$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Sunuwar.js": requireSunuwar$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Syloti_Nagri.js": requireSyloti_Nagri$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Syriac.js": requireSyriac$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tagalog.js": requireTagalog$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tagbanwa.js": requireTagbanwa$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Le.js": requireTai_Le$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Tham.js": requireTai_Tham$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tai_Viet.js": requireTai_Viet$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Takri.js": requireTakri$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tamil.js": requireTamil$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tangsa.js": requireTangsa$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tangut.js": requireTangut$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Telugu.js": requireTelugu$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Thaana.js": requireThaana$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Thai.js": requireThai$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tibetan.js": requireTibetan$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tifinagh.js": requireTifinagh$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tirhuta.js": requireTirhuta$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Todhri.js": requireTodhri$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Toto.js": requireToto$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Tulu_Tigalari.js": requireTulu_Tigalari$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Ugaritic.js": requireUgaritic$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Vai.js": requireVai$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Vithkuqi.js": requireVithkuqi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Wancho.js": requireWancho$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Warang_Citi.js": requireWarang_Citi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Yezidi.js": requireYezidi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Yi.js": requireYi$1,
  		"/node_modules/regenerate-unicode-properties/Script_Extensions/Zanabazar_Square.js": requireZanabazar_Square$1,
  		"/node_modules/regenerate-unicode-properties/Script/Adlam.js": requireAdlam,
  		"/node_modules/regenerate-unicode-properties/Script/Ahom.js": requireAhom,
  		"/node_modules/regenerate-unicode-properties/Script/Anatolian_Hieroglyphs.js": requireAnatolian_Hieroglyphs,
  		"/node_modules/regenerate-unicode-properties/Script/Arabic.js": requireArabic,
  		"/node_modules/regenerate-unicode-properties/Script/Armenian.js": requireArmenian,
  		"/node_modules/regenerate-unicode-properties/Script/Avestan.js": requireAvestan,
  		"/node_modules/regenerate-unicode-properties/Script/Balinese.js": requireBalinese,
  		"/node_modules/regenerate-unicode-properties/Script/Bamum.js": requireBamum,
  		"/node_modules/regenerate-unicode-properties/Script/Bassa_Vah.js": requireBassa_Vah,
  		"/node_modules/regenerate-unicode-properties/Script/Batak.js": requireBatak,
  		"/node_modules/regenerate-unicode-properties/Script/Bengali.js": requireBengali,
  		"/node_modules/regenerate-unicode-properties/Script/Bhaiksuki.js": requireBhaiksuki,
  		"/node_modules/regenerate-unicode-properties/Script/Bopomofo.js": requireBopomofo,
  		"/node_modules/regenerate-unicode-properties/Script/Brahmi.js": requireBrahmi,
  		"/node_modules/regenerate-unicode-properties/Script/Braille.js": requireBraille,
  		"/node_modules/regenerate-unicode-properties/Script/Buginese.js": requireBuginese,
  		"/node_modules/regenerate-unicode-properties/Script/Buhid.js": requireBuhid,
  		"/node_modules/regenerate-unicode-properties/Script/Canadian_Aboriginal.js": requireCanadian_Aboriginal,
  		"/node_modules/regenerate-unicode-properties/Script/Carian.js": requireCarian,
  		"/node_modules/regenerate-unicode-properties/Script/Caucasian_Albanian.js": requireCaucasian_Albanian,
  		"/node_modules/regenerate-unicode-properties/Script/Chakma.js": requireChakma,
  		"/node_modules/regenerate-unicode-properties/Script/Cham.js": requireCham,
  		"/node_modules/regenerate-unicode-properties/Script/Cherokee.js": requireCherokee,
  		"/node_modules/regenerate-unicode-properties/Script/Chorasmian.js": requireChorasmian,
  		"/node_modules/regenerate-unicode-properties/Script/Common.js": requireCommon,
  		"/node_modules/regenerate-unicode-properties/Script/Coptic.js": requireCoptic,
  		"/node_modules/regenerate-unicode-properties/Script/Cuneiform.js": requireCuneiform,
  		"/node_modules/regenerate-unicode-properties/Script/Cypriot.js": requireCypriot,
  		"/node_modules/regenerate-unicode-properties/Script/Cypro_Minoan.js": requireCypro_Minoan,
  		"/node_modules/regenerate-unicode-properties/Script/Cyrillic.js": requireCyrillic,
  		"/node_modules/regenerate-unicode-properties/Script/Deseret.js": requireDeseret,
  		"/node_modules/regenerate-unicode-properties/Script/Devanagari.js": requireDevanagari,
  		"/node_modules/regenerate-unicode-properties/Script/Dives_Akuru.js": requireDives_Akuru,
  		"/node_modules/regenerate-unicode-properties/Script/Dogra.js": requireDogra,
  		"/node_modules/regenerate-unicode-properties/Script/Duployan.js": requireDuployan,
  		"/node_modules/regenerate-unicode-properties/Script/Egyptian_Hieroglyphs.js": requireEgyptian_Hieroglyphs,
  		"/node_modules/regenerate-unicode-properties/Script/Elbasan.js": requireElbasan,
  		"/node_modules/regenerate-unicode-properties/Script/Elymaic.js": requireElymaic,
  		"/node_modules/regenerate-unicode-properties/Script/Ethiopic.js": requireEthiopic,
  		"/node_modules/regenerate-unicode-properties/Script/Garay.js": requireGaray,
  		"/node_modules/regenerate-unicode-properties/Script/Georgian.js": requireGeorgian,
  		"/node_modules/regenerate-unicode-properties/Script/Glagolitic.js": requireGlagolitic,
  		"/node_modules/regenerate-unicode-properties/Script/Gothic.js": requireGothic,
  		"/node_modules/regenerate-unicode-properties/Script/Grantha.js": requireGrantha,
  		"/node_modules/regenerate-unicode-properties/Script/Greek.js": requireGreek,
  		"/node_modules/regenerate-unicode-properties/Script/Gujarati.js": requireGujarati,
  		"/node_modules/regenerate-unicode-properties/Script/Gunjala_Gondi.js": requireGunjala_Gondi,
  		"/node_modules/regenerate-unicode-properties/Script/Gurmukhi.js": requireGurmukhi,
  		"/node_modules/regenerate-unicode-properties/Script/Gurung_Khema.js": requireGurung_Khema,
  		"/node_modules/regenerate-unicode-properties/Script/Han.js": requireHan,
  		"/node_modules/regenerate-unicode-properties/Script/Hangul.js": requireHangul,
  		"/node_modules/regenerate-unicode-properties/Script/Hanifi_Rohingya.js": requireHanifi_Rohingya,
  		"/node_modules/regenerate-unicode-properties/Script/Hanunoo.js": requireHanunoo,
  		"/node_modules/regenerate-unicode-properties/Script/Hatran.js": requireHatran,
  		"/node_modules/regenerate-unicode-properties/Script/Hebrew.js": requireHebrew,
  		"/node_modules/regenerate-unicode-properties/Script/Hiragana.js": requireHiragana,
  		"/node_modules/regenerate-unicode-properties/Script/Imperial_Aramaic.js": requireImperial_Aramaic,
  		"/node_modules/regenerate-unicode-properties/Script/Inherited.js": requireInherited,
  		"/node_modules/regenerate-unicode-properties/Script/Inscriptional_Pahlavi.js": requireInscriptional_Pahlavi,
  		"/node_modules/regenerate-unicode-properties/Script/Inscriptional_Parthian.js": requireInscriptional_Parthian,
  		"/node_modules/regenerate-unicode-properties/Script/Javanese.js": requireJavanese,
  		"/node_modules/regenerate-unicode-properties/Script/Kaithi.js": requireKaithi,
  		"/node_modules/regenerate-unicode-properties/Script/Kannada.js": requireKannada,
  		"/node_modules/regenerate-unicode-properties/Script/Katakana.js": requireKatakana,
  		"/node_modules/regenerate-unicode-properties/Script/Kawi.js": requireKawi,
  		"/node_modules/regenerate-unicode-properties/Script/Kayah_Li.js": requireKayah_Li,
  		"/node_modules/regenerate-unicode-properties/Script/Kharoshthi.js": requireKharoshthi,
  		"/node_modules/regenerate-unicode-properties/Script/Khitan_Small_Script.js": requireKhitan_Small_Script,
  		"/node_modules/regenerate-unicode-properties/Script/Khmer.js": requireKhmer,
  		"/node_modules/regenerate-unicode-properties/Script/Khojki.js": requireKhojki,
  		"/node_modules/regenerate-unicode-properties/Script/Khudawadi.js": requireKhudawadi,
  		"/node_modules/regenerate-unicode-properties/Script/Kirat_Rai.js": requireKirat_Rai,
  		"/node_modules/regenerate-unicode-properties/Script/Lao.js": requireLao,
  		"/node_modules/regenerate-unicode-properties/Script/Latin.js": requireLatin,
  		"/node_modules/regenerate-unicode-properties/Script/Lepcha.js": requireLepcha,
  		"/node_modules/regenerate-unicode-properties/Script/Limbu.js": requireLimbu,
  		"/node_modules/regenerate-unicode-properties/Script/Linear_A.js": requireLinear_A,
  		"/node_modules/regenerate-unicode-properties/Script/Linear_B.js": requireLinear_B,
  		"/node_modules/regenerate-unicode-properties/Script/Lisu.js": requireLisu,
  		"/node_modules/regenerate-unicode-properties/Script/Lycian.js": requireLycian,
  		"/node_modules/regenerate-unicode-properties/Script/Lydian.js": requireLydian,
  		"/node_modules/regenerate-unicode-properties/Script/Mahajani.js": requireMahajani,
  		"/node_modules/regenerate-unicode-properties/Script/Makasar.js": requireMakasar,
  		"/node_modules/regenerate-unicode-properties/Script/Malayalam.js": requireMalayalam,
  		"/node_modules/regenerate-unicode-properties/Script/Mandaic.js": requireMandaic,
  		"/node_modules/regenerate-unicode-properties/Script/Manichaean.js": requireManichaean,
  		"/node_modules/regenerate-unicode-properties/Script/Marchen.js": requireMarchen,
  		"/node_modules/regenerate-unicode-properties/Script/Masaram_Gondi.js": requireMasaram_Gondi,
  		"/node_modules/regenerate-unicode-properties/Script/Medefaidrin.js": requireMedefaidrin,
  		"/node_modules/regenerate-unicode-properties/Script/Meetei_Mayek.js": requireMeetei_Mayek,
  		"/node_modules/regenerate-unicode-properties/Script/Mende_Kikakui.js": requireMende_Kikakui,
  		"/node_modules/regenerate-unicode-properties/Script/Meroitic_Cursive.js": requireMeroitic_Cursive,
  		"/node_modules/regenerate-unicode-properties/Script/Meroitic_Hieroglyphs.js": requireMeroitic_Hieroglyphs,
  		"/node_modules/regenerate-unicode-properties/Script/Miao.js": requireMiao,
  		"/node_modules/regenerate-unicode-properties/Script/Modi.js": requireModi,
  		"/node_modules/regenerate-unicode-properties/Script/Mongolian.js": requireMongolian,
  		"/node_modules/regenerate-unicode-properties/Script/Mro.js": requireMro,
  		"/node_modules/regenerate-unicode-properties/Script/Multani.js": requireMultani,
  		"/node_modules/regenerate-unicode-properties/Script/Myanmar.js": requireMyanmar,
  		"/node_modules/regenerate-unicode-properties/Script/Nabataean.js": requireNabataean,
  		"/node_modules/regenerate-unicode-properties/Script/Nag_Mundari.js": requireNag_Mundari,
  		"/node_modules/regenerate-unicode-properties/Script/Nandinagari.js": requireNandinagari,
  		"/node_modules/regenerate-unicode-properties/Script/New_Tai_Lue.js": requireNew_Tai_Lue,
  		"/node_modules/regenerate-unicode-properties/Script/Newa.js": requireNewa,
  		"/node_modules/regenerate-unicode-properties/Script/Nko.js": requireNko,
  		"/node_modules/regenerate-unicode-properties/Script/Nushu.js": requireNushu,
  		"/node_modules/regenerate-unicode-properties/Script/Nyiakeng_Puachue_Hmong.js": requireNyiakeng_Puachue_Hmong,
  		"/node_modules/regenerate-unicode-properties/Script/Ogham.js": requireOgham,
  		"/node_modules/regenerate-unicode-properties/Script/Ol_Chiki.js": requireOl_Chiki,
  		"/node_modules/regenerate-unicode-properties/Script/Ol_Onal.js": requireOl_Onal,
  		"/node_modules/regenerate-unicode-properties/Script/Old_Hungarian.js": requireOld_Hungarian,
  		"/node_modules/regenerate-unicode-properties/Script/Old_Italic.js": requireOld_Italic,
  		"/node_modules/regenerate-unicode-properties/Script/Old_North_Arabian.js": requireOld_North_Arabian,
  		"/node_modules/regenerate-unicode-properties/Script/Old_Permic.js": requireOld_Permic,
  		"/node_modules/regenerate-unicode-properties/Script/Old_Persian.js": requireOld_Persian,
  		"/node_modules/regenerate-unicode-properties/Script/Old_Sogdian.js": requireOld_Sogdian,
  		"/node_modules/regenerate-unicode-properties/Script/Old_South_Arabian.js": requireOld_South_Arabian,
  		"/node_modules/regenerate-unicode-properties/Script/Old_Turkic.js": requireOld_Turkic,
  		"/node_modules/regenerate-unicode-properties/Script/Old_Uyghur.js": requireOld_Uyghur,
  		"/node_modules/regenerate-unicode-properties/Script/Oriya.js": requireOriya,
  		"/node_modules/regenerate-unicode-properties/Script/Osage.js": requireOsage,
  		"/node_modules/regenerate-unicode-properties/Script/Osmanya.js": requireOsmanya,
  		"/node_modules/regenerate-unicode-properties/Script/Pahawh_Hmong.js": requirePahawh_Hmong,
  		"/node_modules/regenerate-unicode-properties/Script/Palmyrene.js": requirePalmyrene,
  		"/node_modules/regenerate-unicode-properties/Script/Pau_Cin_Hau.js": requirePau_Cin_Hau,
  		"/node_modules/regenerate-unicode-properties/Script/Phags_Pa.js": requirePhags_Pa,
  		"/node_modules/regenerate-unicode-properties/Script/Phoenician.js": requirePhoenician,
  		"/node_modules/regenerate-unicode-properties/Script/Psalter_Pahlavi.js": requirePsalter_Pahlavi,
  		"/node_modules/regenerate-unicode-properties/Script/Rejang.js": requireRejang,
  		"/node_modules/regenerate-unicode-properties/Script/Runic.js": requireRunic,
  		"/node_modules/regenerate-unicode-properties/Script/Samaritan.js": requireSamaritan,
  		"/node_modules/regenerate-unicode-properties/Script/Saurashtra.js": requireSaurashtra,
  		"/node_modules/regenerate-unicode-properties/Script/Sharada.js": requireSharada,
  		"/node_modules/regenerate-unicode-properties/Script/Shavian.js": requireShavian,
  		"/node_modules/regenerate-unicode-properties/Script/Siddham.js": requireSiddham,
  		"/node_modules/regenerate-unicode-properties/Script/SignWriting.js": requireSignWriting,
  		"/node_modules/regenerate-unicode-properties/Script/Sinhala.js": requireSinhala,
  		"/node_modules/regenerate-unicode-properties/Script/Sogdian.js": requireSogdian,
  		"/node_modules/regenerate-unicode-properties/Script/Sora_Sompeng.js": requireSora_Sompeng,
  		"/node_modules/regenerate-unicode-properties/Script/Soyombo.js": requireSoyombo,
  		"/node_modules/regenerate-unicode-properties/Script/Sundanese.js": requireSundanese,
  		"/node_modules/regenerate-unicode-properties/Script/Sunuwar.js": requireSunuwar,
  		"/node_modules/regenerate-unicode-properties/Script/Syloti_Nagri.js": requireSyloti_Nagri,
  		"/node_modules/regenerate-unicode-properties/Script/Syriac.js": requireSyriac,
  		"/node_modules/regenerate-unicode-properties/Script/Tagalog.js": requireTagalog,
  		"/node_modules/regenerate-unicode-properties/Script/Tagbanwa.js": requireTagbanwa,
  		"/node_modules/regenerate-unicode-properties/Script/Tai_Le.js": requireTai_Le,
  		"/node_modules/regenerate-unicode-properties/Script/Tai_Tham.js": requireTai_Tham,
  		"/node_modules/regenerate-unicode-properties/Script/Tai_Viet.js": requireTai_Viet,
  		"/node_modules/regenerate-unicode-properties/Script/Takri.js": requireTakri,
  		"/node_modules/regenerate-unicode-properties/Script/Tamil.js": requireTamil,
  		"/node_modules/regenerate-unicode-properties/Script/Tangsa.js": requireTangsa,
  		"/node_modules/regenerate-unicode-properties/Script/Tangut.js": requireTangut,
  		"/node_modules/regenerate-unicode-properties/Script/Telugu.js": requireTelugu,
  		"/node_modules/regenerate-unicode-properties/Script/Thaana.js": requireThaana,
  		"/node_modules/regenerate-unicode-properties/Script/Thai.js": requireThai,
  		"/node_modules/regenerate-unicode-properties/Script/Tibetan.js": requireTibetan,
  		"/node_modules/regenerate-unicode-properties/Script/Tifinagh.js": requireTifinagh,
  		"/node_modules/regenerate-unicode-properties/Script/Tirhuta.js": requireTirhuta,
  		"/node_modules/regenerate-unicode-properties/Script/Todhri.js": requireTodhri,
  		"/node_modules/regenerate-unicode-properties/Script/Toto.js": requireToto,
  		"/node_modules/regenerate-unicode-properties/Script/Tulu_Tigalari.js": requireTulu_Tigalari,
  		"/node_modules/regenerate-unicode-properties/Script/Ugaritic.js": requireUgaritic,
  		"/node_modules/regenerate-unicode-properties/Script/Vai.js": requireVai,
  		"/node_modules/regenerate-unicode-properties/Script/Vithkuqi.js": requireVithkuqi,
  		"/node_modules/regenerate-unicode-properties/Script/Wancho.js": requireWancho,
  		"/node_modules/regenerate-unicode-properties/Script/Warang_Citi.js": requireWarang_Citi,
  		"/node_modules/regenerate-unicode-properties/Script/Yezidi.js": requireYezidi,
  		"/node_modules/regenerate-unicode-properties/Script/Yi.js": requireYi,
  		"/node_modules/regenerate-unicode-properties/Script/Zanabazar_Square.js": requireZanabazar_Square,
  		"/node_modules/regenerate-unicode-properties/unicode-version.js": requireUnicodeVersion
  	});
  }

if (relPath.endsWith('/..')) {
  			break; // Travelled too far up, avoid infinite loop
  		}

for (var extensionIndex = 0; extensionIndex < checkedExtensions.length; extensionIndex++) {
  			var resolvedPath = relPath + checkedExtensions[extensionIndex];
  			if (modules[resolvedPath]) {
  				return resolvedPath;
  			}
  		}
  		if (!shouldTryNodeModules) break;
  		var nextDir = normalize(originalModuleDir + '/..');
  		if (nextDir === originalModuleDir) break;
  		originalModuleDir = nextDir;
  	}
  	return null;
  }

function isPossibleNodeModulesPath (modulePath) {
  	var c0 = modulePath[0];
  	if (c0 === '/' || c0 === '\\') return false;
  	var c1 = modulePath[1], c2 = modulePath[2];
  	if ((c0 === '.' && (!c1 || c1 === '/' || c1 === '\\')) ||
  		(c0 === '.' && c1 === '.' && (!c2 || c2 === '/' || c2 === '\\'))) return false;
  	if (c1 === ':' && (c2 === '/' || c2 === '\\')) return false;
  	return true;
  }

var regjsgen = {exports: {}};

regjsgen.exports;
  (function (module, exports) {
    (function () {
      var objectTypes = {
        'function': true,
        'object': true
      };
      var root = objectTypes[typeof window] && window || this;
      var freeExports = exports && !exports.nodeType && exports;
      var hasFreeModule = module && !module.nodeType;
      var freeGlobal = freeExports && hasFreeModule && typeof commonjsGlobal == 'object' && commonjsGlobal;
      if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) {
        root = freeGlobal;
      }
      var hasOwnProperty = Object.prototype.hasOwnProperty;
      function fromCodePoint() {
        var codePoint = Number(arguments[0]);
        if (!isFinite(codePoint) || codePoint < 0 || codePoint > 0x10FFFF || Math.floor(codePoint) != codePoint) {
          throw RangeError('Invalid code point: ' + codePoint);
        }
        if (codePoint <= 0xFFFF) {
          return String.fromCharCode(codePoint);
        } else {
          codePoint -= 0x10000;
          var highSurrogate = (codePoint >> 10) + 0xD800;
          var lowSurrogate = codePoint % 0x400 + 0xDC00;
          return String.fromCharCode(highSurrogate, lowSurrogate);
        }
      }
      var assertTypeRegexMap = {};
      function assertType(type, expected) {
        if (expected.indexOf('|') == -1) {
          if (type == expected) {
            return;
          }
          throw Error('Invalid node type: ' + type + '; expected type: ' + expected);
        }
        expected = hasOwnProperty.call(assertTypeRegexMap, expected) ? assertTypeRegexMap[expected] : assertTypeRegexMap[expected] = RegExp('^(?:' + expected + ')$');
        if (expected.test(type)) {
          return;
        }
        throw Error('Invalid node type: ' + type + '; expected types: ' + expected);
      }
      function generate(node) {
        var type = node.type;
        if (hasOwnProperty.call(generators, type)) {
          return generators[type](node);
        }
        throw Error('Invalid node type: ' + type);
      }
      function generateSequence(generator, terms, separator) {
        var i = -1,
          length = terms.length,
          result = '',
          term;
        while (++i < length) {
          term = terms[i];
          if (separator && i > 0) result += separator;
          if (i + 1 < length && terms[i].type == 'value' && terms[i].kind == 'null' && terms[i + 1].type == 'value' && terms[i + 1].kind == 'symbol' && terms[i + 1].codePoint >= 48 && terms[i + 1].codePoint <= 57) {
            result += '\\000';
            continue;
          }
          result += generator(term);
        }
        return result;
      }
      function generateAlternative(node) {
        assertType(node.type, 'alternative');
        return generateSequence(generateTerm, node.body);
      }
      function generateAnchor(node) {
        assertType(node.type, 'anchor');
        switch (node.kind) {
          case 'start':
            return '^';
          case 'end':
            return '$';
          case 'boundary':
            return '\\b';
          case 'not-boundary':
            return '\\B';
          default:
            throw Error('Invalid assertion');
        }
      }
      var atomType = 'anchor|characterClass|characterClassEscape|dot|group|reference|unicodePropertyEscape|value';
      function generateAtom(node) {
        assertType(node.type, atomType);
        return generate(node);
      }
      function generateCharacterClass(node) {
        assertType(node.type, 'characterClass');
        var kind = node.kind;
        var separator = kind === 'intersection' ? '&&' : kind === 'subtraction' ? '--' : '';
        return '[' + (node.negative ? '^' : '') + generateSequence(generateClassAtom, node.body, separator) + ']';
      }
      function generateCharacterClassEscape(node) {
        assertType(node.type, 'characterClassEscape');
        return '\\' + node.value;
      }
      function generateCharacterClassRange(node) {
        assertType(node.type, 'characterClassRange');
        var min = node.min,
          max = node.max;
        if (min.type == 'characterClassRange' || max.type == 'characterClassRange') {
          throw Error('Invalid character class range');
        }
        return generateClassAtom(min) + '-' + generateClassAtom(max);
      }
      function generateClassAtom(node) {
        assertType(node.type, 'anchor|characterClass|characterClassEscape|characterClassRange|dot|value|unicodePropertyEscape|classStrings');
        return generate(node);
      }
      function generateClassStrings(node) {
        assertType(node.type, 'classStrings');
        return '\\q{' + generateSequence(generateClassString, node.strings, '|') + '}';
      }
      function generateClassString(node) {
        assertType(node.type, 'classString');
        return generateSequence(generate, node.characters);
      }
      function generateDisjunction(node) {
        assertType(node.type, 'disjunction');
        return generateSequence(generate, node.body, '|');
      }
      function generateDot(node) {
        assertType(node.type, 'dot');
        return '.';
      }
      function generateGroup(node) {
        assertType(node.type, 'group');
        var result = '';
        switch (node.behavior) {
          case 'normal':
            if (node.name) {
              result += '?<' + generateIdentifier(node.name) + '>';
            }
            break;
          case 'ignore':
            if (node.modifierFlags) {
              result += '?';
              if (node.modifierFlags.enabling) result += node.modifierFlags.enabling;
              if (node.modifierFlags.disabling) result += "-" + node.modifierFlags.disabling;
              result += ':';
            } else {
              result += '?:';
            }
            break;
          case 'lookahead':
            result += '?=';
            break;
          case 'negativeLookahead':
            result += '?!';
            break;
          case 'lookbehind':
            result += '?<=';
            break;
          case 'negativeLookbehind':
            result += '?<!';
            break;
          default:
            throw Error('Invalid behaviour: ' + node.behaviour);
        }
        result += generateSequence(generate, node.body);
        return '(' + result + ')';
      }
      function generateIdentifier(node) {
        assertType(node.type, 'identifier');
        return node.value;
      }
      function generateQuantifier(node) {
        assertType(node.type, 'quantifier');
        var quantifier = '',
          min = node.min,
          max = node.max;
        if (max == null) {
          if (min == 0) {
            quantifier = '*';
          } else if (min == 1) {
            quantifier = '+';
          } else {
            quantifier = '{' + min + ',}';
          }
        } else if (min == max) {
          quantifier = '{' + min + '}';
        } else if (min == 0 && max == 1) {
          quantifier = '?';
        } else {
          quantifier = '{' + min + ',' + max + '}';
        }
        if (!node.greedy) {
          quantifier += '?';
        }
        return generateAtom(node.body[0]) + quantifier;
      }
      function generateReference(node) {
        assertType(node.type, 'reference');
        if (node.matchIndex) {
          return '\\' + node.matchIndex;
        }
        if (node.name) {
          return '\\k<' + generateIdentifier(node.name) + '>';
        }
        throw new Error('Unknown reference type');
      }
      function generateTerm(node) {
        assertType(node.type, atomType + '|empty|quantifier');
        return generate(node);
      }
      function generateUnicodePropertyEscape(node) {
        assertType(node.type, 'unicodePropertyEscape');
        return '\\' + (node.negative ? 'P' : 'p') + '{' + node.value + '}';
      }
      function generateValue(node) {
        assertType(node.type, 'value');
        var kind = node.kind,
          codePoint = node.codePoint;
        if (typeof codePoint != 'number') {
          throw new Error('Invalid code point: ' + codePoint);
        }
        switch (kind) {
          case 'controlLetter':
            return '\\c' + fromCodePoint(codePoint + 64);
          case 'hexadecimalEscape':
            return '\\x' + ('00' + codePoint.toString(16).toUpperCase()).slice(-2);
          case 'identifier':
            return '\\' + fromCodePoint(codePoint);
          case 'null':
            return '\\' + codePoint;
          case 'octal':
            return '\\' + ('000' + codePoint.toString(8)).slice(-3);
          case 'singleEscape':
            switch (codePoint) {
              case 0x0008:
                return '\\b';
              case 0x0009:
                return '\\t';
              case 0x000A:
                return '\\n';
              case 0x000B:
                return '\\v';
              case 0x000C:
                return '\\f';
              case 0x000D:
                return '\\r';
              case 0x002D:
                return '\\-';
              default:
                throw Error('Invalid code point: ' + codePoint);
            }
          case 'symbol':
            return fromCodePoint(codePoint);
          case 'unicodeEscape':
            return "\\u" + ('0000' + codePoint.toString(16).toUpperCase()).slice(-4);
          case 'unicodeCodePointEscape':
            return "\\u{" + codePoint.toString(16).toUpperCase() + '}';
          default:
            throw Error('Unsupported node kind: ' + kind);
        }
      }
      var generators = {
        'alternative': generateAlternative,
        'anchor': generateAnchor,
        'characterClass': generateCharacterClass,
        'characterClassEscape': generateCharacterClassEscape,
        'characterClassRange': generateCharacterClassRange,
        'classStrings': generateClassStrings,
        'disjunction': generateDisjunction,
        'dot': generateDot,
        'group': generateGroup,
        'quantifier': generateQuantifier,
        'reference': generateReference,
        'unicodePropertyEscape': generateUnicodePropertyEscape,
        'value': generateValue
      };
      var regjsgen = {
        'generate': generate
      };
      if (freeExports && hasFreeModule) {
        freeExports.generate = generate;
      } else {
        root.regjsgen = regjsgen;
      }
    }).call(commonjsGlobal);
  })(regjsgen, regjsgen.exports);
  var regjsgenExports = regjsgen.exports;

var parser = {exports: {}};

(function (module) {

var unicodeCanonicalPropertyNamesEcmascript = new Set(['General_Category', 'Script', 'Script_Extensions', 'Alphabetic', 'Any', 'ASCII', 'ASCII_Hex_Digit', 'Assigned', 'Bidi_Control', 'Bidi_Mirrored', 'Case_Ignorable', 'Cased', 'Changes_When_Casefolded', 'Changes_When_Casemapped', 'Changes_When_Lowercased', 'Changes_When_NFKC_Casefolded', 'Changes_When_Titlecased', 'Changes_When_Uppercased', 'Dash', 'Default_Ignorable_Code_Point', 'Deprecated', 'Diacritic', 'Emoji', 'Emoji_Component', 'Emoji_Modifier', 'Emoji_Modifier_Base', 'Emoji_Presentation', 'Extended_Pictographic', 'Extender', 'Grapheme_Base', 'Grapheme_Extend', 'Hex_Digit', 'ID_Continue', 'ID_Start', 'Ideographic', 'IDS_Binary_Operator', 'IDS_Trinary_Operator', 'Join_Control', 'Logical_Order_Exception', 'Lowercase', 'Math', 'Noncharacter_Code_Point', 'Pattern_Syntax', 'Pattern_White_Space', 'Quotation_Mark', 'Radical', 'Regional_Indicator', 'Sentence_Terminal', 'Soft_Dotted', 'Terminal_Punctuation', 'Unified_Ideograph', 'Uppercase', 'Variation_Selector', 'White_Space', 'XID_Continue', 'XID_Start']);

var unicodePropertyAliasesEcmascript = new Map([['scx', 'Script_Extensions'], ['sc', 'Script'], ['gc', 'General_Category'], ['AHex', 'ASCII_Hex_Digit'], ['Alpha', 'Alphabetic'], ['Bidi_C', 'Bidi_Control'], ['Bidi_M', 'Bidi_Mirrored'], ['Cased', 'Cased'], ['CI', 'Case_Ignorable'], ['CWCF', 'Changes_When_Casefolded'], ['CWCM', 'Changes_When_Casemapped'], ['CWKCF', 'Changes_When_NFKC_Casefolded'], ['CWL', 'Changes_When_Lowercased'], ['CWT', 'Changes_When_Titlecased'], ['CWU', 'Changes_When_Uppercased'], ['Dash', 'Dash'], ['Dep', 'Deprecated'], ['DI', 'Default_Ignorable_Code_Point'], ['Dia', 'Diacritic'], ['EBase', 'Emoji_Modifier_Base'], ['EComp', 'Emoji_Component'], ['EMod', 'Emoji_Modifier'], ['Emoji', 'Emoji'], ['EPres', 'Emoji_Presentation'], ['Ext', 'Extender'], ['ExtPict', 'Extended_Pictographic'], ['Gr_Base', 'Grapheme_Base'], ['Gr_Ext', 'Grapheme_Extend'], ['Hex', 'Hex_Digit'], ['IDC', 'ID_Continue'], ['Ideo', 'Ideographic'], ['IDS', 'ID_Start'], ['IDSB', 'IDS_Binary_Operator'], ['IDST', 'IDS_Trinary_Operator'], ['Join_C', 'Join_Control'], ['LOE', 'Logical_Order_Exception'], ['Lower', 'Lowercase'], ['Math', 'Math'], ['NChar', 'Noncharacter_Code_Point'], ['Pat_Syn', 'Pattern_Syntax'], ['Pat_WS', 'Pattern_White_Space'], ['QMark', 'Quotation_Mark'], ['Radical', 'Radical'], ['RI', 'Regional_Indicator'], ['SD', 'Soft_Dotted'], ['STerm', 'Sentence_Terminal'], ['Term', 'Terminal_Punctuation'], ['UIdeo', 'Unified_Ideograph'], ['Upper', 'Uppercase'], ['VS', 'Variation_Selector'], ['WSpace', 'White_Space'], ['space', 'White_Space'], ['XIDC', 'XID_Continue'], ['XIDS', 'XID_Start']]);

var mappings = new Map([['General_Category', new Map([['C', 'Other'], ['Cc', 'Control'], ['cntrl', 'Control'], ['Cf', 'Format'], ['Cn', 'Unassigned'], ['Co', 'Private_Use'], ['Cs', 'Surrogate'], ['L', 'Letter'], ['LC', 'Cased_Letter'], ['Ll', 'Lowercase_Letter'], ['Lm', 'Modifier_Letter'], ['Lo', 'Other_Letter'], ['Lt', 'Titlecase_Letter'], ['Lu', 'Uppercase_Letter'], ['M', 'Mark'], ['Combining_Mark', 'Mark'], ['Mc', 'Spacing_Mark'], ['Me', 'Enclosing_Mark'], ['Mn', 'Nonspacing_Mark'], ['N', 'Number'], ['Nd', 'Decimal_Number'], ['digit', 'Decimal_Number'], ['Nl', 'Letter_Number'], ['No', 'Other_Number'], ['P', 'Punctuation'], ['punct', 'Punctuation'], ['Pc', 'Connector_Punctuation'], ['Pd', 'Dash_Punctuation'], ['Pe', 'Close_Punctuation'], ['Pf', 'Final_Punctuation'], ['Pi', 'Initial_Punctuation'], ['Po', 'Other_Punctuation'], ['Ps', 'Open_Punctuation'], ['S', 'Symbol'], ['Sc', 'Currency_Symbol'], ['Sk', 'Modifier_Symbol'], ['Sm', 'Math_Symbol'], ['So', 'Other_Symbol'], ['Z', 'Separator'], ['Zl', 'Line_Separator'], ['Zp', 'Paragraph_Separator'], ['Zs', 'Space_Separator'], ['Other', 'Other'], ['Control', 'Control'], ['Format', 'Format'], ['Unassigned', 'Unassigned'], ['Private_Use', 'Private_Use'], ['Surrogate', 'Surrogate'], ['Letter', 'Letter'], ['Cased_Letter', 'Cased_Letter'], ['Lowercase_Letter', 'Lowercase_Letter'], ['Modifier_Letter', 'Modifier_Letter'], ['Other_Letter', 'Other_Letter'], ['Titlecase_Letter', 'Titlecase_Letter'], ['Uppercase_Letter', 'Uppercase_Letter'], ['Mark', 'Mark'], ['Spacing_Mark', 'Spacing_Mark'], ['Enclosing_Mark', 'Enclosing_Mark'], ['Nonspacing_Mark', 'Nonspacing_Mark'], ['Number', 'Number'], ['Decimal_Number', 'Decimal_Number'], ['Letter_Number', 'Letter_Number'], ['Other_Number', 'Other_Number'], ['Punctuation', 'Punctuation'], ['Connector_Punctuation', 'Connector_Punctuation'], ['Dash_Punctuation', 'Dash_Punctuation'], ['Close_Punctuation', 'Close_Punctuation'], ['Final_Punctuation', 'Final_Punctuation'], ['Initial_Punctuation', 'Initial_Punctuation'], ['Other_Punctuation', 'Other_Punctuation'], ['Open_Punctuation', 'Open_Punctuation'], ['Symbol', 'Symbol'], ['Currency_Symbol', 'Currency_Symbol'], ['Modifier_Symbol', 'Modifier_Symbol'], ['Math_Symbol', 'Math_Symbol'], ['Other_Symbol', 'Other_Symbol'], ['Separator', 'Separator'], ['Line_Separator', 'Line_Separator'], ['Paragraph_Separator', 'Paragraph_Separator'], ['Space_Separator', 'Space_Separator']])], ['Script', new Map([['Adlm', 'Adlam'], ['Aghb', 'Caucasian_Albanian'], ['Ahom', 'Ahom'], ['Arab', 'Arabic'], ['Armi', 'Imperial_Aramaic'], ['Armn', 'Armenian'], ['Avst', 'Avestan'], ['Bali', 'Balinese'], ['Bamu', 'Bamum'], ['Bass', 'Bassa_Vah'], ['Batk', 'Batak'], ['Beng', 'Bengali'], ['Bhks', 'Bhaiksuki'], ['Bopo', 'Bopomofo'], ['Brah', 'Brahmi'], ['Brai', 'Braille'], ['Bugi', 'Buginese'], ['Buhd', 'Buhid'], ['Cakm', 'Chakma'], ['Cans', 'Canadian_Aboriginal'], ['Cari', 'Carian'], ['Cham', 'Cham'], ['Cher', 'Cherokee'], ['Chrs', 'Chorasmian'], ['Copt', 'Coptic'], ['Qaac', 'Coptic'], ['Cpmn', 'Cypro_Minoan'], ['Cprt', 'Cypriot'], ['Cyrl', 'Cyrillic'], ['Deva', 'Devanagari'], ['Diak', 'Dives_Akuru'], ['Dogr', 'Dogra'], ['Dsrt', 'Deseret'], ['Dupl', 'Duployan'], ['Egyp', 'Egyptian_Hieroglyphs'], ['Elba', 'Elbasan'], ['Elym', 'Elymaic'], ['Ethi', 'Ethiopic'], ['Gara', 'Garay'], ['Geor', 'Georgian'], ['Glag', 'Glagolitic'], ['Gong', 'Gunjala_Gondi'], ['Gonm', 'Masaram_Gondi'], ['Goth', 'Gothic'], ['Gran', 'Grantha'], ['Grek', 'Greek'], ['Gujr', 'Gujarati'], ['Gukh', 'Gurung_Khema'], ['Guru', 'Gurmukhi'], ['Hang', 'Hangul'], ['Hani', 'Han'], ['Hano', 'Hanunoo'], ['Hatr', 'Hatran'], ['Hebr', 'Hebrew'], ['Hira', 'Hiragana'], ['Hluw', 'Anatolian_Hieroglyphs'], ['Hmng', 'Pahawh_Hmong'], ['Hmnp', 'Nyiakeng_Puachue_Hmong'], ['Hrkt', 'Katakana_Or_Hiragana'], ['Hung', 'Old_Hungarian'], ['Ital', 'Old_Italic'], ['Java', 'Javanese'], ['Kali', 'Kayah_Li'], ['Kana', 'Katakana'], ['Kawi', 'Kawi'], ['Khar', 'Kharoshthi'], ['Khmr', 'Khmer'], ['Khoj', 'Khojki'], ['Kits', 'Khitan_Small_Script'], ['Knda', 'Kannada'], ['Krai', 'Kirat_Rai'], ['Kthi', 'Kaithi'], ['Lana', 'Tai_Tham'], ['Laoo', 'Lao'], ['Latn', 'Latin'], ['Lepc', 'Lepcha'], ['Limb', 'Limbu'], ['Lina', 'Linear_A'], ['Linb', 'Linear_B'], ['Lisu', 'Lisu'], ['Lyci', 'Lycian'], ['Lydi', 'Lydian'], ['Mahj', 'Mahajani'], ['Maka', 'Makasar'], ['Mand', 'Mandaic'], ['Mani', 'Manichaean'], ['Marc', 'Marchen'], ['Medf', 'Medefaidrin'], ['Mend', 'Mende_Kikakui'], ['Merc', 'Meroitic_Cursive'], ['Mero', 'Meroitic_Hieroglyphs'], ['Mlym', 'Malayalam'], ['Modi', 'Modi'], ['Mong', 'Mongolian'], ['Mroo', 'Mro'], ['Mtei', 'Meetei_Mayek'], ['Mult', 'Multani'], ['Mymr', 'Myanmar'], ['Nagm', 'Nag_Mundari'], ['Nand', 'Nandinagari'], ['Narb', 'Old_North_Arabian'], ['Nbat', 'Nabataean'], ['Newa', 'Newa'], ['Nkoo', 'Nko'], ['Nshu', 'Nushu'], ['Ogam', 'Ogham'], ['Olck', 'Ol_Chiki'], ['Onao', 'Ol_Onal'], ['Orkh', 'Old_Turkic'], ['Orya', 'Oriya'], ['Osge', 'Osage'], ['Osma', 'Osmanya'], ['Ougr', 'Old_Uyghur'], ['Palm', 'Palmyrene'], ['Pauc', 'Pau_Cin_Hau'], ['Perm', 'Old_Permic'], ['Phag', 'Phags_Pa'], ['Phli', 'Inscriptional_Pahlavi'], ['Phlp', 'Psalter_Pahlavi'], ['Phnx', 'Phoenician'], ['Plrd', 'Miao'], ['Prti', 'Inscriptional_Parthian'], ['Rjng', 'Rejang'], ['Rohg', 'Hanifi_Rohingya'], ['Runr', 'Runic'], ['Samr', 'Samaritan'], ['Sarb', 'Old_South_Arabian'], ['Saur', 'Saurashtra'], ['Sgnw', 'SignWriting'], ['Shaw', 'Shavian'], ['Shrd', 'Sharada'], ['Sidd', 'Siddham'], ['Sind', 'Khudawadi'], ['Sinh', 'Sinhala'], ['Sogd', 'Sogdian'], ['Sogo', 'Old_Sogdian'], ['Sora', 'Sora_Sompeng'], ['Soyo', 'Soyombo'], ['Sund', 'Sundanese'], ['Sunu', 'Sunuwar'], ['Sylo', 'Syloti_Nagri'], ['Syrc', 'Syriac'], ['Tagb', 'Tagbanwa'], ['Takr', 'Takri'], ['Tale', 'Tai_Le'], ['Talu', 'New_Tai_Lue'], ['Taml', 'Tamil'], ['Tang', 'Tangut'], ['Tavt', 'Tai_Viet'], ['Telu', 'Telugu'], ['Tfng', 'Tifinagh'], ['Tglg', 'Tagalog'], ['Thaa', 'Thaana'], ['Thai', 'Thai'], ['Tibt', 'Tibetan'], ['Tirh', 'Tirhuta'], ['Tnsa', 'Tangsa'], ['Todr', 'Todhri'], ['Toto', 'Toto'], ['Tutg', 'Tulu_Tigalari'], ['Ugar', 'Ugaritic'], ['Vaii', 'Vai'], ['Vith', 'Vithkuqi'], ['Wara', 'Warang_Citi'], ['Wcho', 'Wancho'], ['Xpeo', 'Old_Persian'], ['Xsux', 'Cuneiform'], ['Yezi', 'Yezidi'], ['Yiii', 'Yi'], ['Zanb', 'Zanabazar_Square'], ['Zinh', 'Inherited'], ['Qaai', 'Inherited'], ['Zyyy', 'Common'], ['Zzzz', 'Unknown'], ['Adlam', 'Adlam'], ['Caucasian_Albanian', 'Caucasian_Albanian'], ['Arabic', 'Arabic'], ['Imperial_Aramaic', 'Imperial_Aramaic'], ['Armenian', 'Armenian'], ['Avestan', 'Avestan'], ['Balinese', 'Balinese'], ['Bamum', 'Bamum'], ['Bassa_Vah', 'Bassa_Vah'], ['Batak', 'Batak'], ['Bengali', 'Bengali'], ['Bhaiksuki', 'Bhaiksuki'], ['Bopomofo', 'Bopomofo'], ['Brahmi', 'Brahmi'], ['Braille', 'Braille'], ['Buginese', 'Buginese'], ['Buhid', 'Buhid'], ['Chakma', 'Chakma'], ['Canadian_Aboriginal', 'Canadian_Aboriginal'], ['Carian', 'Carian'], ['Cherokee', 'Cherokee'], ['Chorasmian', 'Chorasmian'], ['Coptic', 'Coptic'], ['Cypro_Minoan', 'Cypro_Minoan'], ['Cypriot', 'Cypriot'], ['Cyrillic', 'Cyrillic'], ['Devanagari', 'Devanagari'], ['Dives_Akuru', 'Dives_Akuru'], ['Dogra', 'Dogra'], ['Deseret', 'Deseret'], ['Duployan', 'Duployan'], ['Egyptian_Hieroglyphs', 'Egyptian_Hieroglyphs'], ['Elbasan', 'Elbasan'], ['Elymaic', 'Elymaic'], ['Ethiopic', 'Ethiopic'], ['Garay', 'Garay'], ['Georgian', 'Georgian'], ['Glagolitic', 'Glagolitic'], ['Gunjala_Gondi', 'Gunjala_Gondi'], ['Masaram_Gondi', 'Masaram_Gondi'], ['Gothic', 'Gothic'], ['Grantha', 'Grantha'], ['Greek', 'Greek'], ['Gujarati', 'Gujarati'], ['Gurung_Khema', 'Gurung_Khema'], ['Gurmukhi', 'Gurmukhi'], ['Hangul', 'Hangul'], ['Han', 'Han'], ['Hanunoo', 'Hanunoo'], ['Hatran', 'Hatran'], ['Hebrew', 'Hebrew'], ['Hiragana', 'Hiragana'], ['Anatolian_Hieroglyphs', 'Anatolian_Hieroglyphs'], ['Pahawh_Hmong', 'Pahawh_Hmong'], ['Nyiakeng_Puachue_Hmong', 'Nyiakeng_Puachue_Hmong'], ['Katakana_Or_Hiragana', 'Katakana_Or_Hiragana'], ['Old_Hungarian', 'Old_Hungarian'], ['Old_Italic', 'Old_Italic'], ['Javanese', 'Javanese'], ['Kayah_Li', 'Kayah_Li'], ['Katakana', 'Katakana'], ['Kharoshthi', 'Kharoshthi'], ['Khmer', 'Khmer'], ['Khojki', 'Khojki'], ['Khitan_Small_Script', 'Khitan_Small_Script'], ['Kannada', 'Kannada'], ['Kirat_Rai', 'Kirat_Rai'], ['Kaithi', 'Kaithi'], ['Tai_Tham', 'Tai_Tham'], ['Lao', 'Lao'], ['Latin', 'Latin'], ['Lepcha', 'Lepcha'], ['Limbu', 'Limbu'], ['Linear_A', 'Linear_A'], ['Linear_B', 'Linear_B'], ['Lycian', 'Lycian'], ['Lydian', 'Lydian'], ['Mahajani', 'Mahajani'], ['Makasar', 'Makasar'], ['Mandaic', 'Mandaic'], ['Manichaean', 'Manichaean'], ['Marchen', 'Marchen'], ['Medefaidrin', 'Medefaidrin'], ['Mende_Kikakui', 'Mende_Kikakui'], ['Meroitic_Cursive', 'Meroitic_Cursive'], ['Meroitic_Hieroglyphs', 'Meroitic_Hieroglyphs'], ['Malayalam', 'Malayalam'], ['Mongolian', 'Mongolian'], ['Mro', 'Mro'], ['Meetei_Mayek', 'Meetei_Mayek'], ['Multani', 'Multani'], ['Myanmar', 'Myanmar'], ['Nag_Mundari', 'Nag_Mundari'], ['Nandinagari', 'Nandinagari'], ['Old_North_Arabian', 'Old_North_Arabian'], ['Nabataean', 'Nabataean'], ['Nko', 'Nko'], ['Nushu', 'Nushu'], ['Ogham', 'Ogham'], ['Ol_Chiki', 'Ol_Chiki'], ['Ol_Onal', 'Ol_Onal'], ['Old_Turkic', 'Old_Turkic'], ['Oriya', 'Oriya'], ['Osage', 'Osage'], ['Osmanya', 'Osmanya'], ['Old_Uyghur', 'Old_Uyghur'], ['Palmyrene', 'Palmyrene'], ['Pau_Cin_Hau', 'Pau_Cin_Hau'], ['Old_Permic', 'Old_Permic'], ['Phags_Pa', 'Phags_Pa'], ['Inscriptional_Pahlavi', 'Inscriptional_Pahlavi'], ['Psalter_Pahlavi', 'Psalter_Pahlavi'], ['Phoenician', 'Phoenician'], ['Miao', 'Miao'], ['Inscriptional_Parthian', 'Inscriptional_Parthian'], ['Rejang', 'Rejang'], ['Hanifi_Rohingya', 'Hanifi_Rohingya'], ['Runic', 'Runic'], ['Samaritan', 'Samaritan'], ['Old_South_Arabian', 'Old_South_Arabian'], ['Saurashtra', 'Saurashtra'], ['SignWriting', 'SignWriting'], ['Shavian', 'Shavian'], ['Sharada', 'Sharada'], ['Siddham', 'Siddham'], ['Khudawadi', 'Khudawadi'], ['Sinhala', 'Sinhala'], ['Sogdian', 'Sogdian'], ['Old_Sogdian', 'Old_Sogdian'], ['Sora_Sompeng', 'Sora_Sompeng'], ['Soyombo', 'Soyombo'], ['Sundanese', 'Sundanese'], ['Sunuwar', 'Sunuwar'], ['Syloti_Nagri', 'Syloti_Nagri'], ['Syriac', 'Syriac'], ['Tagbanwa', 'Tagbanwa'], ['Takri', 'Takri'], ['Tai_Le', 'Tai_Le'], ['New_Tai_Lue', 'New_Tai_Lue'], ['Tamil', 'Tamil'], ['Tangut', 'Tangut'], ['Tai_Viet', 'Tai_Viet'], ['Telugu', 'Telugu'], ['Tifinagh', 'Tifinagh'], ['Tagalog', 'Tagalog'], ['Thaana', 'Thaana'], ['Tibetan', 'Tibetan'], ['Tirhuta', 'Tirhuta'], ['Tangsa', 'Tangsa'], ['Todhri', 'Todhri'], ['Tulu_Tigalari', 'Tulu_Tigalari'], ['Ugaritic', 'Ugaritic'], ['Vai', 'Vai'], ['Vithkuqi', 'Vithkuqi'], ['Warang_Citi', 'Warang_Citi'], ['Wancho', 'Wancho'], ['Old_Persian', 'Old_Persian'], ['Cuneiform', 'Cuneiform'], ['Yezidi', 'Yezidi'], ['Yi', 'Yi'], ['Zanabazar_Square', 'Zanabazar_Square'], ['Inherited', 'Inherited'], ['Common', 'Common'], ['Unknown', 'Unknown']])], ['Script_Extensions', new Map([['Adlm', 'Adlam'], ['Aghb', 'Caucasian_Albanian'], ['Ahom', 'Ahom'], ['Arab', 'Arabic'], ['Armi', 'Imperial_Aramaic'], ['Armn', 'Armenian'], ['Avst', 'Avestan'], ['Bali', 'Balinese'], ['Bamu', 'Bamum'], ['Bass', 'Bassa_Vah'], ['Batk', 'Batak'], ['Beng', 'Bengali'], ['Bhks', 'Bhaiksuki'], ['Bopo', 'Bopomofo'], ['Brah', 'Brahmi'], ['Brai', 'Braille'], ['Bugi', 'Buginese'], ['Buhd', 'Buhid'], ['Cakm', 'Chakma'], ['Cans', 'Canadian_Aboriginal'], ['Cari', 'Carian'], ['Cham', 'Cham'], ['Cher', 'Cherokee'], ['Chrs', 'Chorasmian'], ['Copt', 'Coptic'], ['Qaac', 'Coptic'], ['Cpmn', 'Cypro_Minoan'], ['Cprt', 'Cypriot'], ['Cyrl', 'Cyrillic'], ['Deva', 'Devanagari'], ['Diak', 'Dives_Akuru'], ['Dogr', 'Dogra'], ['Dsrt', 'Deseret'], ['Dupl', 'Duployan'], ['Egyp', 'Egyptian_Hieroglyphs'], ['Elba', 'Elbasan'], ['Elym', 'Elymaic'], ['Ethi', 'Ethiopic'], ['Gara', 'Garay'], ['Geor', 'Georgian'], ['Glag', 'Glagolitic'], ['Gong', 'Gunjala_Gondi'], ['Gonm', 'Masaram_Gondi'], ['Goth', 'Gothic'], ['Gran', 'Grantha'], ['Grek', 'Greek'], ['Gujr', 'Gujarati'], ['Gukh', 'Gurung_Khema'], ['Guru', 'Gurmukhi'], ['Hang', 'Hangul'], ['Hani', 'Han'], ['Hano', 'Hanunoo'], ['Hatr', 'Hatran'], ['Hebr', 'Hebrew'], ['Hira', 'Hiragana'], ['Hluw', 'Anatolian_Hieroglyphs'], ['Hmng', 'Pahawh_Hmong'], ['Hmnp', 'Nyiakeng_Puachue_Hmong'], ['Hrkt', 'Katakana_Or_Hiragana'], ['Hung', 'Old_Hungarian'], ['Ital', 'Old_Italic'], ['Java', 'Javanese'], ['Kali', 'Kayah_Li'], ['Kana', 'Katakana'], ['Kawi', 'Kawi'], ['Khar', 'Kharoshthi'], ['Khmr', 'Khmer'], ['Khoj', 'Khojki'], ['Kits', 'Khitan_Small_Script'], ['Knda', 'Kannada'], ['Krai', 'Kirat_Rai'], ['Kthi', 'Kaithi'], ['Lana', 'Tai_Tham'], ['Laoo', 'Lao'], ['Latn', 'Latin'], ['Lepc', 'Lepcha'], ['Limb', 'Limbu'], ['Lina', 'Linear_A'], ['Linb', 'Linear_B'], ['Lisu', 'Lisu'], ['Lyci', 'Lycian'], ['Lydi', 'Lydian'], ['Mahj', 'Mahajani'], ['Maka', 'Makasar'], ['Mand', 'Mandaic'], ['Mani', 'Manichaean'], ['Marc', 'Marchen'], ['Medf', 'Medefaidrin'], ['Mend', 'Mende_Kikakui'], ['Merc', 'Meroitic_Cursive'], ['Mero', 'Meroitic_Hieroglyphs'], ['Mlym', 'Malayalam'], ['Modi', 'Modi'], ['Mong', 'Mongolian'], ['Mroo', 'Mro'], ['Mtei', 'Meetei_Mayek'], ['Mult', 'Multani'], ['Mymr', 'Myanmar'], ['Nagm', 'Nag_Mundari'], ['Nand', 'Nandinagari'], ['Narb', 'Old_North_Arabian'], ['Nbat', 'Nabataean'], ['Newa', 'Newa'], ['Nkoo', 'Nko'], ['Nshu', 'Nushu'], ['Ogam', 'Ogham'], ['Olck', 'Ol_Chiki'], ['Onao', 'Ol_Onal'], ['Orkh', 'Old_Turkic'], ['Orya', 'Oriya'], ['Osge', 'Osage'], ['Osma', 'Osmanya'], ['Ougr', 'Old_Uyghur'], ['Palm', 'Palmyrene'], ['Pauc', 'Pau_Cin_Hau'], ['Perm', 'Old_Permic'], ['Phag', 'Phags_Pa'], ['Phli', 'Inscriptional_Pahlavi'], ['Phlp', 'Psalter_Pahlavi'], ['Phnx', 'Phoenician'], ['Plrd', 'Miao'], ['Prti', 'Inscriptional_Parthian'], ['Rjng', 'Rejang'], ['Rohg', 'Hanifi_Rohingya'], ['Runr', 'Runic'], ['Samr', 'Samaritan'], ['Sarb', 'Old_South_Arabian'], ['Saur', 'Saurashtra'], ['Sgnw', 'SignWriting'], ['Shaw', 'Shavian'], ['Shrd', 'Sharada'], ['Sidd', 'Siddham'], ['Sind', 'Khudawadi'], ['Sinh', 'Sinhala'], ['Sogd', 'Sogdian'], ['Sogo', 'Old_Sogdian'], ['Sora', 'Sora_Sompeng'], ['Soyo', 'Soyombo'], ['Sund', 'Sundanese'], ['Sunu', 'Sunuwar'], ['Sylo', 'Syloti_Nagri'], ['Syrc', 'Syriac'], ['Tagb', 'Tagbanwa'], ['Takr', 'Takri'], ['Tale', 'Tai_Le'], ['Talu', 'New_Tai_Lue'], ['Taml', 'Tamil'], ['Tang', 'Tangut'], ['Tavt', 'Tai_Viet'], ['Telu', 'Telugu'], ['Tfng', 'Tifinagh'], ['Tglg', 'Tagalog'], ['Thaa', 'Thaana'], ['Thai', 'Thai'], ['Tibt', 'Tibetan'], ['Tirh', 'Tirhuta'], ['Tnsa', 'Tangsa'], ['Todr', 'Todhri'], ['Toto', 'Toto'], ['Tutg', 'Tulu_Tigalari'], ['Ugar', 'Ugaritic'], ['Vaii', 'Vai'], ['Vith', 'Vithkuqi'], ['Wara', 'Warang_Citi'], ['Wcho', 'Wancho'], ['Xpeo', 'Old_Persian'], ['Xsux', 'Cuneiform'], ['Yezi', 'Yezidi'], ['Yiii', 'Yi'], ['Zanb', 'Zanabazar_Square'], ['Zinh', 'Inherited'], ['Qaai', 'Inherited'], ['Zyyy', 'Common'], ['Zzzz', 'Unknown'], ['Adlam', 'Adlam'], ['Caucasian_Albanian', 'Caucasian_Albanian'], ['Arabic', 'Arabic'], ['Imperial_Aramaic', 'Imperial_Aramaic'], ['Armenian', 'Armenian'], ['Avestan', 'Avestan'], ['Balinese', 'Balinese'], ['Bamum', 'Bamum'], ['Bassa_Vah', 'Bassa_Vah'], ['Batak', 'Batak'], ['Bengali', 'Bengali'], ['Bhaiksuki', 'Bhaiksuki'], ['Bopomofo', 'Bopomofo'], ['Brahmi', 'Brahmi'], ['Braille', 'Braille'], ['Buginese', 'Buginese'], ['Buhid', 'Buhid'], ['Chakma', 'Chakma'], ['Canadian_Aboriginal', 'Canadian_Aboriginal'], ['Carian', 'Carian'], ['Cherokee', 'Cherokee'], ['Chorasmian', 'Chorasmian'], ['Coptic', 'Coptic'], ['Cypro_Minoan', 'Cypro_Minoan'], ['Cypriot', 'Cypriot'], ['Cyrillic', 'Cyrillic'], ['Devanagari', 'Devanagari'], ['Dives_Akuru', 'Dives_Akuru'], ['Dogra', 'Dogra'], ['Deseret', 'Deseret'], ['Duployan', 'Duployan'], ['Egyptian_Hieroglyphs', 'Egyptian_Hieroglyphs'], ['Elbasan', 'Elbasan'], ['Elymaic', 'Elymaic'], ['Ethiopic', 'Ethiopic'], ['Garay', 'Garay'], ['Georgian', 'Georgian'], ['Glagolitic', 'Glagolitic'], ['Gunjala_Gondi', 'Gunjala_Gondi'], ['Masaram_Gondi', 'Masaram_Gondi'], ['Gothic', 'Gothic'], ['Grantha', 'Grantha'], ['Greek', 'Greek'], ['Gujarati', 'Gujarati'], ['Gurung_Khema', 'Gurung_Khema'], ['Gurmukhi', 'Gurmukhi'], ['Hangul', 'Hangul'], ['Han', 'Han'], ['Hanunoo', 'Hanunoo'], ['Hatran', 'Hatran'], ['Hebrew', 'Hebrew'], ['Hiragana', 'Hiragana'], ['Anatolian_Hieroglyphs', 'Anatolian_Hieroglyphs'], ['Pahawh_Hmong', 'Pahawh_Hmong'], ['Nyiakeng_Puachue_Hmong', 'Nyiakeng_Puachue_Hmong'], ['Katakana_Or_Hiragana', 'Katakana_Or_Hiragana'], ['Old_Hungarian', 'Old_Hungarian'], ['Old_Italic', 'Old_Italic'], ['Javanese', 'Javanese'], ['Kayah_Li', 'Kayah_Li'], ['Katakana', 'Katakana'], ['Kharoshthi', 'Kharoshthi'], ['Khmer', 'Khmer'], ['Khojki', 'Khojki'], ['Khitan_Small_Script', 'Khitan_Small_Script'], ['Kannada', 'Kannada'], ['Kirat_Rai', 'Kirat_Rai'], ['Kaithi', 'Kaithi'], ['Tai_Tham', 'Tai_Tham'], ['Lao', 'Lao'], ['Latin', 'Latin'], ['Lepcha', 'Lepcha'], ['Limbu', 'Limbu'], ['Linear_A', 'Linear_A'], ['Linear_B', 'Linear_B'], ['Lycian', 'Lycian'], ['Lydian', 'Lydian'], ['Mahajani', 'Mahajani'], ['Makasar', 'Makasar'], ['Mandaic', 'Mandaic'], ['Manichaean', 'Manichaean'], ['Marchen', 'Marchen'], ['Medefaidrin', 'Medefaidrin'], ['Mende_Kikakui', 'Mende_Kikakui'], ['Meroitic_Cursive', 'Meroitic_Cursive'], ['Meroitic_Hieroglyphs', 'Meroitic_Hieroglyphs'], ['Malayalam', 'Malayalam'], ['Mongolian', 'Mongolian'], ['Mro', 'Mro'], ['Meetei_Mayek', 'Meetei_Mayek'], ['Multani', 'Multani'], ['Myanmar', 'Myanmar'], ['Nag_Mundari', 'Nag_Mundari'], ['Nandinagari', 'Nandinagari'], ['Old_North_Arabian', 'Old_North_Arabian'], ['Nabataean', 'Nabataean'], ['Nko', 'Nko'], ['Nushu', 'Nushu'], ['Ogham', 'Ogham'], ['Ol_Chiki', 'Ol_Chiki'], ['Ol_Onal', 'Ol_Onal'], ['Old_Turkic', 'Old_Turkic'], ['Oriya', 'Oriya'], ['Osage', 'Osage'], ['Osmanya', 'Osmanya'], ['Old_Uyghur', 'Old_Uyghur'], ['Palmyrene', 'Palmyrene'], ['Pau_Cin_Hau', 'Pau_Cin_Hau'], ['Old_Permic', 'Old_Permic'], ['Phags_Pa', 'Phags_Pa'], ['Inscriptional_Pahlavi', 'Inscriptional_Pahlavi'], ['Psalter_Pahlavi', 'Psalter_Pahlavi'], ['Phoenician', 'Phoenician'], ['Miao', 'Miao'], ['Inscriptional_Parthian', 'Inscriptional_Parthian'], ['Rejang', 'Rejang'], ['Hanifi_Rohingya', 'Hanifi_Rohingya'], ['Runic', 'Runic'], ['Samaritan', 'Samaritan'], ['Old_South_Arabian', 'Old_South_Arabian'], ['Saurashtra', 'Saurashtra'], ['SignWriting', 'SignWriting'], ['Shavian', 'Shavian'], ['Sharada', 'Sharada'], ['Siddham', 'Siddham'], ['Khudawadi', 'Khudawadi'], ['Sinhala', 'Sinhala'], ['Sogdian', 'Sogdian'], ['Old_Sogdian', 'Old_Sogdian'], ['Sora_Sompeng', 'Sora_Sompeng'], ['Soyombo', 'Soyombo'], ['Sundanese', 'Sundanese'], ['Sunuwar', 'Sunuwar'], ['Syloti_Nagri', 'Syloti_Nagri'], ['Syriac', 'Syriac'], ['Tagbanwa', 'Tagbanwa'], ['Takri', 'Takri'], ['Tai_Le', 'Tai_Le'], ['New_Tai_Lue', 'New_Tai_Lue'], ['Tamil', 'Tamil'], ['Tangut', 'Tangut'], ['Tai_Viet', 'Tai_Viet'], ['Telugu', 'Telugu'], ['Tifinagh', 'Tifinagh'], ['Tagalog', 'Tagalog'], ['Thaana', 'Thaana'], ['Tibetan', 'Tibetan'], ['Tirhuta', 'Tirhuta'], ['Tangsa', 'Tangsa'], ['Todhri', 'Todhri'], ['Tulu_Tigalari', 'Tulu_Tigalari'], ['Ugaritic', 'Ugaritic'], ['Vai', 'Vai'], ['Vithkuqi', 'Vithkuqi'], ['Warang_Citi', 'Warang_Citi'], ['Wancho', 'Wancho'], ['Old_Persian', 'Old_Persian'], ['Cuneiform', 'Cuneiform'], ['Yezidi', 'Yezidi'], ['Yi', 'Yi'], ['Zanabazar_Square', 'Zanabazar_Square'], ['Inherited', 'Inherited'], ['Common', 'Common'], ['Unknown', 'Unknown']])]]);

var iuMappings$1 = new Map([[0x4B, 0x212A], [0x53, 0x17F], [0x6B, 0x212A], [0x73, 0x17F], [0xB5, 0x39C], [0xC5, 0x212B], [0xDF, 0x1E9E], [0xE5, 0x212B], [0x17F, 0x53], [0x1C4, 0x1C5], [0x1C5, 0x1C4], [0x1C7, 0x1C8], [0x1C8, 0x1C7], [0x1CA, 0x1CB], [0x1CB, 0x1CA], [0x1F1, 0x1F2], [0x1F2, 0x1F1], [0x345, 0x1FBE], [0x390, 0x1FD3], [0x392, 0x3D0], [0x395, 0x3F5], [0x398, 0x3F4], [0x399, 0x1FBE], [0x39A, 0x3F0], [0x39C, 0xB5], [0x3A0, 0x3D6], [0x3A1, 0x3F1], [0x3A3, 0x3C2], [0x3A6, 0x3D5], [0x3A9, 0x2126], [0x3B0, 0x1FE3], [0x3B8, 0x3F4], [0x3C2, 0x3A3], [0x3C9, 0x2126], [0x3D0, 0x392], [0x3D1, 0x3F4], [0x3D5, 0x3A6], [0x3D6, 0x3A0], [0x3F0, 0x39A], [0x3F1, 0x3A1], [0x3F4, [0x398, 0x3D1, 0x3B8]], [0x3F5, 0x395], [0x412, 0x1C80], [0x414, 0x1C81], [0x41E, 0x1C82], [0x421, 0x1C83], [0x422, 0x1C85], [0x42A, 0x1C86], [0x462, 0x1C87], [0x1C80, 0x412], [0x1C81, 0x414], [0x1C82, 0x41E], [0x1C83, 0x421], [0x1C84, 0x1C85], [0x1C85, [0x422, 0x1C84]], [0x1C86, 0x42A], [0x1C87, 0x462], [0x1C88, 0xA64A], [0x1E60, 0x1E9B], [0x1E9B, 0x1E60], [0x1E9E, 0xDF], [0x1F80, 0x1F88], [0x1F81, 0x1F89], [0x1F82, 0x1F8A], [0x1F83, 0x1F8B], [0x1F84, 0x1F8C], [0x1F85, 0x1F8D], [0x1F86, 0x1F8E], [0x1F87, 0x1F8F], [0x1F88, 0x1F80], [0x1F89, 0x1F81], [0x1F8A, 0x1F82], [0x1F8B, 0x1F83], [0x1F8C, 0x1F84], [0x1F8D, 0x1F85], [0x1F8E, 0x1F86], [0x1F8F, 0x1F87], [0x1F90, 0x1F98], [0x1F91, 0x1F99], [0x1F92, 0x1F9A], [0x1F93, 0x1F9B], [0x1F94, 0x1F9C], [0x1F95, 0x1F9D], [0x1F96, 0x1F9E], [0x1F97, 0x1F9F], [0x1F98, 0x1F90], [0x1F99, 0x1F91], [0x1F9A, 0x1F92], [0x1F9B, 0x1F93], [0x1F9C, 0x1F94], [0x1F9D, 0x1F95], [0x1F9E, 0x1F96], [0x1F9F, 0x1F97], [0x1FA0, 0x1FA8], [0x1FA1, 0x1FA9], [0x1FA2, 0x1FAA], [0x1FA3, 0x1FAB], [0x1FA4, 0x1FAC], [0x1FA5, 0x1FAD], [0x1FA6, 0x1FAE], [0x1FA7, 0x1FAF], [0x1FA8, 0x1FA0], [0x1FA9, 0x1FA1], [0x1FAA, 0x1FA2], [0x1FAB, 0x1FA3], [0x1FAC, 0x1FA4], [0x1FAD, 0x1FA5], [0x1FAE, 0x1FA6], [0x1FAF, 0x1FA7], [0x1FB3, 0x1FBC], [0x1FBC, 0x1FB3], [0x1FBE, [0x345, 0x399]], [0x1FC3, 0x1FCC], [0x1FCC, 0x1FC3], [0x1FD3, 0x390], [0x1FE3, 0x3B0], [0x1FF3, 0x1FFC], [0x1FFC, 0x1FF3], [0x2126, [0x3A9, 0x3C9]], [0x212A, 0x4B], [0x212B, [0xC5, 0xE5]], [0xA64A, 0x1C88], [0xFB05, 0xFB06], [0xFB06, 0xFB05], [0x10400, 0x10428], [0x10401, 0x10429], [0x10402, 0x1042A], [0x10403, 0x1042B], [0x10404, 0x1042C], [0x10405, 0x1042D], [0x10406, 0x1042E], [0x10407, 0x1042F], [0x10408, 0x10430], [0x10409, 0x10431], [0x1040A, 0x10432], [0x1040B, 0x10433], [0x1040C, 0x10434], [0x1040D, 0x10435], [0x1040E, 0x10436], [0x1040F, 0x10437], [0x10410, 0x10438], [0x10411, 0x10439], [0x10412, 0x1043A], [0x10413, 0x1043B], [0x10414, 0x1043C], [0x10415, 0x1043D], [0x10416, 0x1043E], [0x10417, 0x1043F], [0x10418, 0x10440], [0x10419, 0x10441], [0x1041A, 0x10442], [0x1041B, 0x10443], [0x1041C, 0x10444], [0x1041D, 0x10445], [0x1041E, 0x10446], [0x1041F, 0x10447], [0x10420, 0x10448], [0x10421, 0x10449], [0x10422, 0x1044A], [0x10423, 0x1044B], [0x10424, 0x1044C], [0x10425, 0x1044D], [0x10426, 0x1044E], [0x10427, 0x1044F], [0x10428, 0x10400], [0x10429, 0x10401], [0x1042A, 0x10402], [0x1042B, 0x10403], [0x1042C, 0x10404], [0x1042D, 0x10405], [0x1042E, 0x10406], [0x1042F, 0x10407], [0x10430, 0x10408], [0x10431, 0x10409], [0x10432, 0x1040A], [0x10433, 0x1040B], [0x10434, 0x1040C], [0x10435, 0x1040D], [0x10436, 0x1040E], [0x10437, 0x1040F], [0x10438, 0x10410], [0x10439, 0x10411], [0x1043A, 0x10412], [0x1043B, 0x10413], [0x1043C, 0x10414], [0x1043D, 0x10415], [0x1043E, 0x10416], [0x1043F, 0x10417], [0x10440, 0x10418], [0x10441, 0x10419], [0x10442, 0x1041A], [0x10443, 0x1041B], [0x10444, 0x1041C], [0x10445, 0x1041D], [0x10446, 0x1041E], [0x10447, 0x1041F], [0x10448, 0x10420], [0x10449, 0x10421], [0x1044A, 0x10422], [0x1044B, 0x10423], [0x1044C, 0x10424], [0x1044D, 0x10425], [0x1044E, 0x10426], [0x1044F, 0x10427], [0x104B0, 0x104D8], [0x104B1, 0x104D9], [0x104B2, 0x104DA], [0x104B3, 0x104DB], [0x104B4, 0x104DC], [0x104B5, 0x104DD], [0x104B6, 0x104DE], [0x104B7, 0x104DF], [0x104B8, 0x104E0], [0x104B9, 0x104E1], [0x104BA, 0x104E2], [0x104BB, 0x104E3], [0x104BC, 0x104E4], [0x104BD, 0x104E5], [0x104BE, 0x104E6], [0x104BF, 0x104E7], [0x104C0, 0x104E8], [0x104C1, 0x104E9], [0x104C2, 0x104EA], [0x104C3, 0x104EB], [0x104C4, 0x104EC], [0x104C5, 0x104ED], [0x104C6, 0x104EE], [0x104C7, 0x104EF], [0x104C8, 0x104F0], [0x104C9, 0x104F1], [0x104CA, 0x104F2], [0x104CB, 0x104F3], [0x104CC, 0x104F4], [0x104CD, 0x104F5], [0x104CE, 0x104F6], [0x104CF, 0x104F7], [0x104D0, 0x104F8], [0x104D1, 0x104F9], [0x104D2, 0x104FA], [0x104D3, 0x104FB], [0x104D8, 0x104B0], [0x104D9, 0x104B1], [0x104DA, 0x104B2], [0x104DB, 0x104B3], [0x104DC, 0x104B4], [0x104DD, 0x104B5], [0x104DE, 0x104B6], [0x104DF, 0x104B7], [0x104E0, 0x104B8], [0x104E1, 0x104B9], [0x104E2, 0x104BA], [0x104E3, 0x104BB], [0x104E4, 0x104BC], [0x104E5, 0x104BD], [0x104E6, 0x104BE], [0x104E7, 0x104BF], [0x104E8, 0x104C0], [0x104E9, 0x104C1], [0x104EA, 0x104C2], [0x104EB, 0x104C3], [0x104EC, 0x104C4], [0x104ED, 0x104C5], [0x104EE, 0x104C6], [0x104EF, 0x104C7], [0x104F0, 0x104C8], [0x104F1, 0x104C9], [0x104F2, 0x104CA], [0x104F3, 0x104CB], [0x104F4, 0x104CC], [0x104F5, 0x104CD], [0x104F6, 0x104CE], [0x104F7, 0x104CF], [0x104F8, 0x104D0], [0x104F9, 0x104D1], [0x104FA, 0x104D2], [0x104FB, 0x104D3], [0x10570, 0x10597], [0x10571, 0x10598], [0x10572, 0x10599], [0x10573, 0x1059A], [0x10574, 0x1059B], [0x10575, 0x1059C], [0x10576, 0x1059D], [0x10577, 0x1059E], [0x10578, 0x1059F], [0x10579, 0x105A0], [0x1057A, 0x105A1], [0x1057C, 0x105A3], [0x1057D, 0x105A4], [0x1057E, 0x105A5], [0x1057F, 0x105A6], [0x10580, 0x105A7], [0x10581, 0x105A8], [0x10582, 0x105A9], [0x10583, 0x105AA], [0x10584, 0x105AB], [0x10585, 0x105AC], [0x10586, 0x105AD], [0x10587, 0x105AE], [0x10588, 0x105AF], [0x10589, 0x105B0], [0x1058A, 0x105B1], [0x1058C, 0x105B3], [0x1058D, 0x105B4], [0x1058E, 0x105B5], [0x1058F, 0x105B6], [0x10590, 0x105B7], [0x10591, 0x105B8], [0x10592, 0x105B9], [0x10594, 0x105BB], [0x10595, 0x105BC], [0x10597, 0x10570], [0x10598, 0x10571], [0x10599, 0x10572], [0x1059A, 0x10573], [0x1059B, 0x10574], [0x1059C, 0x10575], [0x1059D, 0x10576], [0x1059E, 0x10577], [0x1059F, 0x10578], [0x105A0, 0x10579], [0x105A1, 0x1057A], [0x105A3, 0x1057C], [0x105A4, 0x1057D], [0x105A5, 0x1057E], [0x105A6, 0x1057F], [0x105A7, 0x10580], [0x105A8, 0x10581], [0x105A9, 0x10582], [0x105AA, 0x10583], [0x105AB, 0x10584], [0x105AC, 0x10585], [0x105AD, 0x10586], [0x105AE, 0x10587], [0x105AF, 0x10588], [0x105B0, 0x10589], [0x105B1, 0x1058A], [0x105B3, 0x1058C], [0x105B4, 0x1058D], [0x105B5, 0x1058E], [0x105B6, 0x1058F], [0x105B7, 0x10590], [0x105B8, 0x10591], [0x105B9, 0x10592], [0x105BB, 0x10594], [0x105BC, 0x10595], [0x10C80, 0x10CC0], [0x10C81, 0x10CC1], [0x10C82, 0x10CC2], [0x10C83, 0x10CC3], [0x10C84, 0x10CC4], [0x10C85, 0x10CC5], [0x10C86, 0x10CC6], [0x10C87, 0x10CC7], [0x10C88, 0x10CC8], [0x10C89, 0x10CC9], [0x10C8A, 0x10CCA], [0x10C8B, 0x10CCB], [0x10C8C, 0x10CCC], [0x10C8D, 0x10CCD], [0x10C8E, 0x10CCE], [0x10C8F, 0x10CCF], [0x10C90, 0x10CD0], [0x10C91, 0x10CD1], [0x10C92, 0x10CD2], [0x10C93, 0x10CD3], [0x10C94, 0x10CD4], [0x10C95, 0x10CD5], [0x10C96, 0x10CD6], [0x10C97, 0x10CD7], [0x10C98, 0x10CD8], [0x10C99, 0x10CD9], [0x10C9A, 0x10CDA], [0x10C9B, 0x10CDB], [0x10C9C, 0x10CDC], [0x10C9D, 0x10CDD], [0x10C9E, 0x10CDE], [0x10C9F, 0x10CDF], [0x10CA0, 0x10CE0], [0x10CA1, 0x10CE1], [0x10CA2, 0x10CE2], [0x10CA3, 0x10CE3], [0x10CA4, 0x10CE4], [0x10CA5, 0x10CE5], [0x10CA6, 0x10CE6], [0x10CA7, 0x10CE7], [0x10CA8, 0x10CE8], [0x10CA9, 0x10CE9], [0x10CAA, 0x10CEA], [0x10CAB, 0x10CEB], [0x10CAC, 0x10CEC], [0x10CAD, 0x10CED], [0x10CAE, 0x10CEE], [0x10CAF, 0x10CEF], [0x10CB0, 0x10CF0], [0x10CB1, 0x10CF1], [0x10CB2, 0x10CF2], [0x10CC0, 0x10C80], [0x10CC1, 0x10C81], [0x10CC2, 0x10C82], [0x10CC3, 0x10C83], [0x10CC4, 0x10C84], [0x10CC5, 0x10C85], [0x10CC6, 0x10C86], [0x10CC7, 0x10C87], [0x10CC8, 0x10C88], [0x10CC9, 0x10C89], [0x10CCA, 0x10C8A], [0x10CCB, 0x10C8B], [0x10CCC, 0x10C8C], [0x10CCD, 0x10C8D], [0x10CCE, 0x10C8E], [0x10CCF, 0x10C8F], [0x10CD0, 0x10C90], [0x10CD1, 0x10C91], [0x10CD2, 0x10C92], [0x10CD3, 0x10C93], [0x10CD4, 0x10C94], [0x10CD5, 0x10C95], [0x10CD6, 0x10C96], [0x10CD7, 0x10C97], [0x10CD8, 0x10C98], [0x10CD9, 0x10C99], [0x10CDA, 0x10C9A], [0x10CDB, 0x10C9B], [0x10CDC, 0x10C9C], [0x10CDD, 0x10C9D], [0x10CDE, 0x10C9E], [0x10CDF, 0x10C9F], [0x10CE0, 0x10CA0], [0x10CE1, 0x10CA1], [0x10CE2, 0x10CA2], [0x10CE3, 0x10CA3], [0x10CE4, 0x10CA4], [0x10CE5, 0x10CA5], [0x10CE6, 0x10CA6], [0x10CE7, 0x10CA7], [0x10CE8, 0x10CA8], [0x10CE9, 0x10CA9], [0x10CEA, 0x10CAA], [0x10CEB, 0x10CAB], [0x10CEC, 0x10CAC], [0x10CED, 0x10CAD], [0x10CEE, 0x10CAE], [0x10CEF, 0x10CAF], [0x10CF0, 0x10CB0], [0x10CF1, 0x10CB1], [0x10CF2, 0x10CB2], [0x10D50, 0x10D70], [0x10D51, 0x10D71], [0x10D52, 0x10D72], [0x10D53, 0x10D73], [0x10D54, 0x10D74], [0x10D55, 0x10D75], [0x10D56, 0x10D76], [0x10D57, 0x10D77], [0x10D58, 0x10D78], [0x10D59, 0x10D79], [0x10D5A, 0x10D7A], [0x10D5B, 0x10D7B], [0x10D5C, 0x10D7C], [0x10D5D, 0x10D7D], [0x10D5E, 0x10D7E], [0x10D5F, 0x10D7F], [0x10D60, 0x10D80], [0x10D61, 0x10D81], [0x10D62, 0x10D82], [0x10D63, 0x10D83], [0x10D64, 0x10D84], [0x10D65, 0x10D85], [0x10D70, 0x10D50], [0x10D71, 0x10D51], [0x10D72, 0x10D52], [0x10D73, 0x10D53], [0x10D74, 0x10D54], [0x10D75, 0x10D55], [0x10D76, 0x10D56], [0x10D77, 0x10D57], [0x10D78, 0x10D58], [0x10D79, 0x10D59], [0x10D7A, 0x10D5A], [0x10D7B, 0x10D5B], [0x10D7C, 0x10D5C], [0x10D7D, 0x10D5D], [0x10D7E, 0x10D5E], [0x10D7F, 0x10D5F], [0x10D80, 0x10D60], [0x10D81, 0x10D61], [0x10D82, 0x10D62], [0x10D83, 0x10D63], [0x10D84, 0x10D64], [0x10D85, 0x10D65], [0x118A0, 0x118C0], [0x118A1, 0x118C1], [0x118A2, 0x118C2], [0x118A3, 0x118C3], [0x118A4, 0x118C4], [0x118A5, 0x118C5], [0x118A6, 0x118C6], [0x118A7, 0x118C7], [0x118A8, 0x118C8], [0x118A9, 0x118C9], [0x118AA, 0x118CA], [0x118AB, 0x118CB], [0x118AC, 0x118CC], [0x118AD, 0x118CD], [0x118AE, 0x118CE], [0x118AF, 0x118CF], [0x118B0, 0x118D0], [0x118B1, 0x118D1], [0x118B2, 0x118D2], [0x118B3, 0x118D3], [0x118B4, 0x118D4], [0x118B5, 0x118D5], [0x118B6, 0x118D6], [0x118B7, 0x118D7], [0x118B8, 0x118D8], [0x118B9, 0x118D9], [0x118BA, 0x118DA], [0x118BB, 0x118DB], [0x118BC, 0x118DC], [0x118BD, 0x118DD], [0x118BE, 0x118DE], [0x118BF, 0x118DF], [0x118C0, 0x118A0], [0x118C1, 0x118A1], [0x118C2, 0x118A2], [0x118C3, 0x118A3], [0x118C4, 0x118A4], [0x118C5, 0x118A5], [0x118C6, 0x118A6], [0x118C7, 0x118A7], [0x118C8, 0x118A8], [0x118C9, 0x118A9], [0x118CA, 0x118AA], [0x118CB, 0x118AB], [0x118CC, 0x118AC], [0x118CD, 0x118AD], [0x118CE, 0x118AE], [0x118CF, 0x118AF], [0x118D0, 0x118B0], [0x118D1, 0x118B1], [0x118D2, 0x118B2], [0x118D3, 0x118B3], [0x118D4, 0x118B4], [0x118D5, 0x118B5], [0x118D6, 0x118B6], [0x118D7, 0x118B7], [0x118D8, 0x118B8], [0x118D9, 0x118B9], [0x118DA, 0x118BA], [0x118DB, 0x118BB], [0x118DC, 0x118BC], [0x118DD, 0x118BD], [0x118DE, 0x118BE], [0x118DF, 0x118BF], [0x16E40, 0x16E60], [0x16E41, 0x16E61], [0x16E42, 0x16E62], [0x16E43, 0x16E63], [0x16E44, 0x16E64], [0x16E45, 0x16E65], [0x16E46, 0x16E66], [0x16E47, 0x16E67], [0x16E48, 0x16E68], [0x16E49, 0x16E69], [0x16E4A, 0x16E6A], [0x16E4B, 0x16E6B], [0x16E4C, 0x16E6C], [0x16E4D, 0x16E6D], [0x16E4E, 0x16E6E], [0x16E4F, 0x16E6F], [0x16E50, 0x16E70], [0x16E51, 0x16E71], [0x16E52, 0x16E72], [0x16E53, 0x16E73], [0x16E54, 0x16E74], [0x16E55, 0x16E75], [0x16E56, 0x16E76], [0x16E57, 0x16E77], [0x16E58, 0x16E78], [0x16E59, 0x16E79], [0x16E5A, 0x16E7A], [0x16E5B, 0x16E7B], [0x16E5C, 0x16E7C], [0x16E5D, 0x16E7D], [0x16E5E, 0x16E7E], [0x16E5F, 0x16E7F], [0x16E60, 0x16E40], [0x16E61, 0x16E41], [0x16E62, 0x16E42], [0x16E63, 0x16E43], [0x16E64, 0x16E44], [0x16E65, 0x16E45], [0x16E66, 0x16E46], [0x16E67, 0x16E47], [0x16E68, 0x16E48], [0x16E69, 0x16E49], [0x16E6A, 0x16E4A], [0x16E6B, 0x16E4B], [0x16E6C, 0x16E4C], [0x16E6D, 0x16E4D], [0x16E6E, 0x16E4E], [0x16E6F, 0x16E4F], [0x16E70, 0x16E50], [0x16E71, 0x16E51], [0x16E72, 0x16E52], [0x16E73, 0x16E53], [0x16E74, 0x16E54], [0x16E75, 0x16E55], [0x16E76, 0x16E56], [0x16E77, 0x16E57], [0x16E78, 0x16E58], [0x16E79, 0x16E59], [0x16E7A, 0x16E5A], [0x16E7B, 0x16E5B], [0x16E7C, 0x16E5C], [0x16E7D, 0x16E5D], [0x16E7E, 0x16E5E], [0x16E7F, 0x16E5F], [0x1E900, 0x1E922], [0x1E901, 0x1E923], [0x1E902, 0x1E924], [0x1E903, 0x1E925], [0x1E904, 0x1E926], [0x1E905, 0x1E927], [0x1E906, 0x1E928], [0x1E907, 0x1E929], [0x1E908, 0x1E92A], [0x1E909, 0x1E92B], [0x1E90A, 0x1E92C], [0x1E90B, 0x1E92D], [0x1E90C, 0x1E92E], [0x1E90D, 0x1E92F], [0x1E90E, 0x1E930], [0x1E90F, 0x1E931], [0x1E910, 0x1E932], [0x1E911, 0x1E933], [0x1E912, 0x1E934], [0x1E913, 0x1E935], [0x1E914, 0x1E936], [0x1E915, 0x1E937], [0x1E916, 0x1E938], [0x1E917, 0x1E939], [0x1E918, 0x1E93A], [0x1E919, 0x1E93B], [0x1E91A, 0x1E93C], [0x1E91B, 0x1E93D], [0x1E91C, 0x1E93E], [0x1E91D, 0x1E93F], [0x1E91E, 0x1E940], [0x1E91F, 0x1E941], [0x1E920, 0x1E942], [0x1E921, 0x1E943], [0x1E922, 0x1E900], [0x1E923, 0x1E901], [0x1E924, 0x1E902], [0x1E925, 0x1E903], [0x1E926, 0x1E904], [0x1E927, 0x1E905], [0x1E928, 0x1E906], [0x1E929, 0x1E907], [0x1E92A, 0x1E908], [0x1E92B, 0x1E909], [0x1E92C, 0x1E90A], [0x1E92D, 0x1E90B], [0x1E92E, 0x1E90C], [0x1E92F, 0x1E90D], [0x1E930, 0x1E90E], [0x1E931, 0x1E90F], [0x1E932, 0x1E910], [0x1E933, 0x1E911], [0x1E934, 0x1E912], [0x1E935, 0x1E913], [0x1E936, 0x1E914], [0x1E937, 0x1E915], [0x1E938, 0x1E916], [0x1E939, 0x1E917], [0x1E93A, 0x1E918], [0x1E93B, 0x1E919], [0x1E93C, 0x1E91A], [0x1E93D, 0x1E91B], [0x1E93E, 0x1E91C], [0x1E93F, 0x1E91D], [0x1E940, 0x1E91E], [0x1E941, 0x1E91F], [0x1E942, 0x1E920], [0x1E943, 0x1E921]]);

var iBmpMappings = new Map([[0xB5, 0x3BC], [0xC0, 0xE0], [0xC1, 0xE1], [0xC2, 0xE2], [0xC3, 0xE3], [0xC4, 0xE4], [0xC5, 0xE5], [0xC6, 0xE6], [0xC7, 0xE7], [0xC8, 0xE8], [0xC9, 0xE9], [0xCA, 0xEA], [0xCB, 0xEB], [0xCC, 0xEC], [0xCD, 0xED], [0xCE, 0xEE], [0xCF, 0xEF], [0xD0, 0xF0], [0xD1, 0xF1], [0xD2, 0xF2], [0xD3, 0xF3], [0xD4, 0xF4], [0xD5, 0xF5], [0xD6, 0xF6], [0xD8, 0xF8], [0xD9, 0xF9], [0xDA, 0xFA], [0xDB, 0xFB], [0xDC, 0xFC], [0xDD, 0xFD], [0xDE, 0xFE], [0xE0, 0xC0], [0xE1, 0xC1], [0xE2, 0xC2], [0xE3, 0xC3], [0xE4, 0xC4], [0xE5, 0xC5], [0xE6, 0xC6], [0xE7, 0xC7], [0xE8, 0xC8], [0xE9, 0xC9], [0xEA, 0xCA], [0xEB, 0xCB], [0xEC, 0xCC], [0xED, 0xCD], [0xEE, 0xCE], [0xEF, 0xCF], [0xF0, 0xD0], [0xF1, 0xD1], [0xF2, 0xD2], [0xF3, 0xD3], [0xF4, 0xD4], [0xF5, 0xD5], [0xF6, 0xD6], [0xF8, 0xD8], [0xF9, 0xD9], [0xFA, 0xDA], [0xFB, 0xDB], [0xFC, 0xDC], [0xFD, 0xDD], [0xFE, 0xDE], [0xFF, 0x178], [0x100, 0x101], [0x101, 0x100], [0x102, 0x103], [0x103, 0x102], [0x104, 0x105], [0x105, 0x104], [0x106, 0x107], [0x107, 0x106], [0x108, 0x109], [0x109, 0x108], [0x10A, 0x10B], [0x10B, 0x10A], [0x10C, 0x10D], [0x10D, 0x10C], [0x10E, 0x10F], [0x10F, 0x10E], [0x110, 0x111], [0x111, 0x110], [0x112, 0x113], [0x113, 0x112], [0x114, 0x115], [0x115, 0x114], [0x116, 0x117], [0x117, 0x116], [0x118, 0x119], [0x119, 0x118], [0x11A, 0x11B], [0x11B, 0x11A], [0x11C, 0x11D], [0x11D, 0x11C], [0x11E, 0x11F], [0x11F, 0x11E], [0x120, 0x121], [0x121, 0x120], [0x122, 0x123], [0x123, 0x122], [0x124, 0x125], [0x125, 0x124], [0x126, 0x127], [0x127, 0x126], [0x128, 0x129], [0x129, 0x128], [0x12A, 0x12B], [0x12B, 0x12A], [0x12C, 0x12D], [0x12D, 0x12C], [0x12E, 0x12F], [0x12F, 0x12E], [0x132, 0x133], [0x133, 0x132], [0x134, 0x135], [0x135, 0x134], [0x136, 0x137], [0x137, 0x136], [0x139, 0x13A], [0x13A, 0x139], [0x13B, 0x13C], [0x13C, 0x13B], [0x13D, 0x13E], [0x13E, 0x13D], [0x13F, 0x140], [0x140, 0x13F], [0x141, 0x142], [0x142, 0x141], [0x143, 0x144], [0x144, 0x143], [0x145, 0x146], [0x146, 0x145], [0x147, 0x148], [0x148, 0x147], [0x14A, 0x14B], [0x14B, 0x14A], [0x14C, 0x14D], [0x14D, 0x14C], [0x14E, 0x14F], [0x14F, 0x14E], [0x150, 0x151], [0x151, 0x150], [0x152, 0x153], [0x153, 0x152], [0x154, 0x155], [0x155, 0x154], [0x156, 0x157], [0x157, 0x156], [0x158, 0x159], [0x159, 0x158], [0x15A, 0x15B], [0x15B, 0x15A], [0x15C, 0x15D], [0x15D, 0x15C], [0x15E, 0x15F], [0x15F, 0x15E], [0x160, 0x161], [0x161, 0x160], [0x162, 0x163], [0x163, 0x162], [0x164, 0x165], [0x165, 0x164], [0x166, 0x167], [0x167, 0x166], [0x168, 0x169], [0x169, 0x168], [0x16A, 0x16B], [0x16B, 0x16A], [0x16C, 0x16D], [0x16D, 0x16C], [0x16E, 0x16F], [0x16F, 0x16E], [0x170, 0x171], [0x171, 0x170], [0x172, 0x173], [0x173, 0x172], [0x174, 0x175], [0x175, 0x174], [0x176, 0x177], [0x177, 0x176], [0x178, 0xFF], [0x179, 0x17A], [0x17A, 0x179], [0x17B, 0x17C], [0x17C, 0x17B], [0x17D, 0x17E], [0x17E, 0x17D], [0x180, 0x243], [0x181, 0x253], [0x182, 0x183], [0x183, 0x182], [0x184, 0x185], [0x185, 0x184], [0x186, 0x254], [0x187, 0x188], [0x188, 0x187], [0x189, 0x256], [0x18A, 0x257], [0x18B, 0x18C], [0x18C, 0x18B], [0x18E, 0x1DD], [0x18F, 0x259], [0x190, 0x25B], [0x191, 0x192], [0x192, 0x191], [0x193, 0x260], [0x194, 0x263], [0x195, 0x1F6], [0x196, 0x269], [0x197, 0x268], [0x198, 0x199], [0x199, 0x198], [0x19A, 0x23D], [0x19B, 0xA7DC], [0x19C, 0x26F], [0x19D, 0x272], [0x19E, 0x220], [0x19F, 0x275], [0x1A0, 0x1A1], [0x1A1, 0x1A0], [0x1A2, 0x1A3], [0x1A3, 0x1A2], [0x1A4, 0x1A5], [0x1A5, 0x1A4], [0x1A6, 0x280], [0x1A7, 0x1A8], [0x1A8, 0x1A7], [0x1A9, 0x283], [0x1AC, 0x1AD], [0x1AD, 0x1AC], [0x1AE, 0x288], [0x1AF, 0x1B0], [0x1B0, 0x1AF], [0x1B1, 0x28A], [0x1B2, 0x28B], [0x1B3, 0x1B4], [0x1B4, 0x1B3], [0x1B5, 0x1B6], [0x1B6, 0x1B5], [0x1B7, 0x292], [0x1B8, 0x1B9], [0x1B9, 0x1B8], [0x1BC, 0x1BD], [0x1BD, 0x1BC], [0x1BF, 0x1F7], [0x1C4, 0x1C6], [0x1C5, 0x1C6], [0x1C6, [0x1C4, 0x1C5]], [0x1C7, 0x1C9], [0x1C8, 0x1C9], [0x1C9, [0x1C7, 0x1C8]], [0x1CA, 0x1CC], [0x1CB, 0x1CC], [0x1CC, [0x1CA, 0x1CB]], [0x1CD, 0x1CE], [0x1CE, 0x1CD], [0x1CF, 0x1D0], [0x1D0, 0x1CF], [0x1D1, 0x1D2], [0x1D2, 0x1D1], [0x1D3, 0x1D4], [0x1D4, 0x1D3], [0x1D5, 0x1D6], [0x1D6, 0x1D5], [0x1D7, 0x1D8], [0x1D8, 0x1D7], [0x1D9, 0x1DA], [0x1DA, 0x1D9], [0x1DB, 0x1DC], [0x1DC, 0x1DB], [0x1DD, 0x18E], [0x1DE, 0x1DF], [0x1DF, 0x1DE], [0x1E0, 0x1E1], [0x1E1, 0x1E0], [0x1E2, 0x1E3], [0x1E3, 0x1E2], [0x1E4, 0x1E5], [0x1E5, 0x1E4], [0x1E6, 0x1E7], [0x1E7, 0x1E6], [0x1E8, 0x1E9], [0x1E9, 0x1E8], [0x1EA, 0x1EB], [0x1EB, 0x1EA], [0x1EC, 0x1ED], [0x1ED, 0x1EC], [0x1EE, 0x1EF], [0x1EF, 0x1EE], [0x1F1, 0x1F3], [0x1F2, 0x1F3], [0x1F3, [0x1F1, 0x1F2]], [0x1F4, 0x1F5], [0x1F5, 0x1F4], [0x1F6, 0x195], [0x1F7, 0x1BF], [0x1F8, 0x1F9], [0x1F9, 0x1F8], [0x1FA, 0x1FB], [0x1FB, 0x1FA], [0x1FC, 0x1FD], [0x1FD, 0x1FC], [0x1FE, 0x1FF], [0x1FF, 0x1FE], [0x200, 0x201], [0x201, 0x200], [0x202, 0x203], [0x203, 0x202], [0x204, 0x205], [0x205, 0x204], [0x206, 0x207], [0x207, 0x206], [0x208, 0x209], [0x209, 0x208], [0x20A, 0x20B], [0x20B, 0x20A], [0x20C, 0x20D], [0x20D, 0x20C], [0x20E, 0x20F], [0x20F, 0x20E], [0x210, 0x211], [0x211, 0x210], [0x212, 0x213], [0x213, 0x212], [0x214, 0x215], [0x215, 0x214], [0x216, 0x217], [0x217, 0x216], [0x218, 0x219], [0x219, 0x218], [0x21A, 0x21B], [0x21B, 0x21A], [0x21C, 0x21D], [0x21D, 0x21C], [0x21E, 0x21F], [0x21F, 0x21E], [0x220, 0x19E], [0x222, 0x223], [0x223, 0x222], [0x224, 0x225], [0x225, 0x224], [0x226, 0x227], [0x227, 0x226], [0x228, 0x229], [0x229, 0x228], [0x22A, 0x22B], [0x22B, 0x22A], [0x22C, 0x22D], [0x22D, 0x22C], [0x22E, 0x22F], [0x22F, 0x22E], [0x230, 0x231], [0x231, 0x230], [0x232, 0x233], [0x233, 0x232], [0x23A, 0x2C65], [0x23B, 0x23C], [0x23C, 0x23B], [0x23D, 0x19A], [0x23E, 0x2C66], [0x23F, 0x2C7E], [0x240, 0x2C7F], [0x241, 0x242], [0x242, 0x241], [0x243, 0x180], [0x244, 0x289], [0x245, 0x28C], [0x246, 0x247], [0x247, 0x246], [0x248, 0x249], [0x249, 0x248], [0x24A, 0x24B], [0x24B, 0x24A], [0x24C, 0x24D], [0x24D, 0x24C], [0x24E, 0x24F], [0x24F, 0x24E], [0x250, 0x2C6F], [0x251, 0x2C6D], [0x252, 0x2C70], [0x253, 0x181], [0x254, 0x186], [0x256, 0x189], [0x257, 0x18A], [0x259, 0x18F], [0x25B, 0x190], [0x25C, 0xA7AB], [0x260, 0x193], [0x261, 0xA7AC], [0x263, 0x194], [0x264, 0xA7CB], [0x265, 0xA78D], [0x266, 0xA7AA], [0x268, 0x197], [0x269, 0x196], [0x26A, 0xA7AE], [0x26B, 0x2C62], [0x26C, 0xA7AD], [0x26F, 0x19C], [0x271, 0x2C6E], [0x272, 0x19D], [0x275, 0x19F], [0x27D, 0x2C64], [0x280, 0x1A6], [0x282, 0xA7C5], [0x283, 0x1A9], [0x287, 0xA7B1], [0x288, 0x1AE], [0x289, 0x244], [0x28A, 0x1B1], [0x28B, 0x1B2], [0x28C, 0x245], [0x292, 0x1B7], [0x29D, 0xA7B2], [0x29E, 0xA7B0], [0x345, 0x3B9], [0x370, 0x371], [0x371, 0x370], [0x372, 0x373], [0x373, 0x372], [0x376, 0x377], [0x377, 0x376], [0x37B, 0x3FD], [0x37C, 0x3FE], [0x37D, 0x3FF], [0x37F, 0x3F3], [0x386, 0x3AC], [0x388, 0x3AD], [0x389, 0x3AE], [0x38A, 0x3AF], [0x38C, 0x3CC], [0x38E, 0x3CD], [0x38F, 0x3CE], [0x391, 0x3B1], [0x392, 0x3B2], [0x393, 0x3B3], [0x394, 0x3B4], [0x395, 0x3B5], [0x396, 0x3B6], [0x397, 0x3B7], [0x398, 0x3B8], [0x399, 0x3B9], [0x39A, 0x3BA], [0x39B, 0x3BB], [0x39C, 0x3BC], [0x39D, 0x3BD], [0x39E, 0x3BE], [0x39F, 0x3BF], [0x3A0, 0x3C0], [0x3A1, 0x3C1], [0x3A3, 0x3C3], [0x3A4, 0x3C4], [0x3A5, 0x3C5], [0x3A6, 0x3C6], [0x3A7, 0x3C7], [0x3A8, 0x3C8], [0x3A9, 0x3C9], [0x3AA, 0x3CA], [0x3AB, 0x3CB], [0x3AC, 0x386], [0x3AD, 0x388], [0x3AE, 0x389], [0x3AF, 0x38A], [0x3B1, 0x391], [0x3B2, [0x392, 0x3D0]], [0x3B3, 0x393], [0x3B4, 0x394], [0x3B5, [0x395, 0x3F5]], [0x3B6, 0x396], [0x3B7, 0x397], [0x3B8, [0x398, 0x3D1]], [0x3B9, [0x345, 0x399, 0x1FBE]], [0x3BA, [0x39A, 0x3F0]], [0x3BB, 0x39B], [0x3BC, [0xB5, 0x39C]], [0x3BD, 0x39D], [0x3BE, 0x39E], [0x3BF, 0x39F], [0x3C0, [0x3A0, 0x3D6]], [0x3C1, [0x3A1, 0x3F1]], [0x3C2, 0x3C3], [0x3C3, [0x3A3, 0x3C2]], [0x3C4, 0x3A4], [0x3C5, 0x3A5], [0x3C6, [0x3A6, 0x3D5]], [0x3C7, 0x3A7], [0x3C8, 0x3A8], [0x3C9, 0x3A9], [0x3CA, 0x3AA], [0x3CB, 0x3AB], [0x3CC, 0x38C], [0x3CD, 0x38E], [0x3CE, 0x38F], [0x3CF, 0x3D7], [0x3D0, 0x3B2], [0x3D1, 0x3B8], [0x3D5, 0x3C6], [0x3D6, 0x3C0], [0x3D7, 0x3CF], [0x3D8, 0x3D9], [0x3D9, 0x3D8], [0x3DA, 0x3DB], [0x3DB, 0x3DA], [0x3DC, 0x3DD], [0x3DD, 0x3DC], [0x3DE, 0x3DF], [0x3DF, 0x3DE], [0x3E0, 0x3E1], [0x3E1, 0x3E0], [0x3E2, 0x3E3], [0x3E3, 0x3E2], [0x3E4, 0x3E5], [0x3E5, 0x3E4], [0x3E6, 0x3E7], [0x3E7, 0x3E6], [0x3E8, 0x3E9], [0x3E9, 0x3E8], [0x3EA, 0x3EB], [0x3EB, 0x3EA], [0x3EC, 0x3ED], [0x3ED, 0x3EC], [0x3EE, 0x3EF], [0x3EF, 0x3EE], [0x3F0, 0x3BA], [0x3F1, 0x3C1], [0x3F2, 0x3F9], [0x3F3, 0x37F], [0x3F5, 0x3B5], [0x3F7, 0x3F8], [0x3F8, 0x3F7], [0x3F9, 0x3F2], [0x3FA, 0x3FB], [0x3FB, 0x3FA], [0x3FD, 0x37B], [0x3FE, 0x37C], [0x3FF, 0x37D], [0x400, 0x450], [0x401, 0x451], [0x402, 0x452], [0x403, 0x453], [0x404, 0x454], [0x405, 0x455], [0x406, 0x456], [0x407, 0x457], [0x408, 0x458], [0x409, 0x459], [0x40A, 0x45A], [0x40B, 0x45B], [0x40C, 0x45C], [0x40D, 0x45D], [0x40E, 0x45E], [0x40F, 0x45F], [0x410, 0x430], [0x411, 0x431], [0x412, 0x432], [0x413, 0x433], [0x414, 0x434], [0x415, 0x435], [0x416, 0x436], [0x417, 0x437], [0x418, 0x438], [0x419, 0x439], [0x41A, 0x43A], [0x41B, 0x43B], [0x41C, 0x43C], [0x41D, 0x43D], [0x41E, 0x43E], [0x41F, 0x43F], [0x420, 0x440], [0x421, 0x441], [0x422, 0x442], [0x423, 0x443], [0x424, 0x444], [0x425, 0x445], [0x426, 0x446], [0x427, 0x447], [0x428, 0x448], [0x429, 0x449], [0x42A, 0x44A], [0x42B, 0x44B], [0x42C, 0x44C], [0x42D, 0x44D], [0x42E, 0x44E], [0x42F, 0x44F], [0x430, 0x410], [0x431, 0x411], [0x432, [0x412, 0x1C80]], [0x433, 0x413], [0x434, [0x414, 0x1C81]], [0x435, 0x415], [0x436, 0x416], [0x437, 0x417], [0x438, 0x418], [0x439, 0x419], [0x43A, 0x41A], [0x43B, 0x41B], [0x43C, 0x41C], [0x43D, 0x41D], [0x43E, [0x41E, 0x1C82]], [0x43F, 0x41F], [0x440, 0x420], [0x441, [0x421, 0x1C83]], [0x442, [0x422, 0x1C84, 0x1C85]], [0x443, 0x423], [0x444, 0x424], [0x445, 0x425], [0x446, 0x426], [0x447, 0x427], [0x448, 0x428], [0x449, 0x429], [0x44A, [0x42A, 0x1C86]], [0x44B, 0x42B], [0x44C, 0x42C], [0x44D, 0x42D], [0x44E, 0x42E], [0x44F, 0x42F], [0x450, 0x400], [0x451, 0x401], [0x452, 0x402], [0x453, 0x403], [0x454, 0x404], [0x455, 0x405], [0x456, 0x406], [0x457, 0x407], [0x458, 0x408], [0x459, 0x409], [0x45A, 0x40A], [0x45B, 0x40B], [0x45C, 0x40C], [0x45D, 0x40D], [0x45E, 0x40E], [0x45F, 0x40F], [0x460, 0x461], [0x461, 0x460], [0x462, 0x463], [0x463, [0x462, 0x1C87]], [0x464, 0x465], [0x465, 0x464], [0x466, 0x467], [0x467, 0x466], [0x468, 0x469], [0x469, 0x468], [0x46A, 0x46B], [0x46B, 0x46A], [0x46C, 0x46D], [0x46D, 0x46C], [0x46E, 0x46F], [0x46F, 0x46E], [0x470, 0x471], [0x471, 0x470], [0x472, 0x473], [0x473, 0x472], [0x474, 0x475], [0x475, 0x474], [0x476, 0x477], [0x477, 0x476], [0x478, 0x479], [0x479, 0x478], [0x47A, 0x47B], [0x47B, 0x47A], [0x47C, 0x47D], [0x47D, 0x47C], [0x47E, 0x47F], [0x47F, 0x47E], [0x480, 0x481], [0x481, 0x480], [0x48A, 0x48B], [0x48B, 0x48A], [0x48C, 0x48D], [0x48D, 0x48C], [0x48E, 0x48F], [0x48F, 0x48E], [0x490, 0x491], [0x491, 0x490], [0x492, 0x493], [0x493, 0x492], [0x494, 0x495], [0x495, 0x494], [0x496, 0x497], [0x497, 0x496], [0x498, 0x499], [0x499, 0x498], [0x49A, 0x49B], [0x49B, 0x49A], [0x49C, 0x49D], [0x49D, 0x49C], [0x49E, 0x49F], [0x49F, 0x49E], [0x4A0, 0x4A1], [0x4A1, 0x4A0], [0x4A2, 0x4A3], [0x4A3, 0x4A2], [0x4A4, 0x4A5], [0x4A5, 0x4A4], [0x4A6, 0x4A7], [0x4A7, 0x4A6], [0x4A8, 0x4A9], [0x4A9, 0x4A8], [0x4AA, 0x4AB], [0x4AB, 0x4AA], [0x4AC, 0x4AD], [0x4AD, 0x4AC], [0x4AE, 0x4AF], [0x4AF, 0x4AE], [0x4B0, 0x4B1], [0x4B1, 0x4B0], [0x4B2, 0x4B3], [0x4B3, 0x4B2], [0x4B4, 0x4B5], [0x4B5, 0x4B4], [0x4B6, 0x4B7], [0x4B7, 0x4B6], [0x4B8, 0x4B9], [0x4B9, 0x4B8], [0x4BA, 0x4BB], [0x4BB, 0x4BA], [0x4BC, 0x4BD], [0x4BD, 0x4BC], [0x4BE, 0x4BF], [0x4BF, 0x4BE], [0x4C0, 0x4CF], [0x4C1, 0x4C2], [0x4C2, 0x4C1], [0x4C3, 0x4C4], [0x4C4, 0x4C3], [0x4C5, 0x4C6], [0x4C6, 0x4C5], [0x4C7, 0x4C8], [0x4C8, 0x4C7], [0x4C9, 0x4CA], [0x4CA, 0x4C9], [0x4CB, 0x4CC], [0x4CC, 0x4CB], [0x4CD, 0x4CE], [0x4CE, 0x4CD], [0x4CF, 0x4C0], [0x4D0, 0x4D1], [0x4D1, 0x4D0], [0x4D2, 0x4D3], [0x4D3, 0x4D2], [0x4D4, 0x4D5], [0x4D5, 0x4D4], [0x4D6, 0x4D7], [0x4D7, 0x4D6], [0x4D8, 0x4D9], [0x4D9, 0x4D8], [0x4DA, 0x4DB], [0x4DB, 0x4DA], [0x4DC, 0x4DD], [0x4DD, 0x4DC], [0x4DE, 0x4DF], [0x4DF, 0x4DE], [0x4E0, 0x4E1], [0x4E1, 0x4E0], [0x4E2, 0x4E3], [0x4E3, 0x4E2], [0x4E4, 0x4E5], [0x4E5, 0x4E4], [0x4E6, 0x4E7], [0x4E7, 0x4E6], [0x4E8, 0x4E9], [0x4E9, 0x4E8], [0x4EA, 0x4EB], [0x4EB, 0x4EA], [0x4EC, 0x4ED], [0x4ED, 0x4EC], [0x4EE, 0x4EF], [0x4EF, 0x4EE], [0x4F0, 0x4F1], [0x4F1, 0x4F0], [0x4F2, 0x4F3], [0x4F3, 0x4F2], [0x4F4, 0x4F5], [0x4F5, 0x4F4], [0x4F6, 0x4F7], [0x4F7, 0x4F6], [0x4F8, 0x4F9], [0x4F9, 0x4F8], [0x4FA, 0x4FB], [0x4FB, 0x4FA], [0x4FC, 0x4FD], [0x4FD, 0x4FC], [0x4FE, 0x4FF], [0x4FF, 0x4FE], [0x500, 0x501], [0x501, 0x500], [0x502, 0x503], [0x503, 0x502], [0x504, 0x505], [0x505, 0x504], [0x506, 0x507], [0x507, 0x506], [0x508, 0x509], [0x509, 0x508], [0x50A, 0x50B], [0x50B, 0x50A], [0x50C, 0x50D], [0x50D, 0x50C], [0x50E, 0x50F], [0x50F, 0x50E], [0x510, 0x511], [0x511, 0x510], [0x512, 0x513], [0x513, 0x512], [0x514, 0x515], [0x515, 0x514], [0x516, 0x517], [0x517, 0x516], [0x518, 0x519], [0x519, 0x518], [0x51A, 0x51B], [0x51B, 0x51A], [0x51C, 0x51D], [0x51D, 0x51C], [0x51E, 0x51F], [0x51F, 0x51E], [0x520, 0x521], [0x521, 0x520], [0x522, 0x523], [0x523, 0x522], [0x524, 0x525], [0x525, 0x524], [0x526, 0x527], [0x527, 0x526], [0x528, 0x529], [0x529, 0x528], [0x52A, 0x52B], [0x52B, 0x52A], [0x52C, 0x52D], [0x52D, 0x52C], [0x52E, 0x52F], [0x52F, 0x52E], [0x531, 0x561], [0x532, 0x562], [0x533, 0x563], [0x534, 0x564], [0x535, 0x565], [0x536, 0x566], [0x537, 0x567], [0x538, 0x568], [0x539, 0x569], [0x53A, 0x56A], [0x53B, 0x56B], [0x53C, 0x56C], [0x53D, 0x56D], [0x53E, 0x56E], [0x53F, 0x56F], [0x540, 0x570], [0x541, 0x571], [0x542, 0x572], [0x543, 0x573], [0x544, 0x574], [0x545, 0x575], [0x546, 0x576], [0x547, 0x577], [0x548, 0x578], [0x549, 0x579], [0x54A, 0x57A], [0x54B, 0x57B], [0x54C, 0x57C], [0x54D, 0x57D], [0x54E, 0x57E], [0x54F, 0x57F], [0x550, 0x580], [0x551, 0x581], [0x552, 0x582], [0x553, 0x583], [0x554, 0x584], [0x555, 0x585], [0x556, 0x586], [0x561, 0x531], [0x562, 0x532], [0x563, 0x533], [0x564, 0x534], [0x565, 0x535], [0x566, 0x536], [0x567, 0x537], [0x568, 0x538], [0x569, 0x539], [0x56A, 0x53A], [0x56B, 0x53B], [0x56C, 0x53C], [0x56D, 0x53D], [0x56E, 0x53E], [0x56F, 0x53F], [0x570, 0x540], [0x571, 0x541], [0x572, 0x542], [0x573, 0x543], [0x574, 0x544], [0x575, 0x545], [0x576, 0x546], [0x577, 0x547], [0x578, 0x548], [0x579, 0x549], [0x57A, 0x54A], [0x57B, 0x54B], [0x57C, 0x54C], [0x57D, 0x54D], [0x57E, 0x54E], [0x57F, 0x54F], [0x580, 0x550], [0x581, 0x551], [0x582, 0x552], [0x583, 0x553], [0x584, 0x554], [0x585, 0x555], [0x586, 0x556], [0x10A0, 0x2D00], [0x10A1, 0x2D01], [0x10A2, 0x2D02], [0x10A3, 0x2D03], [0x10A4, 0x2D04], [0x10A5, 0x2D05], [0x10A6, 0x2D06], [0x10A7, 0x2D07], [0x10A8, 0x2D08], [0x10A9, 0x2D09], [0x10AA, 0x2D0A], [0x10AB, 0x2D0B], [0x10AC, 0x2D0C], [0x10AD, 0x2D0D], [0x10AE, 0x2D0E], [0x10AF, 0x2D0F], [0x10B0, 0x2D10], [0x10B1, 0x2D11], [0x10B2, 0x2D12], [0x10B3, 0x2D13], [0x10B4, 0x2D14], [0x10B5, 0x2D15], [0x10B6, 0x2D16], [0x10B7, 0x2D17], [0x10B8, 0x2D18], [0x10B9, 0x2D19], [0x10BA, 0x2D1A], [0x10BB, 0x2D1B], [0x10BC, 0x2D1C], [0x10BD, 0x2D1D], [0x10BE, 0x2D1E], [0x10BF, 0x2D1F], [0x10C0, 0x2D20], [0x10C1, 0x2D21], [0x10C2, 0x2D22], [0x10C3, 0x2D23], [0x10C4, 0x2D24], [0x10C5, 0x2D25], [0x10C7, 0x2D27], [0x10CD, 0x2D2D], [0x10D0, 0x1C90], [0x10D1, 0x1C91], [0x10D2, 0x1C92], [0x10D3, 0x1C93], [0x10D4, 0x1C94], [0x10D5, 0x1C95], [0x10D6, 0x1C96], [0x10D7, 0x1C97], [0x10D8, 0x1C98], [0x10D9, 0x1C99], [0x10DA, 0x1C9A], [0x10DB, 0x1C9B], [0x10DC, 0x1C9C], [0x10DD, 0x1C9D], [0x10DE, 0x1C9E], [0x10DF, 0x1C9F], [0x10E0, 0x1CA0], [0x10E1, 0x1CA1], [0x10E2, 0x1CA2], [0x10E3, 0x1CA3], [0x10E4, 0x1CA4], [0x10E5, 0x1CA5], [0x10E6, 0x1CA6], [0x10E7, 0x1CA7], [0x10E8, 0x1CA8], [0x10E9, 0x1CA9], [0x10EA, 0x1CAA], [0x10EB, 0x1CAB], [0x10EC, 0x1CAC], [0x10ED, 0x1CAD], [0x10EE, 0x1CAE], [0x10EF, 0x1CAF], [0x10F0, 0x1CB0], [0x10F1, 0x1CB1], [0x10F2, 0x1CB2], [0x10F3, 0x1CB3], [0x10F4, 0x1CB4], [0x10F5, 0x1CB5], [0x10F6, 0x1CB6], [0x10F7, 0x1CB7], [0x10F8, 0x1CB8], [0x10F9, 0x1CB9], [0x10FA, 0x1CBA], [0x10FD, 0x1CBD], [0x10FE, 0x1CBE], [0x10FF, 0x1CBF], [0x13A0, 0xAB70], [0x13A1, 0xAB71], [0x13A2, 0xAB72], [0x13A3, 0xAB73], [0x13A4, 0xAB74], [0x13A5, 0xAB75], [0x13A6, 0xAB76], [0x13A7, 0xAB77], [0x13A8, 0xAB78], [0x13A9, 0xAB79], [0x13AA, 0xAB7A], [0x13AB, 0xAB7B], [0x13AC, 0xAB7C], [0x13AD, 0xAB7D], [0x13AE, 0xAB7E], [0x13AF, 0xAB7F], [0x13B0, 0xAB80], [0x13B1, 0xAB81], [0x13B2, 0xAB82], [0x13B3, 0xAB83], [0x13B4, 0xAB84], [0x13B5, 0xAB85], [0x13B6, 0xAB86], [0x13B7, 0xAB87], [0x13B8, 0xAB88], [0x13B9, 0xAB89], [0x13BA, 0xAB8A], [0x13BB, 0xAB8B], [0x13BC, 0xAB8C], [0x13BD, 0xAB8D], [0x13BE, 0xAB8E], [0x13BF, 0xAB8F], [0x13C0, 0xAB90], [0x13C1, 0xAB91], [0x13C2, 0xAB92], [0x13C3, 0xAB93], [0x13C4, 0xAB94], [0x13C5, 0xAB95], [0x13C6, 0xAB96], [0x13C7, 0xAB97], [0x13C8, 0xAB98], [0x13C9, 0xAB99], [0x13CA, 0xAB9A], [0x13CB, 0xAB9B], [0x13CC, 0xAB9C], [0x13CD, 0xAB9D], [0x13CE, 0xAB9E], [0x13CF, 0xAB9F], [0x13D0, 0xABA0], [0x13D1, 0xABA1], [0x13D2, 0xABA2], [0x13D3, 0xABA3], [0x13D4, 0xABA4], [0x13D5, 0xABA5], [0x13D6, 0xABA6], [0x13D7, 0xABA7], [0x13D8, 0xABA8], [0x13D9, 0xABA9], [0x13DA, 0xABAA], [0x13DB, 0xABAB], [0x13DC, 0xABAC], [0x13DD, 0xABAD], [0x13DE, 0xABAE], [0x13DF, 0xABAF], [0x13E0, 0xABB0], [0x13E1, 0xABB1], [0x13E2, 0xABB2], [0x13E3, 0xABB3], [0x13E4, 0xABB4], [0x13E5, 0xABB5], [0x13E6, 0xABB6], [0x13E7, 0xABB7], [0x13E8, 0xABB8], [0x13E9, 0xABB9], [0x13EA, 0xABBA], [0x13EB, 0xABBB], [0x13EC, 0xABBC], [0x13ED, 0xABBD], [0x13EE, 0xABBE], [0x13EF, 0xABBF], [0x13F0, 0x13F8], [0x13F1, 0x13F9], [0x13F2, 0x13FA], [0x13F3, 0x13FB], [0x13F4, 0x13FC], [0x13F5, 0x13FD], [0x13F8, 0x13F0], [0x13F9, 0x13F1], [0x13FA, 0x13F2], [0x13FB, 0x13F3], [0x13FC, 0x13F4], [0x13FD, 0x13F5], [0x1C80, 0x432], [0x1C81, 0x434], [0x1C82, 0x43E], [0x1C83, 0x441], [0x1C84, 0x442], [0x1C85, 0x442], [0x1C86, 0x44A], [0x1C87, 0x463], [0x1C88, 0xA64B], [0x1C89, 0x1C8A], [0x1C8A, 0x1C89], [0x1C90, 0x10D0], [0x1C91, 0x10D1], [0x1C92, 0x10D2], [0x1C93, 0x10D3], [0x1C94, 0x10D4], [0x1C95, 0x10D5], [0x1C96, 0x10D6], [0x1C97, 0x10D7], [0x1C98, 0x10D8], [0x1C99, 0x10D9], [0x1C9A, 0x10DA], [0x1C9B, 0x10DB], [0x1C9C, 0x10DC], [0x1C9D, 0x10DD], [0x1C9E, 0x10DE], [0x1C9F, 0x10DF], [0x1CA0, 0x10E0], [0x1CA1, 0x10E1], [0x1CA2, 0x10E2], [0x1CA3, 0x10E3], [0x1CA4, 0x10E4], [0x1CA5, 0x10E5], [0x1CA6, 0x10E6], [0x1CA7, 0x10E7], [0x1CA8, 0x10E8], [0x1CA9, 0x10E9], [0x1CAA, 0x10EA], [0x1CAB, 0x10EB], [0x1CAC, 0x10EC], [0x1CAD, 0x10ED], [0x1CAE, 0x10EE], [0x1CAF, 0x10EF], [0x1CB0, 0x10F0], [0x1CB1, 0x10F1], [0x1CB2, 0x10F2], [0x1CB3, 0x10F3], [0x1CB4, 0x10F4], [0x1CB5, 0x10F5], [0x1CB6, 0x10F6], [0x1CB7, 0x10F7], [0x1CB8, 0x10F8], [0x1CB9, 0x10F9], [0x1CBA, 0x10FA], [0x1CBD, 0x10FD], [0x1CBE, 0x10FE], [0x1CBF, 0x10FF], [0x1D79, 0xA77D], [0x1D7D, 0x2C63], [0x1D8E, 0xA7C6], [0x1E00, 0x1E01], [0x1E01, 0x1E00], [0x1E02, 0x1E03], [0x1E03, 0x1E02], [0x1E04, 0x1E05], [0x1E05, 0x1E04], [0x1E06, 0x1E07], [0x1E07, 0x1E06], [0x1E08, 0x1E09], [0x1E09, 0x1E08], [0x1E0A, 0x1E0B], [0x1E0B, 0x1E0A], [0x1E0C, 0x1E0D], [0x1E0D, 0x1E0C], [0x1E0E, 0x1E0F], [0x1E0F, 0x1E0E], [0x1E10, 0x1E11], [0x1E11, 0x1E10], [0x1E12, 0x1E13], [0x1E13, 0x1E12], [0x1E14, 0x1E15], [0x1E15, 0x1E14], [0x1E16, 0x1E17], [0x1E17, 0x1E16], [0x1E18, 0x1E19], [0x1E19, 0x1E18], [0x1E1A, 0x1E1B], [0x1E1B, 0x1E1A], [0x1E1C, 0x1E1D], [0x1E1D, 0x1E1C], [0x1E1E, 0x1E1F], [0x1E1F, 0x1E1E], [0x1E20, 0x1E21], [0x1E21, 0x1E20], [0x1E22, 0x1E23], [0x1E23, 0x1E22], [0x1E24, 0x1E25], [0x1E25, 0x1E24], [0x1E26, 0x1E27], [0x1E27, 0x1E26], [0x1E28, 0x1E29], [0x1E29, 0x1E28], [0x1E2A, 0x1E2B], [0x1E2B, 0x1E2A], [0x1E2C, 0x1E2D], [0x1E2D, 0x1E2C], [0x1E2E, 0x1E2F], [0x1E2F, 0x1E2E], [0x1E30, 0x1E31], [0x1E31, 0x1E30], [0x1E32, 0x1E33], [0x1E33, 0x1E32], [0x1E34, 0x1E35], [0x1E35, 0x1E34], [0x1E36, 0x1E37], [0x1E37, 0x1E36], [0x1E38, 0x1E39], [0x1E39, 0x1E38], [0x1E3A, 0x1E3B], [0x1E3B, 0x1E3A], [0x1E3C, 0x1E3D], [0x1E3D, 0x1E3C], [0x1E3E, 0x1E3F], [0x1E3F, 0x1E3E], [0x1E40, 0x1E41], [0x1E41, 0x1E40], [0x1E42, 0x1E43], [0x1E43, 0x1E42], [0x1E44, 0x1E45], [0x1E45, 0x1E44], [0x1E46, 0x1E47], [0x1E47, 0x1E46], [0x1E48, 0x1E49], [0x1E49, 0x1E48], [0x1E4A, 0x1E4B], [0x1E4B, 0x1E4A], [0x1E4C, 0x1E4D], [0x1E4D, 0x1E4C], [0x1E4E, 0x1E4F], [0x1E4F, 0x1E4E], [0x1E50, 0x1E51], [0x1E51, 0x1E50], [0x1E52, 0x1E53], [0x1E53, 0x1E52], [0x1E54, 0x1E55], [0x1E55, 0x1E54], [0x1E56, 0x1E57], [0x1E57, 0x1E56], [0x1E58, 0x1E59], [0x1E59, 0x1E58], [0x1E5A, 0x1E5B], [0x1E5B, 0x1E5A], [0x1E5C, 0x1E5D], [0x1E5D, 0x1E5C], [0x1E5E, 0x1E5F], [0x1E5F, 0x1E5E], [0x1E60, 0x1E61], [0x1E61, [0x1E60, 0x1E9B]], [0x1E62, 0x1E63], [0x1E63, 0x1E62], [0x1E64, 0x1E65], [0x1E65, 0x1E64], [0x1E66, 0x1E67], [0x1E67, 0x1E66], [0x1E68, 0x1E69], [0x1E69, 0x1E68], [0x1E6A, 0x1E6B], [0x1E6B, 0x1E6A], [0x1E6C, 0x1E6D], [0x1E6D, 0x1E6C], [0x1E6E, 0x1E6F], [0x1E6F, 0x1E6E], [0x1E70, 0x1E71], [0x1E71, 0x1E70], [0x1E72, 0x1E73], [0x1E73, 0x1E72], [0x1E74, 0x1E75], [0x1E75, 0x1E74], [0x1E76, 0x1E77], [0x1E77, 0x1E76], [0x1E78, 0x1E79], [0x1E79, 0x1E78], [0x1E7A, 0x1E7B], [0x1E7B, 0x1E7A], [0x1E7C, 0x1E7D], [0x1E7D, 0x1E7C], [0x1E7E, 0x1E7F], [0x1E7F, 0x1E7E], [0x1E80, 0x1E81], [0x1E81, 0x1E80], [0x1E82, 0x1E83], [0x1E83, 0x1E82], [0x1E84, 0x1E85], [0x1E85, 0x1E84], [0x1E86, 0x1E87], [0x1E87, 0x1E86], [0x1E88, 0x1E89], [0x1E89, 0x1E88], [0x1E8A, 0x1E8B], [0x1E8B, 0x1E8A], [0x1E8C, 0x1E8D], [0x1E8D, 0x1E8C], [0x1E8E, 0x1E8F], [0x1E8F, 0x1E8E], [0x1E90, 0x1E91], [0x1E91, 0x1E90], [0x1E92, 0x1E93], [0x1E93, 0x1E92], [0x1E94, 0x1E95], [0x1E95, 0x1E94], [0x1E9B, 0x1E61], [0x1EA0, 0x1EA1], [0x1EA1, 0x1EA0], [0x1EA2, 0x1EA3], [0x1EA3, 0x1EA2], [0x1EA4, 0x1EA5], [0x1EA5, 0x1EA4], [0x1EA6, 0x1EA7], [0x1EA7, 0x1EA6], [0x1EA8, 0x1EA9], [0x1EA9, 0x1EA8], [0x1EAA, 0x1EAB], [0x1EAB, 0x1EAA], [0x1EAC, 0x1EAD], [0x1EAD, 0x1EAC], [0x1EAE, 0x1EAF], [0x1EAF, 0x1EAE], [0x1EB0, 0x1EB1], [0x1EB1, 0x1EB0], [0x1EB2, 0x1EB3], [0x1EB3, 0x1EB2], [0x1EB4, 0x1EB5], [0x1EB5, 0x1EB4], [0x1EB6, 0x1EB7], [0x1EB7, 0x1EB6], [0x1EB8, 0x1EB9], [0x1EB9, 0x1EB8], [0x1EBA, 0x1EBB], [0x1EBB, 0x1EBA], [0x1EBC, 0x1EBD], [0x1EBD, 0x1EBC], [0x1EBE, 0x1EBF], [0x1EBF, 0x1EBE], [0x1EC0, 0x1EC1], [0x1EC1, 0x1EC0], [0x1EC2, 0x1EC3], [0x1EC3, 0x1EC2], [0x1EC4, 0x1EC5], [0x1EC5, 0x1EC4], [0x1EC6, 0x1EC7], [0x1EC7, 0x1EC6], [0x1EC8, 0x1EC9], [0x1EC9, 0x1EC8], [0x1ECA, 0x1ECB], [0x1ECB, 0x1ECA], [0x1ECC, 0x1ECD], [0x1ECD, 0x1ECC], [0x1ECE, 0x1ECF], [0x1ECF, 0x1ECE], [0x1ED0, 0x1ED1], [0x1ED1, 0x1ED0], [0x1ED2, 0x1ED3], [0x1ED3, 0x1ED2], [0x1ED4, 0x1ED5], [0x1ED5, 0x1ED4], [0x1ED6, 0x1ED7], [0x1ED7, 0x1ED6], [0x1ED8, 0x1ED9], [0x1ED9, 0x1ED8], [0x1EDA, 0x1EDB], [0x1EDB, 0x1EDA], [0x1EDC, 0x1EDD], [0x1EDD, 0x1EDC], [0x1EDE, 0x1EDF], [0x1EDF, 0x1EDE], [0x1EE0, 0x1EE1], [0x1EE1, 0x1EE0], [0x1EE2, 0x1EE3], [0x1EE3, 0x1EE2], [0x1EE4, 0x1EE5], [0x1EE5, 0x1EE4], [0x1EE6, 0x1EE7], [0x1EE7, 0x1EE6], [0x1EE8, 0x1EE9], [0x1EE9, 0x1EE8], [0x1EEA, 0x1EEB], [0x1EEB, 0x1EEA], [0x1EEC, 0x1EED], [0x1EED, 0x1EEC], [0x1EEE, 0x1EEF], [0x1EEF, 0x1EEE], [0x1EF0, 0x1EF1], [0x1EF1, 0x1EF0], [0x1EF2, 0x1EF3], [0x1EF3, 0x1EF2], [0x1EF4, 0x1EF5], [0x1EF5, 0x1EF4], [0x1EF6, 0x1EF7], [0x1EF7, 0x1EF6], [0x1EF8, 0x1EF9], [0x1EF9, 0x1EF8], [0x1EFA, 0x1EFB], [0x1EFB, 0x1EFA], [0x1EFC, 0x1EFD], [0x1EFD, 0x1EFC], [0x1EFE, 0x1EFF], [0x1EFF, 0x1EFE], [0x1F00, 0x1F08], [0x1F01, 0x1F09], [0x1F02, 0x1F0A], [0x1F03, 0x1F0B], [0x1F04, 0x1F0C], [0x1F05, 0x1F0D], [0x1F06, 0x1F0E], [0x1F07, 0x1F0F], [0x1F08, 0x1F00], [0x1F09, 0x1F01], [0x1F0A, 0x1F02], [0x1F0B, 0x1F03], [0x1F0C, 0x1F04], [0x1F0D, 0x1F05], [0x1F0E, 0x1F06], [0x1F0F, 0x1F07], [0x1F10, 0x1F18], [0x1F11, 0x1F19], [0x1F12, 0x1F1A], [0x1F13, 0x1F1B], [0x1F14, 0x1F1C], [0x1F15, 0x1F1D], [0x1F18, 0x1F10], [0x1F19, 0x1F11], [0x1F1A, 0x1F12], [0x1F1B, 0x1F13], [0x1F1C, 0x1F14], [0x1F1D, 0x1F15], [0x1F20, 0x1F28], [0x1F21, 0x1F29], [0x1F22, 0x1F2A], [0x1F23, 0x1F2B], [0x1F24, 0x1F2C], [0x1F25, 0x1F2D], [0x1F26, 0x1F2E], [0x1F27, 0x1F2F], [0x1F28, 0x1F20], [0x1F29, 0x1F21], [0x1F2A, 0x1F22], [0x1F2B, 0x1F23], [0x1F2C, 0x1F24], [0x1F2D, 0x1F25], [0x1F2E, 0x1F26], [0x1F2F, 0x1F27], [0x1F30, 0x1F38], [0x1F31, 0x1F39], [0x1F32, 0x1F3A], [0x1F33, 0x1F3B], [0x1F34, 0x1F3C], [0x1F35, 0x1F3D], [0x1F36, 0x1F3E], [0x1F37, 0x1F3F], [0x1F38, 0x1F30], [0x1F39, 0x1F31], [0x1F3A, 0x1F32], [0x1F3B, 0x1F33], [0x1F3C, 0x1F34], [0x1F3D, 0x1F35], [0x1F3E, 0x1F36], [0x1F3F, 0x1F37], [0x1F40, 0x1F48], [0x1F41, 0x1F49], [0x1F42, 0x1F4A], [0x1F43, 0x1F4B], [0x1F44, 0x1F4C], [0x1F45, 0x1F4D], [0x1F48, 0x1F40], [0x1F49, 0x1F41], [0x1F4A, 0x1F42], [0x1F4B, 0x1F43], [0x1F4C, 0x1F44], [0x1F4D, 0x1F45], [0x1F51, 0x1F59], [0x1F53, 0x1F5B], [0x1F55, 0x1F5D], [0x1F57, 0x1F5F], [0x1F59, 0x1F51], [0x1F5B, 0x1F53], [0x1F5D, 0x1F55], [0x1F5F, 0x1F57], [0x1F60, 0x1F68], [0x1F61, 0x1F69], [0x1F62, 0x1F6A], [0x1F63, 0x1F6B], [0x1F64, 0x1F6C], [0x1F65, 0x1F6D], [0x1F66, 0x1F6E], [0x1F67, 0x1F6F], [0x1F68, 0x1F60], [0x1F69, 0x1F61], [0x1F6A, 0x1F62], [0x1F6B, 0x1F63], [0x1F6C, 0x1F64], [0x1F6D, 0x1F65], [0x1F6E, 0x1F66], [0x1F6F, 0x1F67], [0x1F70, 0x1FBA], [0x1F71, 0x1FBB], [0x1F72, 0x1FC8], [0x1F73, 0x1FC9], [0x1F74, 0x1FCA], [0x1F75, 0x1FCB], [0x1F76, 0x1FDA], [0x1F77, 0x1FDB], [0x1F78, 0x1FF8], [0x1F79, 0x1FF9], [0x1F7A, 0x1FEA], [0x1F7B, 0x1FEB], [0x1F7C, 0x1FFA], [0x1F7D, 0x1FFB], [0x1FB0, 0x1FB8], [0x1FB1, 0x1FB9], [0x1FB8, 0x1FB0], [0x1FB9, 0x1FB1], [0x1FBA, 0x1F70], [0x1FBB, 0x1F71], [0x1FBE, 0x3B9], [0x1FC8, 0x1F72], [0x1FC9, 0x1F73], [0x1FCA, 0x1F74], [0x1FCB, 0x1F75], [0x1FD0, 0x1FD8], [0x1FD1, 0x1FD9], [0x1FD8, 0x1FD0], [0x1FD9, 0x1FD1], [0x1FDA, 0x1F76], [0x1FDB, 0x1F77], [0x1FE0, 0x1FE8], [0x1FE1, 0x1FE9], [0x1FE5, 0x1FEC], [0x1FE8, 0x1FE0], [0x1FE9, 0x1FE1], [0x1FEA, 0x1F7A], [0x1FEB, 0x1F7B], [0x1FEC, 0x1FE5], [0x1FF8, 0x1F78], [0x1FF9, 0x1F79], [0x1FFA, 0x1F7C], [0x1FFB, 0x1F7D], [0x2132, 0x214E], [0x214E, 0x2132], [0x2160, 0x2170], [0x2161, 0x2171], [0x2162, 0x2172], [0x2163, 0x2173], [0x2164, 0x2174], [0x2165, 0x2175], [0x2166, 0x2176], [0x2167, 0x2177], [0x2168, 0x2178], [0x2169, 0x2179], [0x216A, 0x217A], [0x216B, 0x217B], [0x216C, 0x217C], [0x216D, 0x217D], [0x216E, 0x217E], [0x216F, 0x217F], [0x2170, 0x2160], [0x2171, 0x2161], [0x2172, 0x2162], [0x2173, 0x2163], [0x2174, 0x2164], [0x2175, 0x2165], [0x2176, 0x2166], [0x2177, 0x2167], [0x2178, 0x2168], [0x2179, 0x2169], [0x217A, 0x216A], [0x217B, 0x216B], [0x217C, 0x216C], [0x217D, 0x216D], [0x217E, 0x216E], [0x217F, 0x216F], [0x2183, 0x2184], [0x2184, 0x2183], [0x24B6, 0x24D0], [0x24B7, 0x24D1], [0x24B8, 0x24D2], [0x24B9, 0x24D3], [0x24BA, 0x24D4], [0x24BB, 0x24D5], [0x24BC, 0x24D6], [0x24BD, 0x24D7], [0x24BE, 0x24D8], [0x24BF, 0x24D9], [0x24C0, 0x24DA], [0x24C1, 0x24DB], [0x24C2, 0x24DC], [0x24C3, 0x24DD], [0x24C4, 0x24DE], [0x24C5, 0x24DF], [0x24C6, 0x24E0], [0x24C7, 0x24E1], [0x24C8, 0x24E2], [0x24C9, 0x24E3], [0x24CA, 0x24E4], [0x24CB, 0x24E5], [0x24CC, 0x24E6], [0x24CD, 0x24E7], [0x24CE, 0x24E8], [0x24CF, 0x24E9], [0x24D0, 0x24B6], [0x24D1, 0x24B7], [0x24D2, 0x24B8], [0x24D3, 0x24B9], [0x24D4, 0x24BA], [0x24D5, 0x24BB], [0x24D6, 0x24BC], [0x24D7, 0x24BD], [0x24D8, 0x24BE], [0x24D9, 0x24BF], [0x24DA, 0x24C0], [0x24DB, 0x24C1], [0x24DC, 0x24C2], [0x24DD, 0x24C3], [0x24DE, 0x24C4], [0x24DF, 0x24C5], [0x24E0, 0x24C6], [0x24E1, 0x24C7], [0x24E2, 0x24C8], [0x24E3, 0x24C9], [0x24E4, 0x24CA], [0x24E5, 0x24CB], [0x24E6, 0x24CC], [0x24E7, 0x24CD], [0x24E8, 0x24CE], [0x24E9, 0x24CF], [0x2C00, 0x2C30], [0x2C01, 0x2C31], [0x2C02, 0x2C32], [0x2C03, 0x2C33], [0x2C04, 0x2C34], [0x2C05, 0x2C35], [0x2C06, 0x2C36], [0x2C07, 0x2C37], [0x2C08, 0x2C38], [0x2C09, 0x2C39], [0x2C0A, 0x2C3A], [0x2C0B, 0x2C3B], [0x2C0C, 0x2C3C], [0x2C0D, 0x2C3D], [0x2C0E, 0x2C3E], [0x2C0F, 0x2C3F], [0x2C10, 0x2C40], [0x2C11, 0x2C41], [0x2C12, 0x2C42], [0x2C13, 0x2C43], [0x2C14, 0x2C44], [0x2C15, 0x2C45], [0x2C16, 0x2C46], [0x2C17, 0x2C47], [0x2C18, 0x2C48], [0x2C19, 0x2C49], [0x2C1A, 0x2C4A], [0x2C1B, 0x2C4B], [0x2C1C, 0x2C4C], [0x2C1D, 0x2C4D], [0x2C1E, 0x2C4E], [0x2C1F, 0x2C4F], [0x2C20, 0x2C50], [0x2C21, 0x2C51], [0x2C22, 0x2C52], [0x2C23, 0x2C53], [0x2C24, 0x2C54], [0x2C25, 0x2C55], [0x2C26, 0x2C56], [0x2C27, 0x2C57], [0x2C28, 0x2C58], [0x2C29, 0x2C59], [0x2C2A, 0x2C5A], [0x2C2B, 0x2C5B], [0x2C2C, 0x2C5C], [0x2C2D, 0x2C5D], [0x2C2E, 0x2C5E], [0x2C2F, 0x2C5F], [0x2C30, 0x2C00], [0x2C31, 0x2C01], [0x2C32, 0x2C02], [0x2C33, 0x2C03], [0x2C34, 0x2C04], [0x2C35, 0x2C05], [0x2C36, 0x2C06], [0x2C37, 0x2C07], [0x2C38, 0x2C08], [0x2C39, 0x2C09], [0x2C3A, 0x2C0A], [0x2C3B, 0x2C0B], [0x2C3C, 0x2C0C], [0x2C3D, 0x2C0D], [0x2C3E, 0x2C0E], [0x2C3F, 0x2C0F], [0x2C40, 0x2C10], [0x2C41, 0x2C11], [0x2C42, 0x2C12], [0x2C43, 0x2C13], [0x2C44, 0x2C14], [0x2C45, 0x2C15], [0x2C46, 0x2C16], [0x2C47, 0x2C17], [0x2C48, 0x2C18], [0x2C49, 0x2C19], [0x2C4A, 0x2C1A], [0x2C4B, 0x2C1B], [0x2C4C, 0x2C1C], [0x2C4D, 0x2C1D], [0x2C4E, 0x2C1E], [0x2C4F, 0x2C1F], [0x2C50, 0x2C20], [0x2C51, 0x2C21], [0x2C52, 0x2C22], [0x2C53, 0x2C23], [0x2C54, 0x2C24], [0x2C55, 0x2C25], [0x2C56, 0x2C26], [0x2C57, 0x2C27], [0x2C58, 0x2C28], [0x2C59, 0x2C29], [0x2C5A, 0x2C2A], [0x2C5B, 0x2C2B], [0x2C5C, 0x2C2C], [0x2C5D, 0x2C2D], [0x2C5E, 0x2C2E], [0x2C5F, 0x2C2F], [0x2C60, 0x2C61], [0x2C61, 0x2C60], [0x2C62, 0x26B], [0x2C63, 0x1D7D], [0x2C64, 0x27D], [0x2C65, 0x23A], [0x2C66, 0x23E], [0x2C67, 0x2C68], [0x2C68, 0x2C67], [0x2C69, 0x2C6A], [0x2C6A, 0x2C69], [0x2C6B, 0x2C6C], [0x2C6C, 0x2C6B], [0x2C6D, 0x251], [0x2C6E, 0x271], [0x2C6F, 0x250], [0x2C70, 0x252], [0x2C72, 0x2C73], [0x2C73, 0x2C72], [0x2C75, 0x2C76], [0x2C76, 0x2C75], [0x2C7E, 0x23F], [0x2C7F, 0x240], [0x2C80, 0x2C81], [0x2C81, 0x2C80], [0x2C82, 0x2C83], [0x2C83, 0x2C82], [0x2C84, 0x2C85], [0x2C85, 0x2C84], [0x2C86, 0x2C87], [0x2C87, 0x2C86], [0x2C88, 0x2C89], [0x2C89, 0x2C88], [0x2C8A, 0x2C8B], [0x2C8B, 0x2C8A], [0x2C8C, 0x2C8D], [0x2C8D, 0x2C8C], [0x2C8E, 0x2C8F], [0x2C8F, 0x2C8E], [0x2C90, 0x2C91], [0x2C91, 0x2C90], [0x2C92, 0x2C93], [0x2C93, 0x2C92], [0x2C94, 0x2C95], [0x2C95, 0x2C94], [0x2C96, 0x2C97], [0x2C97, 0x2C96], [0x2C98, 0x2C99], [0x2C99, 0x2C98], [0x2C9A, 0x2C9B], [0x2C9B, 0x2C9A], [0x2C9C, 0x2C9D], [0x2C9D, 0x2C9C], [0x2C9E, 0x2C9F], [0x2C9F, 0x2C9E], [0x2CA0, 0x2CA1], [0x2CA1, 0x2CA0], [0x2CA2, 0x2CA3], [0x2CA3, 0x2CA2], [0x2CA4, 0x2CA5], [0x2CA5, 0x2CA4], [0x2CA6, 0x2CA7], [0x2CA7, 0x2CA6], [0x2CA8, 0x2CA9], [0x2CA9, 0x2CA8], [0x2CAA, 0x2CAB], [0x2CAB, 0x2CAA], [0x2CAC, 0x2CAD], [0x2CAD, 0x2CAC], [0x2CAE, 0x2CAF], [0x2CAF, 0x2CAE], [0x2CB0, 0x2CB1], [0x2CB1, 0x2CB0], [0x2CB2, 0x2CB3], [0x2CB3, 0x2CB2], [0x2CB4, 0x2CB5], [0x2CB5, 0x2CB4], [0x2CB6, 0x2CB7], [0x2CB7, 0x2CB6], [0x2CB8, 0x2CB9], [0x2CB9, 0x2CB8], [0x2CBA, 0x2CBB], [0x2CBB, 0x2CBA], [0x2CBC, 0x2CBD], [0x2CBD, 0x2CBC], [0x2CBE, 0x2CBF], [0x2CBF, 0x2CBE], [0x2CC0, 0x2CC1], [0x2CC1, 0x2CC0], [0x2CC2, 0x2CC3], [0x2CC3, 0x2CC2], [0x2CC4, 0x2CC5], [0x2CC5, 0x2CC4], [0x2CC6, 0x2CC7], [0x2CC7, 0x2CC6], [0x2CC8, 0x2CC9], [0x2CC9, 0x2CC8], [0x2CCA, 0x2CCB], [0x2CCB, 0x2CCA], [0x2CCC, 0x2CCD], [0x2CCD, 0x2CCC], [0x2CCE, 0x2CCF], [0x2CCF, 0x2CCE], [0x2CD0, 0x2CD1], [0x2CD1, 0x2CD0], [0x2CD2, 0x2CD3], [0x2CD3, 0x2CD2], [0x2CD4, 0x2CD5], [0x2CD5, 0x2CD4], [0x2CD6, 0x2CD7], [0x2CD7, 0x2CD6], [0x2CD8, 0x2CD9], [0x2CD9, 0x2CD8], [0x2CDA, 0x2CDB], [0x2CDB, 0x2CDA], [0x2CDC, 0x2CDD], [0x2CDD, 0x2CDC], [0x2CDE, 0x2CDF], [0x2CDF, 0x2CDE], [0x2CE0, 0x2CE1], [0x2CE1, 0x2CE0], [0x2CE2, 0x2CE3], [0x2CE3, 0x2CE2], [0x2CEB, 0x2CEC], [0x2CEC, 0x2CEB], [0x2CED, 0x2CEE], [0x2CEE, 0x2CED], [0x2CF2, 0x2CF3], [0x2CF3, 0x2CF2], [0x2D00, 0x10A0], [0x2D01, 0x10A1], [0x2D02, 0x10A2], [0x2D03, 0x10A3], [0x2D04, 0x10A4], [0x2D05, 0x10A5], [0x2D06, 0x10A6], [0x2D07, 0x10A7], [0x2D08, 0x10A8], [0x2D09, 0x10A9], [0x2D0A, 0x10AA], [0x2D0B, 0x10AB], [0x2D0C, 0x10AC], [0x2D0D, 0x10AD], [0x2D0E, 0x10AE], [0x2D0F, 0x10AF], [0x2D10, 0x10B0], [0x2D11, 0x10B1], [0x2D12, 0x10B2], [0x2D13, 0x10B3], [0x2D14, 0x10B4], [0x2D15, 0x10B5], [0x2D16, 0x10B6], [0x2D17, 0x10B7], [0x2D18, 0x10B8], [0x2D19, 0x10B9], [0x2D1A, 0x10BA], [0x2D1B, 0x10BB], [0x2D1C, 0x10BC], [0x2D1D, 0x10BD], [0x2D1E, 0x10BE], [0x2D1F, 0x10BF], [0x2D20, 0x10C0], [0x2D21, 0x10C1], [0x2D22, 0x10C2], [0x2D23, 0x10C3], [0x2D24, 0x10C4], [0x2D25, 0x10C5], [0x2D27, 0x10C7], [0x2D2D, 0x10CD], [0xA640, 0xA641], [0xA641, 0xA640], [0xA642, 0xA643], [0xA643, 0xA642], [0xA644, 0xA645], [0xA645, 0xA644], [0xA646, 0xA647], [0xA647, 0xA646], [0xA648, 0xA649], [0xA649, 0xA648], [0xA64A, 0xA64B], [0xA64B, [0x1C88, 0xA64A]], [0xA64C, 0xA64D], [0xA64D, 0xA64C], [0xA64E, 0xA64F], [0xA64F, 0xA64E], [0xA650, 0xA651], [0xA651, 0xA650], [0xA652, 0xA653], [0xA653, 0xA652], [0xA654, 0xA655], [0xA655, 0xA654], [0xA656, 0xA657], [0xA657, 0xA656], [0xA658, 0xA659], [0xA659, 0xA658], [0xA65A, 0xA65B], [0xA65B, 0xA65A], [0xA65C, 0xA65D], [0xA65D, 0xA65C], [0xA65E, 0xA65F], [0xA65F, 0xA65E], [0xA660, 0xA661], [0xA661, 0xA660], [0xA662, 0xA663], [0xA663, 0xA662], [0xA664, 0xA665], [0xA665, 0xA664], [0xA666, 0xA667], [0xA667, 0xA666], [0xA668, 0xA669], [0xA669, 0xA668], [0xA66A, 0xA66B], [0xA66B, 0xA66A], [0xA66C, 0xA66D], [0xA66D, 0xA66C], [0xA680, 0xA681], [0xA681, 0xA680], [0xA682, 0xA683], [0xA683, 0xA682], [0xA684, 0xA685], [0xA685, 0xA684], [0xA686, 0xA687], [0xA687, 0xA686], [0xA688, 0xA689], [0xA689, 0xA688], [0xA68A, 0xA68B], [0xA68B, 0xA68A], [0xA68C, 0xA68D], [0xA68D, 0xA68C], [0xA68E, 0xA68F], [0xA68F, 0xA68E], [0xA690, 0xA691], [0xA691, 0xA690], [0xA692, 0xA693], [0xA693, 0xA692], [0xA694, 0xA695], [0xA695, 0xA694], [0xA696, 0xA697], [0xA697, 0xA696], [0xA698, 0xA699], [0xA699, 0xA698], [0xA69A, 0xA69B], [0xA69B, 0xA69A], [0xA722, 0xA723], [0xA723, 0xA722], [0xA724, 0xA725], [0xA725, 0xA724], [0xA726, 0xA727], [0xA727, 0xA726], [0xA728, 0xA729], [0xA729, 0xA728], [0xA72A, 0xA72B], [0xA72B, 0xA72A], [0xA72C, 0xA72D], [0xA72D, 0xA72C], [0xA72E, 0xA72F], [0xA72F, 0xA72E], [0xA732, 0xA733], [0xA733, 0xA732], [0xA734, 0xA735], [0xA735, 0xA734], [0xA736, 0xA737], [0xA737, 0xA736], [0xA738, 0xA739], [0xA739, 0xA738], [0xA73A, 0xA73B], [0xA73B, 0xA73A], [0xA73C, 0xA73D], [0xA73D, 0xA73C], [0xA73E, 0xA73F], [0xA73F, 0xA73E], [0xA740, 0xA741], [0xA741, 0xA740], [0xA742, 0xA743], [0xA743, 0xA742], [0xA744, 0xA745], [0xA745, 0xA744], [0xA746, 0xA747], [0xA747, 0xA746], [0xA748, 0xA749], [0xA749, 0xA748], [0xA74A, 0xA74B], [0xA74B, 0xA74A], [0xA74C, 0xA74D], [0xA74D, 0xA74C], [0xA74E, 0xA74F], [0xA74F, 0xA74E], [0xA750, 0xA751], [0xA751, 0xA750], [0xA752, 0xA753], [0xA753, 0xA752], [0xA754, 0xA755], [0xA755, 0xA754], [0xA756, 0xA757], [0xA757, 0xA756], [0xA758, 0xA759], [0xA759, 0xA758], [0xA75A, 0xA75B], [0xA75B, 0xA75A], [0xA75C, 0xA75D], [0xA75D, 0xA75C], [0xA75E, 0xA75F], [0xA75F, 0xA75E], [0xA760, 0xA761], [0xA761, 0xA760], [0xA762, 0xA763], [0xA763, 0xA762], [0xA764, 0xA765], [0xA765, 0xA764], [0xA766, 0xA767], [0xA767, 0xA766], [0xA768, 0xA769], [0xA769, 0xA768], [0xA76A, 0xA76B], [0xA76B, 0xA76A], [0xA76C, 0xA76D], [0xA76D, 0xA76C], [0xA76E, 0xA76F], [0xA76F, 0xA76E], [0xA779, 0xA77A], [0xA77A, 0xA779], [0xA77B, 0xA77C], [0xA77C, 0xA77B], [0xA77D, 0x1D79], [0xA77E, 0xA77F], [0xA77F, 0xA77E], [0xA780, 0xA781], [0xA781, 0xA780], [0xA782, 0xA783], [0xA783, 0xA782], [0xA784, 0xA785], [0xA785, 0xA784], [0xA786, 0xA787], [0xA787, 0xA786], [0xA78B, 0xA78C], [0xA78C, 0xA78B], [0xA78D, 0x265], [0xA790, 0xA791], [0xA791, 0xA790], [0xA792, 0xA793], [0xA793, 0xA792], [0xA794, 0xA7C4], [0xA796, 0xA797], [0xA797, 0xA796], [0xA798, 0xA799], [0xA799, 0xA798], [0xA79A, 0xA79B], [0xA79B, 0xA79A], [0xA79C, 0xA79D], [0xA79D, 0xA79C], [0xA79E, 0xA79F], [0xA79F, 0xA79E], [0xA7A0, 0xA7A1], [0xA7A1, 0xA7A0], [0xA7A2, 0xA7A3], [0xA7A3, 0xA7A2], [0xA7A4, 0xA7A5], [0xA7A5, 0xA7A4], [0xA7A6, 0xA7A7], [0xA7A7, 0xA7A6], [0xA7A8, 0xA7A9], [0xA7A9, 0xA7A8], [0xA7AA, 0x266], [0xA7AB, 0x25C], [0xA7AC, 0x261], [0xA7AD, 0x26C], [0xA7AE, 0x26A], [0xA7B0, 0x29E], [0xA7B1, 0x287], [0xA7B2, 0x29D], [0xA7B3, 0xAB53], [0xA7B4, 0xA7B5], [0xA7B5, 0xA7B4], [0xA7B6, 0xA7B7], [0xA7B7, 0xA7B6], [0xA7B8, 0xA7B9], [0xA7B9, 0xA7B8], [0xA7BA, 0xA7BB], [0xA7BB, 0xA7BA], [0xA7BC, 0xA7BD], [0xA7BD, 0xA7BC], [0xA7BE, 0xA7BF], [0xA7BF, 0xA7BE], [0xA7C0, 0xA7C1], [0xA7C1, 0xA7C0], [0xA7C2, 0xA7C3], [0xA7C3, 0xA7C2], [0xA7C4, 0xA794], [0xA7C5, 0x282], [0xA7C6, 0x1D8E], [0xA7C7, 0xA7C8], [0xA7C8, 0xA7C7], [0xA7C9, 0xA7CA], [0xA7CA, 0xA7C9], [0xA7CB, 0x264], [0xA7CC, 0xA7CD], [0xA7CD, 0xA7CC], [0xA7D0, 0xA7D1], [0xA7D1, 0xA7D0], [0xA7D6, 0xA7D7], [0xA7D7, 0xA7D6], [0xA7D8, 0xA7D9], [0xA7D9, 0xA7D8], [0xA7DA, 0xA7DB], [0xA7DB, 0xA7DA], [0xA7DC, 0x19B], [0xA7F5, 0xA7F6], [0xA7F6, 0xA7F5], [0xAB53, 0xA7B3], [0xAB70, 0x13A0], [0xAB71, 0x13A1], [0xAB72, 0x13A2], [0xAB73, 0x13A3], [0xAB74, 0x13A4], [0xAB75, 0x13A5], [0xAB76, 0x13A6], [0xAB77, 0x13A7], [0xAB78, 0x13A8], [0xAB79, 0x13A9], [0xAB7A, 0x13AA], [0xAB7B, 0x13AB], [0xAB7C, 0x13AC], [0xAB7D, 0x13AD], [0xAB7E, 0x13AE], [0xAB7F, 0x13AF], [0xAB80, 0x13B0], [0xAB81, 0x13B1], [0xAB82, 0x13B2], [0xAB83, 0x13B3], [0xAB84, 0x13B4], [0xAB85, 0x13B5], [0xAB86, 0x13B6], [0xAB87, 0x13B7], [0xAB88, 0x13B8], [0xAB89, 0x13B9], [0xAB8A, 0x13BA], [0xAB8B, 0x13BB], [0xAB8C, 0x13BC], [0xAB8D, 0x13BD], [0xAB8E, 0x13BE], [0xAB8F, 0x13BF], [0xAB90, 0x13C0], [0xAB91, 0x13C1], [0xAB92, 0x13C2], [0xAB93, 0x13C3], [0xAB94, 0x13C4], [0xAB95, 0x13C5], [0xAB96, 0x13C6], [0xAB97, 0x13C7], [0xAB98, 0x13C8], [0xAB99, 0x13C9], [0xAB9A, 0x13CA], [0xAB9B, 0x13CB], [0xAB9C, 0x13CC], [0xAB9D, 0x13CD], [0xAB9E, 0x13CE], [0xAB9F, 0x13CF], [0xABA0, 0x13D0], [0xABA1, 0x13D1], [0xABA2, 0x13D2], [0xABA3, 0x13D3], [0xABA4, 0x13D4], [0xABA5, 0x13D5], [0xABA6, 0x13D6], [0xABA7, 0x13D7], [0xABA8, 0x13D8], [0xABA9, 0x13D9], [0xABAA, 0x13DA], [0xABAB, 0x13DB], [0xABAC, 0x13DC], [0xABAD, 0x13DD], [0xABAE, 0x13DE], [0xABAF, 0x13DF], [0xABB0, 0x13E0], [0xABB1, 0x13E1], [0xABB2, 0x13E2], [0xABB3, 0x13E3], [0xABB4, 0x13E4], [0xABB5, 0x13E5], [0xABB6, 0x13E6], [0xABB7, 0x13E7], [0xABB8, 0x13E8], [0xABB9, 0x13E9], [0xABBA, 0x13EA], [0xABBB, 0x13EB], [0xABBC, 0x13EC], [0xABBD, 0x13ED], [0xABBE, 0x13EE], [0xABBF, 0x13EF], [0xFF21, 0xFF41], [0xFF22, 0xFF42], [0xFF23, 0xFF43], [0xFF24, 0xFF44], [0xFF25, 0xFF45], [0xFF26, 0xFF46], [0xFF27, 0xFF47], [0xFF28, 0xFF48], [0xFF29, 0xFF49], [0xFF2A, 0xFF4A], [0xFF2B, 0xFF4B], [0xFF2C, 0xFF4C], [0xFF2D, 0xFF4D], [0xFF2E, 0xFF4E], [0xFF2F, 0xFF4F], [0xFF30, 0xFF50], [0xFF31, 0xFF51], [0xFF32, 0xFF52], [0xFF33, 0xFF53], [0xFF34, 0xFF54], [0xFF35, 0xFF55], [0xFF36, 0xFF56], [0xFF37, 0xFF57], [0xFF38, 0xFF58], [0xFF39, 0xFF59], [0xFF3A, 0xFF5A], [0xFF41, 0xFF21], [0xFF42, 0xFF22], [0xFF43, 0xFF23], [0xFF44, 0xFF24], [0xFF45, 0xFF25], [0xFF46, 0xFF26], [0xFF47, 0xFF27], [0xFF48, 0xFF28], [0xFF49, 0xFF29], [0xFF4A, 0xFF2A], [0xFF4B, 0xFF2B], [0xFF4C, 0xFF2C], [0xFF4D, 0xFF2D], [0xFF4E, 0xFF2E], [0xFF4F, 0xFF2F], [0xFF50, 0xFF30], [0xFF51, 0xFF31], [0xFF52, 0xFF32], [0xFF53, 0xFF33], [0xFF54, 0xFF34], [0xFF55, 0xFF35], [0xFF56, 0xFF36], [0xFF57, 0xFF37], [0xFF58, 0xFF38], [0xFF59, 0xFF39], [0xFF5A, 0xFF3A]]);

var iuFoldings$1 = new Map([[0x41, 0x61], [0x42, 0x62], [0x43, 0x63], [0x44, 0x64], [0x45, 0x65], [0x46, 0x66], [0x47, 0x67], [0x48, 0x68], [0x49, 0x69], [0x4A, 0x6A], [0x4B, 0x6B], [0x4C, 0x6C], [0x4D, 0x6D], [0x4E, 0x6E], [0x4F, 0x6F], [0x50, 0x70], [0x51, 0x71], [0x52, 0x72], [0x53, 0x73], [0x54, 0x74], [0x55, 0x75], [0x56, 0x76], [0x57, 0x77], [0x58, 0x78], [0x59, 0x79], [0x5A, 0x7A], [0xB5, 0x3BC], [0xC0, 0xE0], [0xC1, 0xE1], [0xC2, 0xE2], [0xC3, 0xE3], [0xC4, 0xE4], [0xC5, 0xE5], [0xC6, 0xE6], [0xC7, 0xE7], [0xC8, 0xE8], [0xC9, 0xE9], [0xCA, 0xEA], [0xCB, 0xEB], [0xCC, 0xEC], [0xCD, 0xED], [0xCE, 0xEE], [0xCF, 0xEF], [0xD0, 0xF0], [0xD1, 0xF1], [0xD2, 0xF2], [0xD3, 0xF3], [0xD4, 0xF4], [0xD5, 0xF5], [0xD6, 0xF6], [0xD8, 0xF8], [0xD9, 0xF9], [0xDA, 0xFA], [0xDB, 0xFB], [0xDC, 0xFC], [0xDD, 0xFD], [0xDE, 0xFE], [0x100, 0x101], [0x102, 0x103], [0x104, 0x105], [0x106, 0x107], [0x108, 0x109], [0x10A, 0x10B], [0x10C, 0x10D], [0x10E, 0x10F], [0x110, 0x111], [0x112, 0x113], [0x114, 0x115], [0x116, 0x117], [0x118, 0x119], [0x11A, 0x11B], [0x11C, 0x11D], [0x11E, 0x11F], [0x120, 0x121], [0x122, 0x123], [0x124, 0x125], [0x126, 0x127], [0x128, 0x129], [0x12A, 0x12B], [0x12C, 0x12D], [0x12E, 0x12F], [0x132, 0x133], [0x134, 0x135], [0x136, 0x137], [0x139, 0x13A], [0x13B, 0x13C], [0x13D, 0x13E], [0x13F, 0x140], [0x141, 0x142], [0x143, 0x144], [0x145, 0x146], [0x147, 0x148], [0x14A, 0x14B], [0x14C, 0x14D], [0x14E, 0x14F], [0x150, 0x151], [0x152, 0x153], [0x154, 0x155], [0x156, 0x157], [0x158, 0x159], [0x15A, 0x15B], [0x15C, 0x15D], [0x15E, 0x15F], [0x160, 0x161], [0x162, 0x163], [0x164, 0x165], [0x166, 0x167], [0x168, 0x169], [0x16A, 0x16B], [0x16C, 0x16D], [0x16E, 0x16F], [0x170, 0x171], [0x172, 0x173], [0x174, 0x175], [0x176, 0x177], [0x178, 0xFF], [0x179, 0x17A], [0x17B, 0x17C], [0x17D, 0x17E], [0x17F, 0x73], [0x181, 0x253], [0x182, 0x183], [0x184, 0x185], [0x186, 0x254], [0x187, 0x188], [0x189, 0x256], [0x18A, 0x257], [0x18B, 0x18C], [0x18E, 0x1DD], [0x18F, 0x259], [0x190, 0x25B], [0x191, 0x192], [0x193, 0x260], [0x194, 0x263], [0x196, 0x269], [0x197, 0x268], [0x198, 0x199], [0x19C, 0x26F], [0x19D, 0x272], [0x19F, 0x275], [0x1A0, 0x1A1], [0x1A2, 0x1A3], [0x1A4, 0x1A5], [0x1A6, 0x280], [0x1A7, 0x1A8], [0x1A9, 0x283], [0x1AC, 0x1AD], [0x1AE, 0x288], [0x1AF, 0x1B0], [0x1B1, 0x28A], [0x1B2, 0x28B], [0x1B3, 0x1B4], [0x1B5, 0x1B6], [0x1B7, 0x292], [0x1B8, 0x1B9], [0x1BC, 0x1BD], [0x1C4, 0x1C6], [0x1C5, 0x1C6], [0x1C7, 0x1C9], [0x1C8, 0x1C9], [0x1CA, 0x1CC], [0x1CB, 0x1CC], [0x1CD, 0x1CE], [0x1CF, 0x1D0], [0x1D1, 0x1D2], [0x1D3, 0x1D4], [0x1D5, 0x1D6], [0x1D7, 0x1D8], [0x1D9, 0x1DA], [0x1DB, 0x1DC], [0x1DE, 0x1DF], [0x1E0, 0x1E1], [0x1E2, 0x1E3], [0x1E4, 0x1E5], [0x1E6, 0x1E7], [0x1E8, 0x1E9], [0x1EA, 0x1EB], [0x1EC, 0x1ED], [0x1EE, 0x1EF], [0x1F1, 0x1F3], [0x1F2, 0x1F3], [0x1F4, 0x1F5], [0x1F6, 0x195], [0x1F7, 0x1BF], [0x1F8, 0x1F9], [0x1FA, 0x1FB], [0x1FC, 0x1FD], [0x1FE, 0x1FF], [0x200, 0x201], [0x202, 0x203], [0x204, 0x205], [0x206, 0x207], [0x208, 0x209], [0x20A, 0x20B], [0x20C, 0x20D], [0x20E, 0x20F], [0x210, 0x211], [0x212, 0x213], [0x214, 0x215], [0x216, 0x217], [0x218, 0x219], [0x21A, 0x21B], [0x21C, 0x21D], [0x21E, 0x21F], [0x220, 0x19E], [0x222, 0x223], [0x224, 0x225], [0x226, 0x227], [0x228, 0x229], [0x22A, 0x22B], [0x22C, 0x22D], [0x22E, 0x22F], [0x230, 0x231], [0x232, 0x233], [0x23A, 0x2C65], [0x23B, 0x23C], [0x23D, 0x19A], [0x23E, 0x2C66], [0x241, 0x242], [0x243, 0x180], [0x244, 0x289], [0x245, 0x28C], [0x246, 0x247], [0x248, 0x249], [0x24A, 0x24B], [0x24C, 0x24D], [0x24E, 0x24F], [0x345, 0x3B9], [0x370, 0x371], [0x372, 0x373], [0x376, 0x377], [0x37F, 0x3F3], [0x386, 0x3AC], [0x388, 0x3AD], [0x389, 0x3AE], [0x38A, 0x3AF], [0x38C, 0x3CC], [0x38E, 0x3CD], [0x38F, 0x3CE], [0x391, 0x3B1], [0x392, 0x3B2], [0x393, 0x3B3], [0x394, 0x3B4], [0x395, 0x3B5], [0x396, 0x3B6], [0x397, 0x3B7], [0x398, 0x3B8], [0x399, 0x3B9], [0x39A, 0x3BA], [0x39B, 0x3BB], [0x39C, 0x3BC], [0x39D, 0x3BD], [0x39E, 0x3BE], [0x39F, 0x3BF], [0x3A0, 0x3C0], [0x3A1, 0x3C1], [0x3A3, 0x3C3], [0x3A4, 0x3C4], [0x3A5, 0x3C5], [0x3A6, 0x3C6], [0x3A7, 0x3C7], [0x3A8, 0x3C8], [0x3A9, 0x3C9], [0x3AA, 0x3CA], [0x3AB, 0x3CB], [0x3C2, 0x3C3], [0x3CF, 0x3D7], [0x3D0, 0x3B2], [0x3D1, 0x3B8], [0x3D5, 0x3C6], [0x3D6, 0x3C0], [0x3D8, 0x3D9], [0x3DA, 0x3DB], [0x3DC, 0x3DD], [0x3DE, 0x3DF], [0x3E0, 0x3E1], [0x3E2, 0x3E3], [0x3E4, 0x3E5], [0x3E6, 0x3E7], [0x3E8, 0x3E9], [0x3EA, 0x3EB], [0x3EC, 0x3ED], [0x3EE, 0x3EF], [0x3F0, 0x3BA], [0x3F1, 0x3C1], [0x3F4, 0x3B8], [0x3F5, 0x3B5], [0x3F7, 0x3F8], [0x3F9, 0x3F2], [0x3FA, 0x3FB], [0x3FD, 0x37B], [0x3FE, 0x37C], [0x3FF, 0x37D], [0x400, 0x450], [0x401, 0x451], [0x402, 0x452], [0x403, 0x453], [0x404, 0x454], [0x405, 0x455], [0x406, 0x456], [0x407, 0x457], [0x408, 0x458], [0x409, 0x459], [0x40A, 0x45A], [0x40B, 0x45B], [0x40C, 0x45C], [0x40D, 0x45D], [0x40E, 0x45E], [0x40F, 0x45F], [0x410, 0x430], [0x411, 0x431], [0x412, 0x432], [0x413, 0x433], [0x414, 0x434], [0x415, 0x435], [0x416, 0x436], [0x417, 0x437], [0x418, 0x438], [0x419, 0x439], [0x41A, 0x43A], [0x41B, 0x43B], [0x41C, 0x43C], [0x41D, 0x43D], [0x41E, 0x43E], [0x41F, 0x43F], [0x420, 0x440], [0x421, 0x441], [0x422, 0x442], [0x423, 0x443], [0x424, 0x444], [0x425, 0x445], [0x426, 0x446], [0x427, 0x447], [0x428, 0x448], [0x429, 0x449], [0x42A, 0x44A], [0x42B, 0x44B], [0x42C, 0x44C], [0x42D, 0x44D], [0x42E, 0x44E], [0x42F, 0x44F], [0x460, 0x461], [0x462, 0x463], [0x464, 0x465], [0x466, 0x467], [0x468, 0x469], [0x46A, 0x46B], [0x46C, 0x46D], [0x46E, 0x46F], [0x470, 0x471], [0x472, 0x473], [0x474, 0x475], [0x476, 0x477], [0x478, 0x479], [0x47A, 0x47B], [0x47C, 0x47D], [0x47E, 0x47F], [0x480, 0x481], [0x48A, 0x48B], [0x48C, 0x48D], [0x48E, 0x48F], [0x490, 0x491], [0x492, 0x493], [0x494, 0x495], [0x496, 0x497], [0x498, 0x499], [0x49A, 0x49B], [0x49C, 0x49D], [0x49E, 0x49F], [0x4A0, 0x4A1], [0x4A2, 0x4A3], [0x4A4, 0x4A5], [0x4A6, 0x4A7], [0x4A8, 0x4A9], [0x4AA, 0x4AB], [0x4AC, 0x4AD], [0x4AE, 0x4AF], [0x4B0, 0x4B1], [0x4B2, 0x4B3], [0x4B4, 0x4B5], [0x4B6, 0x4B7], [0x4B8, 0x4B9], [0x4BA, 0x4BB], [0x4BC, 0x4BD], [0x4BE, 0x4BF], [0x4C0, 0x4CF], [0x4C1, 0x4C2], [0x4C3, 0x4C4], [0x4C5, 0x4C6], [0x4C7, 0x4C8], [0x4C9, 0x4CA], [0x4CB, 0x4CC], [0x4CD, 0x4CE], [0x4D0, 0x4D1], [0x4D2, 0x4D3], [0x4D4, 0x4D5], [0x4D6, 0x4D7], [0x4D8, 0x4D9], [0x4DA, 0x4DB], [0x4DC, 0x4DD], [0x4DE, 0x4DF], [0x4E0, 0x4E1], [0x4E2, 0x4E3], [0x4E4, 0x4E5], [0x4E6, 0x4E7], [0x4E8, 0x4E9], [0x4EA, 0x4EB], [0x4EC, 0x4ED], [0x4EE, 0x4EF], [0x4F0, 0x4F1], [0x4F2, 0x4F3], [0x4F4, 0x4F5], [0x4F6, 0x4F7], [0x4F8, 0x4F9], [0x4FA, 0x4FB], [0x4FC, 0x4FD], [0x4FE, 0x4FF], [0x500, 0x501], [0x502, 0x503], [0x504, 0x505], [0x506, 0x507], [0x508, 0x509], [0x50A, 0x50B], [0x50C, 0x50D], [0x50E, 0x50F], [0x510, 0x511], [0x512, 0x513], [0x514, 0x515], [0x516, 0x517], [0x518, 0x519], [0x51A, 0x51B], [0x51C, 0x51D], [0x51E, 0x51F], [0x520, 0x521], [0x522, 0x523], [0x524, 0x525], [0x526, 0x527], [0x528, 0x529], [0x52A, 0x52B], [0x52C, 0x52D], [0x52E, 0x52F], [0x531, 0x561], [0x532, 0x562], [0x533, 0x563], [0x534, 0x564], [0x535, 0x565], [0x536, 0x566], [0x537, 0x567], [0x538, 0x568], [0x539, 0x569], [0x53A, 0x56A], [0x53B, 0x56B], [0x53C, 0x56C], [0x53D, 0x56D], [0x53E, 0x56E], [0x53F, 0x56F], [0x540, 0x570], [0x541, 0x571], [0x542, 0x572], [0x543, 0x573], [0x544, 0x574], [0x545, 0x575], [0x546, 0x576], [0x547, 0x577], [0x548, 0x578], [0x549, 0x579], [0x54A, 0x57A], [0x54B, 0x57B], [0x54C, 0x57C], [0x54D, 0x57D], [0x54E, 0x57E], [0x54F, 0x57F], [0x550, 0x580], [0x551, 0x581], [0x552, 0x582], [0x553, 0x583], [0x554, 0x584], [0x555, 0x585], [0x556, 0x586], [0x10A0, 0x2D00], [0x10A1, 0x2D01], [0x10A2, 0x2D02], [0x10A3, 0x2D03], [0x10A4, 0x2D04], [0x10A5, 0x2D05], [0x10A6, 0x2D06], [0x10A7, 0x2D07], [0x10A8, 0x2D08], [0x10A9, 0x2D09], [0x10AA, 0x2D0A], [0x10AB, 0x2D0B], [0x10AC, 0x2D0C], [0x10AD, 0x2D0D], [0x10AE, 0x2D0E], [0x10AF, 0x2D0F], [0x10B0, 0x2D10], [0x10B1, 0x2D11], [0x10B2, 0x2D12], [0x10B3, 0x2D13], [0x10B4, 0x2D14], [0x10B5, 0x2D15], [0x10B6, 0x2D16], [0x10B7, 0x2D17], [0x10B8, 0x2D18], [0x10B9, 0x2D19], [0x10BA, 0x2D1A], [0x10BB, 0x2D1B], [0x10BC, 0x2D1C], [0x10BD, 0x2D1D], [0x10BE, 0x2D1E], [0x10BF, 0x2D1F], [0x10C0, 0x2D20], [0x10C1, 0x2D21], [0x10C2, 0x2D22], [0x10C3, 0x2D23], [0x10C4, 0x2D24], [0x10C5, 0x2D25], [0x10C7, 0x2D27], [0x10CD, 0x2D2D], [0x13F8, 0x13F0], [0x13F9, 0x13F1], [0x13FA, 0x13F2], [0x13FB, 0x13F3], [0x13FC, 0x13F4], [0x13FD, 0x13F5], [0x1C80, 0x432], [0x1C81, 0x434], [0x1C82, 0x43E], [0x1C83, 0x441], [0x1C84, 0x442], [0x1C85, 0x442], [0x1C86, 0x44A], [0x1C87, 0x463], [0x1C88, 0xA64B], [0x1C89, 0x1C8A], [0x1C90, 0x10D0], [0x1C91, 0x10D1], [0x1C92, 0x10D2], [0x1C93, 0x10D3], [0x1C94, 0x10D4], [0x1C95, 0x10D5], [0x1C96, 0x10D6], [0x1C97, 0x10D7], [0x1C98, 0x10D8], [0x1C99, 0x10D9], [0x1C9A, 0x10DA], [0x1C9B, 0x10DB], [0x1C9C, 0x10DC], [0x1C9D, 0x10DD], [0x1C9E, 0x10DE], [0x1C9F, 0x10DF], [0x1CA0, 0x10E0], [0x1CA1, 0x10E1], [0x1CA2, 0x10E2], [0x1CA3, 0x10E3], [0x1CA4, 0x10E4], [0x1CA5, 0x10E5], [0x1CA6, 0x10E6], [0x1CA7, 0x10E7], [0x1CA8, 0x10E8], [0x1CA9, 0x10E9], [0x1CAA, 0x10EA], [0x1CAB, 0x10EB], [0x1CAC, 0x10EC], [0x1CAD, 0x10ED], [0x1CAE, 0x10EE], [0x1CAF, 0x10EF], [0x1CB0, 0x10F0], [0x1CB1, 0x10F1], [0x1CB2, 0x10F2], [0x1CB3, 0x10F3], [0x1CB4, 0x10F4], [0x1CB5, 0x10F5], [0x1CB6, 0x10F6], [0x1CB7, 0x10F7], [0x1CB8, 0x10F8], [0x1CB9, 0x10F9], [0x1CBA, 0x10FA], [0x1CBD, 0x10FD], [0x1CBE, 0x10FE], [0x1CBF, 0x10FF], [0x1E00, 0x1E01], [0x1E02, 0x1E03], [0x1E04, 0x1E05], [0x1E06, 0x1E07], [0x1E08, 0x1E09], [0x1E0A, 0x1E0B], [0x1E0C, 0x1E0D], [0x1E0E, 0x1E0F], [0x1E10, 0x1E11], [0x1E12, 0x1E13], [0x1E14, 0x1E15], [0x1E16, 0x1E17], [0x1E18, 0x1E19], [0x1E1A, 0x1E1B], [0x1E1C, 0x1E1D], [0x1E1E, 0x1E1F], [0x1E20, 0x1E21], [0x1E22, 0x1E23], [0x1E24, 0x1E25], [0x1E26, 0x1E27], [0x1E28, 0x1E29], [0x1E2A, 0x1E2B], [0x1E2C, 0x1E2D], [0x1E2E, 0x1E2F], [0x1E30, 0x1E31], [0x1E32, 0x1E33], [0x1E34, 0x1E35], [0x1E36, 0x1E37], [0x1E38, 0x1E39], [0x1E3A, 0x1E3B], [0x1E3C, 0x1E3D], [0x1E3E, 0x1E3F], [0x1E40, 0x1E41], [0x1E42, 0x1E43], [0x1E44, 0x1E45], [0x1E46, 0x1E47], [0x1E48, 0x1E49], [0x1E4A, 0x1E4B], [0x1E4C, 0x1E4D], [0x1E4E, 0x1E4F], [0x1E50, 0x1E51], [0x1E52, 0x1E53], [0x1E54, 0x1E55], [0x1E56, 0x1E57], [0x1E58, 0x1E59], [0x1E5A, 0x1E5B], [0x1E5C, 0x1E5D], [0x1E5E, 0x1E5F], [0x1E60, 0x1E61], [0x1E62, 0x1E63], [0x1E64, 0x1E65], [0x1E66, 0x1E67], [0x1E68, 0x1E69], [0x1E6A, 0x1E6B], [0x1E6C, 0x1E6D], [0x1E6E, 0x1E6F], [0x1E70, 0x1E71], [0x1E72, 0x1E73], [0x1E74, 0x1E75], [0x1E76, 0x1E77], [0x1E78, 0x1E79], [0x1E7A, 0x1E7B], [0x1E7C, 0x1E7D], [0x1E7E, 0x1E7F], [0x1E80, 0x1E81], [0x1E82, 0x1E83], [0x1E84, 0x1E85], [0x1E86, 0x1E87], [0x1E88, 0x1E89], [0x1E8A, 0x1E8B], [0x1E8C, 0x1E8D], [0x1E8E, 0x1E8F], [0x1E90, 0x1E91], [0x1E92, 0x1E93], [0x1E94, 0x1E95], [0x1E9B, 0x1E61], [0x1E9E, 0xDF], [0x1EA0, 0x1EA1], [0x1EA2, 0x1EA3], [0x1EA4, 0x1EA5], [0x1EA6, 0x1EA7], [0x1EA8, 0x1EA9], [0x1EAA, 0x1EAB], [0x1EAC, 0x1EAD], [0x1EAE, 0x1EAF], [0x1EB0, 0x1EB1], [0x1EB2, 0x1EB3], [0x1EB4, 0x1EB5], [0x1EB6, 0x1EB7], [0x1EB8, 0x1EB9], [0x1EBA, 0x1EBB], [0x1EBC, 0x1EBD], [0x1EBE, 0x1EBF], [0x1EC0, 0x1EC1], [0x1EC2, 0x1EC3], [0x1EC4, 0x1EC5], [0x1EC6, 0x1EC7], [0x1EC8, 0x1EC9], [0x1ECA, 0x1ECB], [0x1ECC, 0x1ECD], [0x1ECE, 0x1ECF], [0x1ED0, 0x1ED1], [0x1ED2, 0x1ED3], [0x1ED4, 0x1ED5], [0x1ED6, 0x1ED7], [0x1ED8, 0x1ED9], [0x1EDA, 0x1EDB], [0x1EDC, 0x1EDD], [0x1EDE, 0x1EDF], [0x1EE0, 0x1EE1], [0x1EE2, 0x1EE3], [0x1EE4, 0x1EE5], [0x1EE6, 0x1EE7], [0x1EE8, 0x1EE9], [0x1EEA, 0x1EEB], [0x1EEC, 0x1EED], [0x1EEE, 0x1EEF], [0x1EF0, 0x1EF1], [0x1EF2, 0x1EF3], [0x1EF4, 0x1EF5], [0x1EF6, 0x1EF7], [0x1EF8, 0x1EF9], [0x1EFA, 0x1EFB], [0x1EFC, 0x1EFD], [0x1EFE, 0x1EFF], [0x1F08, 0x1F00], [0x1F09, 0x1F01], [0x1F0A, 0x1F02], [0x1F0B, 0x1F03], [0x1F0C, 0x1F04], [0x1F0D, 0x1F05], [0x1F0E, 0x1F06], [0x1F0F, 0x1F07], [0x1F18, 0x1F10], [0x1F19, 0x1F11], [0x1F1A, 0x1F12], [0x1F1B, 0x1F13], [0x1F1C, 0x1F14], [0x1F1D, 0x1F15], [0x1F28, 0x1F20], [0x1F29, 0x1F21], [0x1F2A, 0x1F22], [0x1F2B, 0x1F23], [0x1F2C, 0x1F24], [0x1F2D, 0x1F25], [0x1F2E, 0x1F26], [0x1F2F, 0x1F27], [0x1F38, 0x1F30], [0x1F39, 0x1F31], [0x1F3A, 0x1F32], [0x1F3B, 0x1F33], [0x1F3C, 0x1F34], [0x1F3D, 0x1F35], [0x1F3E, 0x1F36], [0x1F3F, 0x1F37], [0x1F48, 0x1F40], [0x1F49, 0x1F41], [0x1F4A, 0x1F42], [0x1F4B, 0x1F43], [0x1F4C, 0x1F44], [0x1F4D, 0x1F45], [0x1F59, 0x1F51], [0x1F5B, 0x1F53], [0x1F5D, 0x1F55], [0x1F5F, 0x1F57], [0x1F68, 0x1F60], [0x1F69, 0x1F61], [0x1F6A, 0x1F62], [0x1F6B, 0x1F63], [0x1F6C, 0x1F64], [0x1F6D, 0x1F65], [0x1F6E, 0x1F66], [0x1F6F, 0x1F67], [0x1F88, 0x1F80], [0x1F89, 0x1F81], [0x1F8A, 0x1F82], [0x1F8B, 0x1F83], [0x1F8C, 0x1F84], [0x1F8D, 0x1F85], [0x1F8E, 0x1F86], [0x1F8F, 0x1F87], [0x1F98, 0x1F90], [0x1F99, 0x1F91], [0x1F9A, 0x1F92], [0x1F9B, 0x1F93], [0x1F9C, 0x1F94], [0x1F9D, 0x1F95], [0x1F9E, 0x1F96], [0x1F9F, 0x1F97], [0x1FA8, 0x1FA0], [0x1FA9, 0x1FA1], [0x1FAA, 0x1FA2], [0x1FAB, 0x1FA3], [0x1FAC, 0x1FA4], [0x1FAD, 0x1FA5], [0x1FAE, 0x1FA6], [0x1FAF, 0x1FA7], [0x1FB8, 0x1FB0], [0x1FB9, 0x1FB1], [0x1FBA, 0x1F70], [0x1FBB, 0x1F71], [0x1FBC, 0x1FB3], [0x1FBE, 0x3B9], [0x1FC8, 0x1F72], [0x1FC9, 0x1F73], [0x1FCA, 0x1F74], [0x1FCB, 0x1F75], [0x1FCC, 0x1FC3], [0x1FD3, 0x390], [0x1FD8, 0x1FD0], [0x1FD9, 0x1FD1], [0x1FDA, 0x1F76], [0x1FDB, 0x1F77], [0x1FE3, 0x3B0], [0x1FE8, 0x1FE0], [0x1FE9, 0x1FE1], [0x1FEA, 0x1F7A], [0x1FEB, 0x1F7B], [0x1FEC, 0x1FE5], [0x1FF8, 0x1F78], [0x1FF9, 0x1F79], [0x1FFA, 0x1F7C], [0x1FFB, 0x1F7D], [0x1FFC, 0x1FF3], [0x2126, 0x3C9], [0x212A, 0x6B], [0x212B, 0xE5], [0x2132, 0x214E], [0x2160, 0x2170], [0x2161, 0x2171], [0x2162, 0x2172], [0x2163, 0x2173], [0x2164, 0x2174], [0x2165, 0x2175], [0x2166, 0x2176], [0x2167, 0x2177], [0x2168, 0x2178], [0x2169, 0x2179], [0x216A, 0x217A], [0x216B, 0x217B], [0x216C, 0x217C], [0x216D, 0x217D], [0x216E, 0x217E], [0x216F, 0x217F], [0x2183, 0x2184], [0x24B6, 0x24D0], [0x24B7, 0x24D1], [0x24B8, 0x24D2], [0x24B9, 0x24D3], [0x24BA, 0x24D4], [0x24BB, 0x24D5], [0x24BC, 0x24D6], [0x24BD, 0x24D7], [0x24BE, 0x24D8], [0x24BF, 0x24D9], [0x24C0, 0x24DA], [0x24C1, 0x24DB], [0x24C2, 0x24DC], [0x24C3, 0x24DD], [0x24C4, 0x24DE], [0x24C5, 0x24DF], [0x24C6, 0x24E0], [0x24C7, 0x24E1], [0x24C8, 0x24E2], [0x24C9, 0x24E3], [0x24CA, 0x24E4], [0x24CB, 0x24E5], [0x24CC, 0x24E6], [0x24CD, 0x24E7], [0x24CE, 0x24E8], [0x24CF, 0x24E9], [0x2C00, 0x2C30], [0x2C01, 0x2C31], [0x2C02, 0x2C32], [0x2C03, 0x2C33], [0x2C04, 0x2C34], [0x2C05, 0x2C35], [0x2C06, 0x2C36], [0x2C07, 0x2C37], [0x2C08, 0x2C38], [0x2C09, 0x2C39], [0x2C0A, 0x2C3A], [0x2C0B, 0x2C3B], [0x2C0C, 0x2C3C], [0x2C0D, 0x2C3D], [0x2C0E, 0x2C3E], [0x2C0F, 0x2C3F], [0x2C10, 0x2C40], [0x2C11, 0x2C41], [0x2C12, 0x2C42], [0x2C13, 0x2C43], [0x2C14, 0x2C44], [0x2C15, 0x2C45], [0x2C16, 0x2C46], [0x2C17, 0x2C47], [0x2C18, 0x2C48], [0x2C19, 0x2C49], [0x2C1A, 0x2C4A], [0x2C1B, 0x2C4B], [0x2C1C, 0x2C4C], [0x2C1D, 0x2C4D], [0x2C1E, 0x2C4E], [0x2C1F, 0x2C4F], [0x2C20, 0x2C50], [0x2C21, 0x2C51], [0x2C22, 0x2C52], [0x2C23, 0x2C53], [0x2C24, 0x2C54], [0x2C25, 0x2C55], [0x2C26, 0x2C56], [0x2C27, 0x2C57], [0x2C28, 0x2C58], [0x2C29, 0x2C59], [0x2C2A, 0x2C5A], [0x2C2B, 0x2C5B], [0x2C2C, 0x2C5C], [0x2C2D, 0x2C5D], [0x2C2E, 0x2C5E], [0x2C2F, 0x2C5F], [0x2C60, 0x2C61], [0x2C62, 0x26B], [0x2C63, 0x1D7D], [0x2C64, 0x27D], [0x2C67, 0x2C68], [0x2C69, 0x2C6A], [0x2C6B, 0x2C6C], [0x2C6D, 0x251], [0x2C6E, 0x271], [0x2C6F, 0x250], [0x2C70, 0x252], [0x2C72, 0x2C73], [0x2C75, 0x2C76], [0x2C7E, 0x23F], [0x2C7F, 0x240], [0x2C80, 0x2C81], [0x2C82, 0x2C83], [0x2C84, 0x2C85], [0x2C86, 0x2C87], [0x2C88, 0x2C89], [0x2C8A, 0x2C8B], [0x2C8C, 0x2C8D], [0x2C8E, 0x2C8F], [0x2C90, 0x2C91], [0x2C92, 0x2C93], [0x2C94, 0x2C95], [0x2C96, 0x2C97], [0x2C98, 0x2C99], [0x2C9A, 0x2C9B], [0x2C9C, 0x2C9D], [0x2C9E, 0x2C9F], [0x2CA0, 0x2CA1], [0x2CA2, 0x2CA3], [0x2CA4, 0x2CA5], [0x2CA6, 0x2CA7], [0x2CA8, 0x2CA9], [0x2CAA, 0x2CAB], [0x2CAC, 0x2CAD], [0x2CAE, 0x2CAF], [0x2CB0, 0x2CB1], [0x2CB2, 0x2CB3], [0x2CB4, 0x2CB5], [0x2CB6, 0x2CB7], [0x2CB8, 0x2CB9], [0x2CBA, 0x2CBB], [0x2CBC, 0x2CBD], [0x2CBE, 0x2CBF], [0x2CC0, 0x2CC1], [0x2CC2, 0x2CC3], [0x2CC4, 0x2CC5], [0x2CC6, 0x2CC7], [0x2CC8, 0x2CC9], [0x2CCA, 0x2CCB], [0x2CCC, 0x2CCD], [0x2CCE, 0x2CCF], [0x2CD0, 0x2CD1], [0x2CD2, 0x2CD3], [0x2CD4, 0x2CD5], [0x2CD6, 0x2CD7], [0x2CD8, 0x2CD9], [0x2CDA, 0x2CDB], [0x2CDC, 0x2CDD], [0x2CDE, 0x2CDF], [0x2CE0, 0x2CE1], [0x2CE2, 0x2CE3], [0x2CEB, 0x2CEC], [0x2CED, 0x2CEE], [0x2CF2, 0x2CF3], [0xA640, 0xA641], [0xA642, 0xA643], [0xA644, 0xA645], [0xA646, 0xA647], [0xA648, 0xA649], [0xA64A, 0xA64B], [0xA64C, 0xA64D], [0xA64E, 0xA64F], [0xA650, 0xA651], [0xA652, 0xA653], [0xA654, 0xA655], [0xA656, 0xA657], [0xA658, 0xA659], [0xA65A, 0xA65B], [0xA65C, 0xA65D], [0xA65E, 0xA65F], [0xA660, 0xA661], [0xA662, 0xA663], [0xA664, 0xA665], [0xA666, 0xA667], [0xA668, 0xA669], [0xA66A, 0xA66B], [0xA66C, 0xA66D], [0xA680, 0xA681], [0xA682, 0xA683], [0xA684, 0xA685], [0xA686, 0xA687], [0xA688, 0xA689], [0xA68A, 0xA68B], [0xA68C, 0xA68D], [0xA68E, 0xA68F], [0xA690, 0xA691], [0xA692, 0xA693], [0xA694, 0xA695], [0xA696, 0xA697], [0xA698, 0xA699], [0xA69A, 0xA69B], [0xA722, 0xA723], [0xA724, 0xA725], [0xA726, 0xA727], [0xA728, 0xA729], [0xA72A, 0xA72B], [0xA72C, 0xA72D], [0xA72E, 0xA72F], [0xA732, 0xA733], [0xA734, 0xA735], [0xA736, 0xA737], [0xA738, 0xA739], [0xA73A, 0xA73B], [0xA73C, 0xA73D], [0xA73E, 0xA73F], [0xA740, 0xA741], [0xA742, 0xA743], [0xA744, 0xA745], [0xA746, 0xA747], [0xA748, 0xA749], [0xA74A, 0xA74B], [0xA74C, 0xA74D], [0xA74E, 0xA74F], [0xA750, 0xA751], [0xA752, 0xA753], [0xA754, 0xA755], [0xA756, 0xA757], [0xA758, 0xA759], [0xA75A, 0xA75B], [0xA75C, 0xA75D], [0xA75E, 0xA75F], [0xA760, 0xA761], [0xA762, 0xA763], [0xA764, 0xA765], [0xA766, 0xA767], [0xA768, 0xA769], [0xA76A, 0xA76B], [0xA76C, 0xA76D], [0xA76E, 0xA76F], [0xA779, 0xA77A], [0xA77B, 0xA77C], [0xA77D, 0x1D79], [0xA77E, 0xA77F], [0xA780, 0xA781], [0xA782, 0xA783], [0xA784, 0xA785], [0xA786, 0xA787], [0xA78B, 0xA78C], [0xA78D, 0x265], [0xA790, 0xA791], [0xA792, 0xA793], [0xA796, 0xA797], [0xA798, 0xA799], [0xA79A, 0xA79B], [0xA79C, 0xA79D], [0xA79E, 0xA79F], [0xA7A0, 0xA7A1], [0xA7A2, 0xA7A3], [0xA7A4, 0xA7A5], [0xA7A6, 0xA7A7], [0xA7A8, 0xA7A9], [0xA7AA, 0x266], [0xA7AB, 0x25C], [0xA7AC, 0x261], [0xA7AD, 0x26C], [0xA7AE, 0x26A], [0xA7B0, 0x29E], [0xA7B1, 0x287], [0xA7B2, 0x29D], [0xA7B3, 0xAB53], [0xA7B4, 0xA7B5], [0xA7B6, 0xA7B7], [0xA7B8, 0xA7B9], [0xA7BA, 0xA7BB], [0xA7BC, 0xA7BD], [0xA7BE, 0xA7BF], [0xA7C0, 0xA7C1], [0xA7C2, 0xA7C3], [0xA7C4, 0xA794], [0xA7C5, 0x282], [0xA7C6, 0x1D8E], [0xA7C7, 0xA7C8], [0xA7C9, 0xA7CA], [0xA7CB, 0x264], [0xA7CC, 0xA7CD], [0xA7D0, 0xA7D1], [0xA7D6, 0xA7D7], [0xA7D8, 0xA7D9], [0xA7DA, 0xA7DB], [0xA7DC, 0x19B], [0xA7F5, 0xA7F6], [0xAB70, 0x13A0], [0xAB71, 0x13A1], [0xAB72, 0x13A2], [0xAB73, 0x13A3], [0xAB74, 0x13A4], [0xAB75, 0x13A5], [0xAB76, 0x13A6], [0xAB77, 0x13A7], [0xAB78, 0x13A8], [0xAB79, 0x13A9], [0xAB7A, 0x13AA], [0xAB7B, 0x13AB], [0xAB7C, 0x13AC], [0xAB7D, 0x13AD], [0xAB7E, 0x13AE], [0xAB7F, 0x13AF], [0xAB80, 0x13B0], [0xAB81, 0x13B1], [0xAB82, 0x13B2], [0xAB83, 0x13B3], [0xAB84, 0x13B4], [0xAB85, 0x13B5], [0xAB86, 0x13B6], [0xAB87, 0x13B7], [0xAB88, 0x13B8], [0xAB89, 0x13B9], [0xAB8A, 0x13BA], [0xAB8B, 0x13BB], [0xAB8C, 0x13BC], [0xAB8D, 0x13BD], [0xAB8E, 0x13BE], [0xAB8F, 0x13BF], [0xAB90, 0x13C0], [0xAB91, 0x13C1], [0xAB92, 0x13C2], [0xAB93, 0x13C3], [0xAB94, 0x13C4], [0xAB95, 0x13C5], [0xAB96, 0x13C6], [0xAB97, 0x13C7], [0xAB98, 0x13C8], [0xAB99, 0x13C9], [0xAB9A, 0x13CA], [0xAB9B, 0x13CB], [0xAB9C, 0x13CC], [0xAB9D, 0x13CD], [0xAB9E, 0x13CE], [0xAB9F, 0x13CF], [0xABA0, 0x13D0], [0xABA1, 0x13D1], [0xABA2, 0x13D2], [0xABA3, 0x13D3], [0xABA4, 0x13D4], [0xABA5, 0x13D5], [0xABA6, 0x13D6], [0xABA7, 0x13D7], [0xABA8, 0x13D8], [0xABA9, 0x13D9], [0xABAA, 0x13DA], [0xABAB, 0x13DB], [0xABAC, 0x13DC], [0xABAD, 0x13DD], [0xABAE, 0x13DE], [0xABAF, 0x13DF], [0xABB0, 0x13E0], [0xABB1, 0x13E1], [0xABB2, 0x13E2], [0xABB3, 0x13E3], [0xABB4, 0x13E4], [0xABB5, 0x13E5], [0xABB6, 0x13E6], [0xABB7, 0x13E7], [0xABB8, 0x13E8], [0xABB9, 0x13E9], [0xABBA, 0x13EA], [0xABBB, 0x13EB], [0xABBC, 0x13EC], [0xABBD, 0x13ED], [0xABBE, 0x13EE], [0xABBF, 0x13EF], [0xFB05, 0xFB06], [0xFF21, 0xFF41], [0xFF22, 0xFF42], [0xFF23, 0xFF43], [0xFF24, 0xFF44], [0xFF25, 0xFF45], [0xFF26, 0xFF46], [0xFF27, 0xFF47], [0xFF28, 0xFF48], [0xFF29, 0xFF49], [0xFF2A, 0xFF4A], [0xFF2B, 0xFF4B], [0xFF2C, 0xFF4C], [0xFF2D, 0xFF4D], [0xFF2E, 0xFF4E], [0xFF2F, 0xFF4F], [0xFF30, 0xFF50], [0xFF31, 0xFF51], [0xFF32, 0xFF52], [0xFF33, 0xFF53], [0xFF34, 0xFF54], [0xFF35, 0xFF55], [0xFF36, 0xFF56], [0xFF37, 0xFF57], [0xFF38, 0xFF58], [0xFF39, 0xFF59], [0xFF3A, 0xFF5A], [0x10400, 0x10428], [0x10401, 0x10429], [0x10402, 0x1042A], [0x10403, 0x1042B], [0x10404, 0x1042C], [0x10405, 0x1042D], [0x10406, 0x1042E], [0x10407, 0x1042F], [0x10408, 0x10430], [0x10409, 0x10431], [0x1040A, 0x10432], [0x1040B, 0x10433], [0x1040C, 0x10434], [0x1040D, 0x10435], [0x1040E, 0x10436], [0x1040F, 0x10437], [0x10410, 0x10438], [0x10411, 0x10439], [0x10412, 0x1043A], [0x10413, 0x1043B], [0x10414, 0x1043C], [0x10415, 0x1043D], [0x10416, 0x1043E], [0x10417, 0x1043F], [0x10418, 0x10440], [0x10419, 0x10441], [0x1041A, 0x10442], [0x1041B, 0x10443], [0x1041C, 0x10444], [0x1041D, 0x10445], [0x1041E, 0x10446], [0x1041F, 0x10447], [0x10420, 0x10448], [0x10421, 0x10449], [0x10422, 0x1044A], [0x10423, 0x1044B], [0x10424, 0x1044C], [0x10425, 0x1044D], [0x10426, 0x1044E], [0x10427, 0x1044F], [0x104B0, 0x104D8], [0x104B1, 0x104D9], [0x104B2, 0x104DA], [0x104B3, 0x104DB], [0x104B4, 0x104DC], [0x104B5, 0x104DD], [0x104B6, 0x104DE], [0x104B7, 0x104DF], [0x104B8, 0x104E0], [0x104B9, 0x104E1], [0x104BA, 0x104E2], [0x104BB, 0x104E3], [0x104BC, 0x104E4], [0x104BD, 0x104E5], [0x104BE, 0x104E6], [0x104BF, 0x104E7], [0x104C0, 0x104E8], [0x104C1, 0x104E9], [0x104C2, 0x104EA], [0x104C3, 0x104EB], [0x104C4, 0x104EC], [0x104C5, 0x104ED], [0x104C6, 0x104EE], [0x104C7, 0x104EF], [0x104C8, 0x104F0], [0x104C9, 0x104F1], [0x104CA, 0x104F2], [0x104CB, 0x104F3], [0x104CC, 0x104F4], [0x104CD, 0x104F5], [0x104CE, 0x104F6], [0x104CF, 0x104F7], [0x104D0, 0x104F8], [0x104D1, 0x104F9], [0x104D2, 0x104FA], [0x104D3, 0x104FB], [0x10570, 0x10597], [0x10571, 0x10598], [0x10572, 0x10599], [0x10573, 0x1059A], [0x10574, 0x1059B], [0x10575, 0x1059C], [0x10576, 0x1059D], [0x10577, 0x1059E], [0x10578, 0x1059F], [0x10579, 0x105A0], [0x1057A, 0x105A1], [0x1057C, 0x105A3], [0x1057D, 0x105A4], [0x1057E, 0x105A5], [0x1057F, 0x105A6], [0x10580, 0x105A7], [0x10581, 0x105A8], [0x10582, 0x105A9], [0x10583, 0x105AA], [0x10584, 0x105AB], [0x10585, 0x105AC], [0x10586, 0x105AD], [0x10587, 0x105AE], [0x10588, 0x105AF], [0x10589, 0x105B0], [0x1058A, 0x105B1], [0x1058C, 0x105B3], [0x1058D, 0x105B4], [0x1058E, 0x105B5], [0x1058F, 0x105B6], [0x10590, 0x105B7], [0x10591, 0x105B8], [0x10592, 0x105B9], [0x10594, 0x105BB], [0x10595, 0x105BC], [0x10C80, 0x10CC0], [0x10C81, 0x10CC1], [0x10C82, 0x10CC2], [0x10C83, 0x10CC3], [0x10C84, 0x10CC4], [0x10C85, 0x10CC5], [0x10C86, 0x10CC6], [0x10C87, 0x10CC7], [0x10C88, 0x10CC8], [0x10C89, 0x10CC9], [0x10C8A, 0x10CCA], [0x10C8B, 0x10CCB], [0x10C8C, 0x10CCC], [0x10C8D, 0x10CCD], [0x10C8E, 0x10CCE], [0x10C8F, 0x10CCF], [0x10C90, 0x10CD0], [0x10C91, 0x10CD1], [0x10C92, 0x10CD2], [0x10C93, 0x10CD3], [0x10C94, 0x10CD4], [0x10C95, 0x10CD5], [0x10C96, 0x10CD6], [0x10C97, 0x10CD7], [0x10C98, 0x10CD8], [0x10C99, 0x10CD9], [0x10C9A, 0x10CDA], [0x10C9B, 0x10CDB], [0x10C9C, 0x10CDC], [0x10C9D, 0x10CDD], [0x10C9E, 0x10CDE], [0x10C9F, 0x10CDF], [0x10CA0, 0x10CE0], [0x10CA1, 0x10CE1], [0x10CA2, 0x10CE2], [0x10CA3, 0x10CE3], [0x10CA4, 0x10CE4], [0x10CA5, 0x10CE5], [0x10CA6, 0x10CE6], [0x10CA7, 0x10CE7], [0x10CA8, 0x10CE8], [0x10CA9, 0x10CE9], [0x10CAA, 0x10CEA], [0x10CAB, 0x10CEB], [0x10CAC, 0x10CEC], [0x10CAD, 0x10CED], [0x10CAE, 0x10CEE], [0x10CAF, 0x10CEF], [0x10CB0, 0x10CF0], [0x10CB1, 0x10CF1], [0x10CB2, 0x10CF2], [0x10D50, 0x10D70], [0x10D51, 0x10D71], [0x10D52, 0x10D72], [0x10D53, 0x10D73], [0x10D54, 0x10D74], [0x10D55, 0x10D75], [0x10D56, 0x10D76], [0x10D57, 0x10D77], [0x10D58, 0x10D78], [0x10D59, 0x10D79], [0x10D5A, 0x10D7A], [0x10D5B, 0x10D7B], [0x10D5C, 0x10D7C], [0x10D5D, 0x10D7D], [0x10D5E, 0x10D7E], [0x10D5F, 0x10D7F], [0x10D60, 0x10D80], [0x10D61, 0x10D81], [0x10D62, 0x10D82], [0x10D63, 0x10D83], [0x10D64, 0x10D84], [0x10D65, 0x10D85], [0x118A0, 0x118C0], [0x118A1, 0x118C1], [0x118A2, 0x118C2], [0x118A3, 0x118C3], [0x118A4, 0x118C4], [0x118A5, 0x118C5], [0x118A6, 0x118C6], [0x118A7, 0x118C7], [0x118A8, 0x118C8], [0x118A9, 0x118C9], [0x118AA, 0x118CA], [0x118AB, 0x118CB], [0x118AC, 0x118CC], [0x118AD, 0x118CD], [0x118AE, 0x118CE], [0x118AF, 0x118CF], [0x118B0, 0x118D0], [0x118B1, 0x118D1], [0x118B2, 0x118D2], [0x118B3, 0x118D3], [0x118B4, 0x118D4], [0x118B5, 0x118D5], [0x118B6, 0x118D6], [0x118B7, 0x118D7], [0x118B8, 0x118D8], [0x118B9, 0x118D9], [0x118BA, 0x118DA], [0x118BB, 0x118DB], [0x118BC, 0x118DC], [0x118BD, 0x118DD], [0x118BE, 0x118DE], [0x118BF, 0x118DF], [0x16E40, 0x16E60], [0x16E41, 0x16E61], [0x16E42, 0x16E62], [0x16E43, 0x16E63], [0x16E44, 0x16E64], [0x16E45, 0x16E65], [0x16E46, 0x16E66], [0x16E47, 0x16E67], [0x16E48, 0x16E68], [0x16E49, 0x16E69], [0x16E4A, 0x16E6A], [0x16E4B, 0x16E6B], [0x16E4C, 0x16E6C], [0x16E4D, 0x16E6D], [0x16E4E, 0x16E6E], [0x16E4F, 0x16E6F], [0x16E50, 0x16E70], [0x16E51, 0x16E71], [0x16E52, 0x16E72], [0x16E53, 0x16E73], [0x16E54, 0x16E74], [0x16E55, 0x16E75], [0x16E56, 0x16E76], [0x16E57, 0x16E77], [0x16E58, 0x16E78], [0x16E59, 0x16E79], [0x16E5A, 0x16E7A], [0x16E5B, 0x16E7B], [0x16E5C, 0x16E7C], [0x16E5D, 0x16E7D], [0x16E5E, 0x16E7E], [0x16E5F, 0x16E7F], [0x1E900, 0x1E922], [0x1E901, 0x1E923], [0x1E902, 0x1E924], [0x1E903, 0x1E925], [0x1E904, 0x1E926], [0x1E905, 0x1E927], [0x1E906, 0x1E928], [0x1E907, 0x1E929], [0x1E908, 0x1E92A], [0x1E909, 0x1E92B], [0x1E90A, 0x1E92C], [0x1E90B, 0x1E92D], [0x1E90C, 0x1E92E], [0x1E90D, 0x1E92F], [0x1E90E, 0x1E930], [0x1E90F, 0x1E931], [0x1E910, 0x1E932], [0x1E911, 0x1E933], [0x1E912, 0x1E934], [0x1E913, 0x1E935], [0x1E914, 0x1E936], [0x1E915, 0x1E937], [0x1E916, 0x1E938], [0x1E917, 0x1E939], [0x1E918, 0x1E93A], [0x1E919, 0x1E93B], [0x1E91A, 0x1E93C], [0x1E91B, 0x1E93D], [0x1E91C, 0x1E93E], [0x1E91D, 0x1E93F], [0x1E91E, 0x1E940], [0x1E91F, 0x1E941], [0x1E920, 0x1E942], [0x1E921, 0x1E943]]);

var characterClassEscapeSets = {};

var allCharacters = {};

var regenerate$2 = regenerateExports;
  allCharacters.UNICODE_SET = regenerate$2().addRange(0x0, 0x10FFFF);
  allCharacters.UNICODE_IV_SET = regenerate$2(0xD7, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x133, 0x135, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x17E, 0x180, 0x183, 0x185, 0x188, 0x192, 0x195, 0x19E, 0x1A1, 0x1A3, 0x1A5, 0x1A8, 0x1AD, 0x1B0, 0x1B4, 0x1B6, 0x1C6, 0x1C9, 0x1CC, 0x1CE, 0x1D0, 0x1D2, 0x1D4, 0x1D6, 0x1D8, 0x1DA, 0x1DF, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x1E9, 0x1EB, 0x1ED, 0x1F3, 0x1F5, 0x1F9, 0x1FB, 0x1FD, 0x1FF, 0x201, 0x203, 0x205, 0x207, 0x209, 0x20B, 0x20D, 0x20F, 0x211, 0x213, 0x215, 0x217, 0x219, 0x21B, 0x21D, 0x21F, 0x221, 0x223, 0x225, 0x227, 0x229, 0x22B, 0x22D, 0x22F, 0x231, 0x23C, 0x242, 0x247, 0x249, 0x24B, 0x24D, 0x371, 0x387, 0x38B, 0x38D, 0x390, 0x3A2, 0x3D7, 0x3D9, 0x3DB, 0x3DD, 0x3DF, 0x3E1, 0x3E3, 0x3E5, 0x3E7, 0x3E9, 0x3EB, 0x3ED, 0x3EF, 0x3F6, 0x3F8, 0x461, 0x463, 0x465, 0x467, 0x469, 0x46B, 0x46D, 0x46F, 0x471, 0x473, 0x475, 0x477, 0x479, 0x47B, 0x47D, 0x47F, 0x48B, 0x48D, 0x48F, 0x491, 0x493, 0x495, 0x497, 0x499, 0x49B, 0x49D, 0x49F, 0x4A1, 0x4A3, 0x4A5, 0x4A7, 0x4A9, 0x4AB, 0x4AD, 0x4AF, 0x4B1, 0x4B3, 0x4B5, 0x4B7, 0x4B9, 0x4BB, 0x4BD, 0x4BF, 0x4C2, 0x4C4, 0x4C6, 0x4C8, 0x4CA, 0x4CC, 0x4D1, 0x4D3, 0x4D5, 0x4D7, 0x4D9, 0x4DB, 0x4DD, 0x4DF, 0x4E1, 0x4E3, 0x4E5, 0x4E7, 0x4E9, 0x4EB, 0x4ED, 0x4EF, 0x4F1, 0x4F3, 0x4F5, 0x4F7, 0x4F9, 0x4FB, 0x4FD, 0x4FF, 0x501, 0x503, 0x505, 0x507, 0x509, 0x50B, 0x50D, 0x50F, 0x511, 0x513, 0x515, 0x517, 0x519, 0x51B, 0x51D, 0x51F, 0x521, 0x523, 0x525, 0x527, 0x529, 0x52B, 0x52D, 0x10C6, 0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1E9F, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9, 0x1EFB, 0x1EFD, 0x1F5A, 0x1F5C, 0x1F5E, 0x1FBD, 0x2C61, 0x2C68, 0x2C6A, 0x2C6C, 0x2C71, 0x2C81, 0x2C83, 0x2C85, 0x2C87, 0x2C89, 0x2C8B, 0x2C8D, 0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1, 0x2CA3, 0x2CA5, 0x2CA7, 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5, 0x2CB7, 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, 0x2CC9, 0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, 0x2CD9, 0x2CDB, 0x2CDD, 0x2CDF, 0x2CE1, 0x2CEC, 0xA641, 0xA643, 0xA645, 0xA647, 0xA649, 0xA64B, 0xA64D, 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B, 0xA65D, 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA681, 0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, 0xA691, 0xA693, 0xA695, 0xA697, 0xA699, 0xA723, 0xA725, 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA733, 0xA735, 0xA737, 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745, 0xA747, 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, 0xA759, 0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D, 0xA77A, 0xA77C, 0xA77F, 0xA781, 0xA783, 0xA785, 0xA78C, 0xA791, 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, 0xA7A7, 0xA7A9, 0xA7AF, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3, 0xA7C8, 0xA7CA, 0xA7D7, 0xA7D9, 0xA7DB, 0x1057B, 0x1058B, 0x10593).addRange(0x0, 0x40).addRange(0x5B, 0xB4).addRange(0xB6, 0xBF).addRange(0xDF, 0xFF).addRange(0x12F, 0x131).addRange(0x137, 0x138).addRange(0x148, 0x149).addRange(0x18C, 0x18D).addRange(0x199, 0x19B).addRange(0x1AA, 0x1AB).addRange(0x1B9, 0x1BB).addRange(0x1BD, 0x1C3).addRange(0x1DC, 0x1DD).addRange(0x1EF, 0x1F0).addRange(0x233, 0x239).addRange(0x23F, 0x240).addRange(0x24F, 0x344).addRange(0x346, 0x36F).addRange(0x373, 0x375).addRange(0x377, 0x37E).addRange(0x380, 0x385).addRange(0x3AC, 0x3C1).addRange(0x3C3, 0x3CE).addRange(0x3D2, 0x3D4).addRange(0x3F2, 0x3F3).addRange(0x3FB, 0x3FC).addRange(0x430, 0x45F).addRange(0x481, 0x489).addRange(0x4CE, 0x4CF).addRange(0x52F, 0x530).addRange(0x557, 0x109F).addRange(0x10C8, 0x10CC).addRange(0x10CE, 0x13F7).addRange(0x13FE, 0x1C7F).addRange(0x1C8A, 0x1C8F).addRange(0x1CBB, 0x1CBC).addRange(0x1CC0, 0x1DFF).addRange(0x1E95, 0x1E9A).addRange(0x1E9C, 0x1E9D).addRange(0x1EFF, 0x1F07).addRange(0x1F10, 0x1F17).addRange(0x1F1E, 0x1F27).addRange(0x1F30, 0x1F37).addRange(0x1F40, 0x1F47).addRange(0x1F4E, 0x1F58).addRange(0x1F60, 0x1F67).addRange(0x1F70, 0x1F87).addRange(0x1F90, 0x1F97).addRange(0x1FA0, 0x1FA7).addRange(0x1FB0, 0x1FB7).addRange(0x1FBF, 0x1FC7).addRange(0x1FCD, 0x1FD2).addRange(0x1FD4, 0x1FD7).addRange(0x1FDC, 0x1FE2).addRange(0x1FE4, 0x1FE7).addRange(0x1FED, 0x1FF7).addRange(0x1FFD, 0x2125).addRange(0x2127, 0x2129).addRange(0x212C, 0x2131).addRange(0x2133, 0x215F).addRange(0x2170, 0x2182).addRange(0x2184, 0x24B5).addRange(0x24D0, 0x2BFF).addRange(0x2C30, 0x2C5F).addRange(0x2C65, 0x2C66).addRange(0x2C73, 0x2C74).addRange(0x2C76, 0x2C7D).addRange(0x2CE3, 0x2CEA).addRange(0x2CEE, 0x2CF1).addRange(0x2CF3, 0xA63F).addRange(0xA66D, 0xA67F).addRange(0xA69B, 0xA721).addRange(0xA72F, 0xA731).addRange(0xA76F, 0xA778).addRange(0xA787, 0xA78A).addRange(0xA78E, 0xA78F).addRange(0xA793, 0xA795).addRange(0xA7CD, 0xA7CF).addRange(0xA7D1, 0xA7D5).addRange(0xA7DD, 0xA7F4).addRange(0xA7F6, 0xAB6F).addRange(0xABC0, 0xFB04).addRange(0xFB06, 0xFF20).addRange(0xFF3B, 0x103FF).addRange(0x10428, 0x104AF).addRange(0x104D4, 0x1056F).addRange(0x10596, 0x10C7F).addRange(0x10CB3, 0x10D4F).addRange(0x10D66, 0x1189F).addRange(0x118C0, 0x16E3F).addRange(0x16E60, 0x1E8FF).addRange(0x1E922, 0x10FFFF);

var regenerate$1 = regenerateExports;
  var UNICODE_IV_SET$1 = allCharacters.UNICODE_IV_SET;
  characterClassEscapeSets.REGULAR = new Map([['d', regenerate$1().addRange(0x30, 0x39)], ['D', regenerate$1().addRange(0x0, 0x2F).addRange(0x3A, 0xFFFF)], ['s', regenerate$1(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000, 0xFEFF).addRange(0x9, 0xD).addRange(0x2000, 0x200A).addRange(0x2028, 0x2029)], ['S', regenerate$1().addRange(0x0, 0x8).addRange(0xE, 0x1F).addRange(0x21, 0x9F).addRange(0xA1, 0x167F).addRange(0x1681, 0x1FFF).addRange(0x200B, 0x2027).addRange(0x202A, 0x202E).addRange(0x2030, 0x205E).addRange(0x2060, 0x2FFF).addRange(0x3001, 0xFEFE).addRange(0xFF00, 0xFFFF)], ['w', regenerate$1(0x5F).addRange(0x30, 0x39).addRange(0x41, 0x5A).addRange(0x61, 0x7A)], ['W', regenerate$1(0x60).addRange(0x0, 0x2F).addRange(0x3A, 0x40).addRange(0x5B, 0x5E).addRange(0x7B, 0xFFFF)]]);
  characterClassEscapeSets.UNICODE = new Map([['d', regenerate$1().addRange(0x30, 0x39)], ['D', regenerate$1().addRange(0x0, 0x2F).addRange(0x3A, 0x10FFFF)], ['s', regenerate$1(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000, 0xFEFF).addRange(0x9, 0xD).addRange(0x2000, 0x200A).addRange(0x2028, 0x2029)], ['S', regenerate$1().addRange(0x0, 0x8).addRange(0xE, 0x1F).addRange(0x21, 0x9F).addRange(0xA1, 0x167F).addRange(0x1681, 0x1FFF).addRange(0x200B, 0x2027).addRange(0x202A, 0x202E).addRange(0x2030, 0x205E).addRange(0x2060, 0x2FFF).addRange(0x3001, 0xFEFE).addRange(0xFF00, 0x10FFFF)], ['w', regenerate$1(0x5F).addRange(0x30, 0x39).addRange(0x41, 0x5A).addRange(0x61, 0x7A)], ['W', regenerate$1(0x60).addRange(0x0, 0x2F).addRange(0x3A, 0x40).addRange(0x5B, 0x5E).addRange(0x7B, 0x10FFFF)]]);
  characterClassEscapeSets.UNICODE_IGNORE_CASE = new Map([['d', regenerate$1().addRange(0x30, 0x39)], ['D', regenerate$1().addRange(0x0, 0x2F).addRange(0x3A, 0x10FFFF)], ['s', regenerate$1(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000, 0xFEFF).addRange(0x9, 0xD).addRange(0x2000, 0x200A).addRange(0x2028, 0x2029)], ['S', regenerate$1().addRange(0x0, 0x8).addRange(0xE, 0x1F).addRange(0x21, 0x9F).addRange(0xA1, 0x167F).addRange(0x1681, 0x1FFF).addRange(0x200B, 0x2027).addRange(0x202A, 0x202E).addRange(0x2030, 0x205E).addRange(0x2060, 0x2FFF).addRange(0x3001, 0xFEFE).addRange(0xFF00, 0x10FFFF)], ['w', regenerate$1(0x5F, 0x17F, 0x212A).addRange(0x30, 0x39).addRange(0x41, 0x5A).addRange(0x61, 0x7A)], ['W', regenerate$1(0x60).addRange(0x0, 0x2F).addRange(0x3A, 0x40).addRange(0x5B, 0x5E).addRange(0x7B, 0x17E).addRange(0x180, 0x2129).addRange(0x212B, 0x10FFFF)]]);
  characterClassEscapeSets.UNICODESET_IGNORE_CASE = new Map([['d', regenerate$1().addRange(0x30, 0x39)], ['D', UNICODE_IV_SET$1.clone().remove(regenerate$1().addRange(0x30, 0x39))], ['s', regenerate$1(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000, 0xFEFF).addRange(0x9, 0xD).addRange(0x2000, 0x200A).addRange(0x2028, 0x2029)], ['S', UNICODE_IV_SET$1.clone().remove(regenerate$1(0x20, 0xA0, 0x1680, 0x202F, 0x205F, 0x3000, 0xFEFF).addRange(0x9, 0xD).addRange(0x2000, 0x200A).addRange(0x2028, 0x2029))], ['w', regenerate$1(0x5F).addRange(0x30, 0x39).addRange(0x61, 0x7A)], ['W', UNICODE_IV_SET$1.clone().remove(regenerate$1(0x5F).addRange(0x30, 0x39).addRange(0x61, 0x7A))]]);

function bool$3(value) {
    if (value == null) return false;
    return value && value !== "false" && value !== "0";
  }
  var semver$6 = bool$3(browser$1$1.env["BABEL_8_BREAKING"]) ? requireSemver$2() : requireSemver$2();

var _templateObject$s;
  var _transformNullishCoalescingOperator = declare(function (api, _ref) {
    var _api$assumption, _api$assumption2;
    var _ref$loose = _ref.loose,
      loose = _ref$loose === void 0 ? false : _ref$loose;
    api.assertVersion("*");
    var noDocumentAll = (_api$assumption = api.assumption("noDocumentAll")) != null ? _api$assumption : loose;
    var pureGetters = (_api$assumption2 = api.assumption("pureGetters")) != null ? _api$assumption2 : false;
    return {
      name: "transform-nullish-coalescing-operator",
      manipulateOptions: function (_, parser) {
        return parser.plugins.push("nullishCoalescingOperator");
      },
      visitor: {
        LogicalExpression: function LogicalExpression(path) {
          var node = path.node,
            scope = path.scope;
          if (node.operator !== "??") {
            return;
          }
          var ref;
          var assignment;
          if (pureGetters && scope.path.isPattern() && isMemberExpression$7(node.left) && !node.left.computed && isIdentifier$e(node.left.object) && isIdentifier$e(node.left.property) || isIdentifier$e(node.left) && (pureGetters || scope.hasBinding(node.left.name))) {
            ref = node.left;
            assignment = cloneNode$e(node.left);
          } else if (scope.path.isPattern()) {
            path.replaceWith(template$1.statement.ast(_templateObject$s || (_templateObject$s = _taggedTemplateLiteralLoose(["(() => ", ")()"])), path.node));
            return;
          } else {
            ref = scope.generateUidIdentifierBasedOnNode(node.left);
            scope.push({
              id: cloneNode$e(ref)
            });
            assignment = assignmentExpression$8("=", ref, node.left);
          }
          path.replaceWith(conditionalExpression$5(noDocumentAll ? binaryExpression$4("!=", assignment, nullLiteral$2()) : logicalExpression$2("&&", binaryExpression$4("!==", assignment, nullLiteral$2()), binaryExpression$4("!==", cloneNode$e(ref), scope.buildUndefinedNode())), cloneNode$e(ref), node.right));
        }
      }
    };
  });

var compatData = {
    "Object.assign": {
      chrome: "49",
      opera: "36",
      edge: "13",
      firefox: "36",
      safari: "10",
      node: "6",
      deno: "1",
      ios: "10",
      samsung: "5",
      opera_mobile: "36",
      electron: "0.37"
    }
  };

var _templateObject$r;
  var last = function last(arr) {
    return arr[arr.length - 1];
  };
  function isSimpleMemberExpression(expression) {
    expression = skipTransparentExprWrapperNodes(expression);
    return isIdentifier$e(expression) || isSuper$2(expression) || isMemberExpression$7(expression) && !expression.computed && isSimpleMemberExpression(expression.object);
  }
  function needsMemoize(path) {
    var optionalPath = path;
    var scope = path.scope;
    while (optionalPath.isOptionalMemberExpression() || optionalPath.isOptionalCallExpression()) {
      var _optionalPath = optionalPath,
        node = _optionalPath.node;
      var childPath = skipTransparentExprWrappers(optionalPath.isOptionalMemberExpression() ? optionalPath.get("object") : optionalPath.get("callee"));
      if (node.optional) {
        return !scope.isStatic(childPath.node);
      }
      optionalPath = childPath;
    }
  }
  var NULLISH_CHECK = template$1.expression("%%check%% === null || %%ref%% === void 0");
  var NULLISH_CHECK_NO_DDA = template$1.expression("%%check%% == null");
  var NULLISH_CHECK_NEG = template$1.expression("%%check%% !== null && %%ref%% !== void 0");
  var NULLISH_CHECK_NO_DDA_NEG = template$1.expression("%%check%% != null");
  function transformOptionalChain(path, _ref, replacementPath, ifNullish, wrapLast) {
    var pureGetters = _ref.pureGetters,
      noDocumentAll = _ref.noDocumentAll;
    var scope = path.scope;
    if (scope.path.isPattern() && needsMemoize(path)) {
      replacementPath.replaceWith(template$1.expression.ast(_templateObject$r || (_templateObject$r = _taggedTemplateLiteralLoose(["(() => ", ")()"])), replacementPath.node));
      return;
    }
    var optionals = [];
    var optionalPath = path;
    while (optionalPath.isOptionalMemberExpression() || optionalPath.isOptionalCallExpression()) {
      var _optionalPath2 = optionalPath,
        node = _optionalPath2.node;
      if (node.optional) {
        optionals.push(node);
      }
      if (optionalPath.isOptionalMemberExpression()) {
        optionalPath.node.type = "MemberExpression";
        optionalPath = skipTransparentExprWrappers(optionalPath.get("object"));
      } else if (optionalPath.isOptionalCallExpression()) {
        optionalPath.node.type = "CallExpression";
        optionalPath = skipTransparentExprWrappers(optionalPath.get("callee"));
      }
    }
    if (optionals.length === 0) {
      return;
    }
    var checks = [];
    var tmpVar;
    for (var i = optionals.length - 1; i >= 0; i--) {
      var _node = optionals[i];
      var isCall = isCallExpression$8(_node);
      var chainWithTypes = isCall ? _node.callee : _node.object;
      var chain = skipTransparentExprWrapperNodes(chainWithTypes);
      var ref = void 0;
      var _check = void 0;
      if (isCall && isIdentifier$e(chain, {
        name: "eval"
      })) {
        _check = ref = chain;
        _node.callee = sequenceExpression$6([numericLiteral$5(0), ref]);
      } else if (pureGetters && isCall && isSimpleMemberExpression(chain)) {
        _check = ref = _node.callee;
      } else if (scope.isStatic(chain)) {
        _check = ref = chainWithTypes;
      } else {
        if (!tmpVar || isCall) {
          tmpVar = scope.generateUidIdentifierBasedOnNode(chain);
          scope.push({
            id: cloneNode$e(tmpVar)
          });
        }
        ref = tmpVar;
        _check = assignmentExpression$8("=", cloneNode$e(tmpVar), chainWithTypes);
        if (isCall) {
          _node.callee = ref;
        } else {
          _node.object = ref;
        }
      }
      if (isCall && isMemberExpression$7(chain)) {
        if (pureGetters && isSimpleMemberExpression(chain)) {
          _node.callee = chainWithTypes;
        } else {
          var object = chain.object;
          var context = void 0;
          if (isSuper$2(object)) {
            context = thisExpression$4();
          } else {
            var memoized = scope.maybeGenerateMemoised(object);
            if (memoized) {
              context = memoized;
              chain.object = assignmentExpression$8("=", memoized, object);
            } else {
              context = object;
            }
          }
          _node.arguments.unshift(cloneNode$e(context));
          _node.callee = memberExpression$9(_node.callee, identifier$d("call"));
        }
      }
      var data = {
        check: cloneNode$e(_check),
        ref: cloneNode$e(ref)
      };
      Object.defineProperty(data, "ref", {
        enumerable: false
      });
      checks.push(data);
    }
    var result = replacementPath.node;
    if (wrapLast) result = wrapLast(result);
    var ifNullishBoolean = isBooleanLiteral(ifNullish);
    var ifNullishFalse = ifNullishBoolean && ifNullish.value === false;
    var ifNullishVoid = !ifNullishBoolean && isUnaryExpression$1(ifNullish, {
      operator: "void"
    });
    var isEvaluationValueIgnored = isExpressionStatement$2(replacementPath.parent) && !replacementPath.isCompletionRecord() || isSequenceExpression$1(replacementPath.parent) && last(replacementPath.parent.expressions) !== replacementPath.node;
    var tpl = ifNullishFalse ? noDocumentAll ? NULLISH_CHECK_NO_DDA_NEG : NULLISH_CHECK_NEG : noDocumentAll ? NULLISH_CHECK_NO_DDA : NULLISH_CHECK;
    var logicalOp = ifNullishFalse ? "&&" : "||";
    var check = checks.map(tpl).reduce(function (expr, check) {
      return logicalExpression$2(logicalOp, expr, check);
    });
    replacementPath.replaceWith(ifNullishBoolean || ifNullishVoid && isEvaluationValueIgnored ? logicalExpression$2(logicalOp, check, result) : conditionalExpression$5(check, ifNullish, result));
  }
  function transform$1(path, assumptions) {
    var scope = path.scope;
    var maybeWrapped = findOutermostTransparentParent(path);
    var parentPath = maybeWrapped.parentPath;
    if (parentPath.isUnaryExpression({
      operator: "delete"
    })) {
      transformOptionalChain(path, assumptions, parentPath, booleanLiteral$2(true));
    } else {
      var wrapLast;
      if (parentPath.isCallExpression({
        callee: maybeWrapped.node
      }) && path.isOptionalMemberExpression()) {
        wrapLast = function wrapLast(replacement) {
          var _baseRef;
          var object = skipTransparentExprWrapperNodes(replacement.object);
          var baseRef;
          if (!assumptions.pureGetters || !isSimpleMemberExpression(object)) {
            baseRef = scope.maybeGenerateMemoised(object);
            if (baseRef) {
              replacement.object = assignmentExpression$8("=", baseRef, object);
            }
          }
          return callExpression$c(memberExpression$9(replacement, identifier$d("bind")), [cloneNode$e((_baseRef = baseRef) != null ? _baseRef : object)]);
        };
      }
      transformOptionalChain(path, assumptions, path, willPathCastToBoolean(maybeWrapped) ? booleanLiteral$2(false) : scope.buildUndefinedNode(), wrapLast);
    }
  }

var _templateObject$q, _templateObject2$d, _templateObject3$9, _templateObject4$4, _templateObject5$2, _templateObject6$1;
  var _transformPrivatePropertyInObject = declare(function (api, opt) {
    api.assertVersion("*");
    var t = api.types,
      template = api.template;
    var loose = opt.loose;
    var classWeakSets = new WeakMap();
    var fieldsWeakSets = new WeakMap();
    function unshadow(name, targetScope, scope) {
      while (scope !== targetScope) {
        if (scope.hasOwnBinding(name)) scope.rename(name);
        scope = scope.parent;
      }
    }
    function injectToFieldInit(fieldPath, expr, before) {
      if (before === void 0) {
        before = false;
      }
      if (fieldPath.node.value) {
        var value = fieldPath.get("value");
        if (before) {
          value.insertBefore(expr);
        } else {
          value.insertAfter(expr);
        }
      } else {
        fieldPath.set("value", t.unaryExpression("void", expr));
      }
    }
    function injectInitialization$1(classPath, init) {
      var firstFieldPath;
      var constructorPath;
      for (var _iterator = _createForOfIteratorHelperLoose(classPath.get("body.body")), _step; !(_step = _iterator()).done;) {
        var el = _step.value;
        if ((el.isClassProperty() || el.isClassPrivateProperty()) && !el.node["static"]) {
          firstFieldPath = el;
          break;
        }
        if (!constructorPath && el.isClassMethod({
          kind: "constructor"
        })) {
          constructorPath = el;
        }
      }
      if (firstFieldPath) {
        injectToFieldInit(firstFieldPath, init, true);
      } else {
        injectInitialization(classPath, constructorPath, [t.expressionStatement(init)]);
      }
    }
    function getWeakSetId(weakSets, outerClass, reference, name, inject) {
      if (name === void 0) {
        name = "";
      }
      var id = weakSets.get(reference.node);
      if (!id) {
        id = outerClass.scope.generateUidIdentifier((name || "") + " brandCheck");
        weakSets.set(reference.node, id);
        inject(reference, template.expression.ast(_templateObject$q || (_templateObject$q = _taggedTemplateLiteralLoose(["", ".add(this)"])), t.cloneNode(id)));
        var newExpr = t.newExpression(t.identifier("WeakSet"), []);
        annotateAsPure(newExpr);
        outerClass.insertBefore(template.ast(_templateObject2$d || (_templateObject2$d = _taggedTemplateLiteralLoose(["var ", " = ", ""])), id, newExpr));
      }
      return t.cloneNode(id);
    }
    return {
      name: "transform-private-property-in-object",
      manipulateOptions: function (_, parser) {
        return parser.plugins.push("privateIn");
      },
      pre: function pre() {
        enableFeature$1(this.file, FEATURES$1.privateIn, loose);
      },
      visitor: {
        BinaryExpression: function BinaryExpression(path, state) {
          var node = path.node;
          var file = state.file;
          if (node.operator !== "in") return;
          if (!t.isPrivateName(node.left)) return;
          var name = node.left.id.name;
          var privateElement;
          var outerClass = path.findParent(function (path) {
            if (!path.isClass()) return false;
            privateElement = path.get("body.body").find(function (_ref) {
              var node = _ref.node;
              return (t.isPrivate(node) && node.key.id.name === name
              );
            });
            return !!privateElement;
          });
          if (outerClass.parentPath.scope.path.isPattern()) {
            outerClass.replaceWith(template.ast(_templateObject3$9 || (_templateObject3$9 = _taggedTemplateLiteralLoose(["(() => ", ")()"])), outerClass.node));
            return;
          }
          if (privateElement.node.type === "ClassPrivateMethod") {
            if (privateElement.node["static"]) {
              if (outerClass.node.id) {
                unshadow(outerClass.node.id.name, outerClass.scope, path.scope);
              } else {
                outerClass.set("id", path.scope.generateUidIdentifier("class"));
              }
              path.replaceWith(template.expression.ast(_templateObject4$4 || (_templateObject4$4 = _taggedTemplateLiteralLoose(["\n                ", " === ", "\n              "])), t.cloneNode(outerClass.node.id), buildCheckInRHS(node.right, file)));
            } else {
              var _outerClass$node$id;
              var id = getWeakSetId(classWeakSets, outerClass, outerClass, (_outerClass$node$id = outerClass.node.id) == null ? void 0 : _outerClass$node$id.name, injectInitialization$1);
              path.replaceWith(template.expression.ast(_templateObject5$2 || (_templateObject5$2 = _taggedTemplateLiteralLoose(["", ".has(", ")"])), id, buildCheckInRHS(node.right, file)));
            }
          } else {
            var _id = getWeakSetId(fieldsWeakSets, outerClass, privateElement, privateElement.node.key.id.name, injectToFieldInit);
            path.replaceWith(template.expression.ast(_templateObject6$1 || (_templateObject6$1 = _taggedTemplateLiteralLoose(["", ".has(", ")"])), _id, buildCheckInRHS(node.right, file)));
          }
        }
      }
    };
  });

var transformRegExpModifiers = declare(function (api) {
    api.assertVersion("*");
    return createRegExpFeaturePlugin({
      name: "transform-regexp-modifiers",
      feature: "modifiers"
    });
  });

var _templateObject$p, _templateObject2$c, _templateObject3$8, _templateObject4$3;
  var collectLoopBodyBindingsVisitor = {
    "Expression|Declaration|Loop": function ExpressionDeclarationLoop(path) {
      path.skip();
    },
    Scope: function Scope(path, state) {
      if (path.isFunctionParent()) path.skip();
      var bindings = path.scope.bindings;
      for (var _i = 0, _Object$keys = Object.keys(bindings); _i < _Object$keys.length; _i++) {
        var name = _Object$keys[_i];
        var binding = bindings[name];
        if (binding.kind === "let" || binding.kind === "const" || binding.kind === "hoisted") {
          state.blockScoped.push(binding);
        }
      }
    }
  };
  function getLoopBodyBindings(loopPath) {
    var state = {
      blockScoped: []
    };
    loopPath.traverse(collectLoopBodyBindingsVisitor, state);
    return state.blockScoped;
  }
  function getUsageInBody(binding, loopPath) {
    var seen = new WeakSet();
    var capturedInClosure = false;
    var constantViolations = filterMap(binding.constantViolations, function (path) {
      var _relativeLoopLocation = relativeLoopLocation(path, loopPath),
        inBody = _relativeLoopLocation.inBody,
        inClosure = _relativeLoopLocation.inClosure;
      if (!inBody) return null;
      capturedInClosure || (capturedInClosure = inClosure);
      var id = path.isUpdateExpression() ? path.get("argument") : path.isAssignmentExpression() ? path.get("left") : null;
      if (id) seen.add(id.node);
      return id;
    });
    var references = filterMap(binding.referencePaths, function (path) {
      if (seen.has(path.node)) return null;
      var _relativeLoopLocation2 = relativeLoopLocation(path, loopPath),
        inBody = _relativeLoopLocation2.inBody,
        inClosure = _relativeLoopLocation2.inClosure;
      if (!inBody) return null;
      capturedInClosure || (capturedInClosure = inClosure);
      return path;
    });
    return {
      capturedInClosure: capturedInClosure,
      hasConstantViolations: constantViolations.length > 0,
      usages: references.concat(constantViolations)
    };
  }
  function relativeLoopLocation(path, loopPath) {
    var bodyPath = loopPath.get("body");
    var inClosure = false;
    for (var currPath = path; currPath; currPath = currPath.parentPath) {
      if (currPath.isFunction() || currPath.isClass() || currPath.isMethod()) {
        inClosure = true;
      }
      if (currPath === bodyPath) {
        return {
          inBody: true,
          inClosure: inClosure
        };
      } else if (currPath === loopPath) {
        return {
          inBody: false,
          inClosure: inClosure
        };
      }
    }
    throw new Error("Internal Babel error: path is not in loop. Please report this as a bug.");
  }
  var collectCompletionsAndVarsVisitor = {
    Function: function Function(path) {
      path.skip();
    },
    LabeledStatement: {
      enter: function enter(_ref, state) {
        var node = _ref.node;
        state.labelsStack.push(node.label.name);
      },
      exit: function exit(_ref2, state) {
        var node = _ref2.node;
        var popped = state.labelsStack.pop();
        if (popped !== node.label.name) {
          throw new Error("Assertion failure. Please report this bug to Babel.");
        }
      }
    },
    Loop: {
      enter: function enter(_, state) {
        state.labellessContinueTargets++;
        state.labellessBreakTargets++;
      },
      exit: function exit(_, state) {
        state.labellessContinueTargets--;
        state.labellessBreakTargets--;
      }
    },
    SwitchStatement: {
      enter: function enter(_, state) {
        state.labellessBreakTargets++;
      },
      exit: function exit(_, state) {
        state.labellessBreakTargets--;
      }
    },
    "BreakStatement|ContinueStatement": function BreakStatementContinueStatement(path, state) {
      var label = path.node.label;
      if (label) {
        if (state.labelsStack.includes(label.name)) return;
      } else if (path.isBreakStatement() ? state.labellessBreakTargets > 0 : state.labellessContinueTargets > 0) {
        return;
      }
      state.breaksContinues.push(path);
    },
    ReturnStatement: function ReturnStatement(path, state) {
      state.returns.push(path);
    },
    VariableDeclaration: function VariableDeclaration(path, state) {
      if (path.parent === state.loopNode && isVarInLoopHead(path)) return;
      if (path.node.kind === "var") state.vars.push(path);
    }
  };
  function wrapLoopBody(loopPath, captured, updatedBindingsUsages) {
    var loopNode = loopPath.node;
    var state = {
      breaksContinues: [],
      returns: [],
      labelsStack: [],
      labellessBreakTargets: 0,
      labellessContinueTargets: 0,
      vars: [],
      loopNode: loopNode
    };
    loopPath.traverse(collectCompletionsAndVarsVisitor, state);
    var callArgs = [];
    var closureParams = [];
    var updater = [];
    for (var _iterator = _createForOfIteratorHelperLoose(updatedBindingsUsages), _step; !(_step = _iterator()).done;) {
      var _step$value = _slicedToArray(_step.value, 2),
        _name2 = _step$value[0],
        updatedUsage = _step$value[1];
      callArgs.push(identifier$d(_name2));
      var innerName = loopPath.scope.generateUid(_name2);
      closureParams.push(identifier$d(innerName));
      updater.push(assignmentExpression$8("=", identifier$d(_name2), identifier$d(innerName)));
      for (var _iterator7 = _createForOfIteratorHelperLoose(updatedUsage), _step7; !(_step7 = _iterator7()).done;) {
        var _path3 = _step7.value;
        _path3.replaceWith(identifier$d(innerName));
      }
    }
    for (var _iterator2 = _createForOfIteratorHelperLoose(captured), _step2; !(_step2 = _iterator2()).done;) {
      var _name3 = _step2.value;
      if (updatedBindingsUsages.has(_name3)) continue;
      callArgs.push(identifier$d(_name3));
      closureParams.push(identifier$d(_name3));
    }
    var id = loopPath.scope.generateUid("loop");
    var fn = functionExpression$2(null, closureParams, toBlock(loopNode.body));
    var call = callExpression$c(identifier$d(id), callArgs);
    var fnParent = loopPath.findParent(function (p) {
      return p.isFunction();
    });
    if (fnParent) {
      var _ref3 = fnParent.node,
        async = _ref3.async,
        generator = _ref3.generator;
      fn.async = async;
      fn.generator = generator;
      if (generator) call = yieldExpression$2(call, true);else if (async) call = awaitExpression$1(call);
    }
    var updaterNode = updater.length > 0 ? expressionStatement$7(sequenceExpression$6(updater)) : null;
    if (updaterNode) fn.body.body.push(updaterNode);
    var _ref4 = loopPath.insertBefore(variableDeclaration$6("var", [variableDeclarator$6(identifier$d(id), fn)])),
      _ref5 = _slicedToArray(_ref4, 1),
      varPath = _ref5[0];
    var bodyStmts = [];
    var varNames = [];
    for (var _iterator3 = _createForOfIteratorHelperLoose(state.vars), _step3; !(_step3 = _iterator3()).done;) {
      var _varPath = _step3.value;
      var assign = [];
      for (var _iterator8 = _createForOfIteratorHelperLoose(_varPath.node.declarations), _step8; !(_step8 = _iterator8()).done;) {
        var decl = _step8.value;
        varNames.push.apply(varNames, _toConsumableArray(Object.keys(getBindingIdentifiers$4(decl.id))));
        if (decl.init) {
          assign.push(assignmentExpression$8("=", decl.id, decl.init));
        } else if (isForXStatement$1(_varPath.parent, {
          left: _varPath.node
        })) {
          assign.push(decl.id);
        }
      }
      if (assign.length > 0) {
        var replacement = assign.length === 1 ? assign[0] : sequenceExpression$6(assign);
        _varPath.replaceWith(replacement);
      } else {
        _varPath.remove();
      }
    }
    if (varNames.length) {
      varPath.pushContainer("declarations", varNames.map(function (name) {
        return variableDeclarator$6(identifier$d(name));
      }));
    }
    var labelNum = state.breaksContinues.length;
    var returnNum = state.returns.length;
    if (labelNum + returnNum === 0) {
      bodyStmts.push(expressionStatement$7(call));
    } else if (labelNum === 1 && returnNum === 0) {
      for (var _iterator4 = _createForOfIteratorHelperLoose(state.breaksContinues), _step4; !(_step4 = _iterator4()).done;) {
        var path = _step4.value;
        var node = path.node;
        var type = node.type,
          label = node.label;
        var name = type === "BreakStatement" ? "break" : "continue";
        if (label) name += " " + label.name;
        path.replaceWith(addComment$2(returnStatement$3(numericLiteral$5(1)), "trailing", " " + name, true));
        if (updaterNode) path.insertBefore(cloneNode$e(updaterNode));
        bodyStmts.push(template$1.statement.ast(_templateObject$p || (_templateObject$p = _taggedTemplateLiteralLoose(["\n        if (", ") ", "\n      "])), call, node));
      }
    } else {
      var completionId = loopPath.scope.generateUid("ret");
      if (varPath.isVariableDeclaration()) {
        varPath.pushContainer("declarations", [variableDeclarator$6(identifier$d(completionId))]);
        bodyStmts.push(expressionStatement$7(assignmentExpression$8("=", identifier$d(completionId), call)));
      } else {
        bodyStmts.push(variableDeclaration$6("var", [variableDeclarator$6(identifier$d(completionId), call)]));
      }
      var injected = [];
      for (var _iterator5 = _createForOfIteratorHelperLoose(state.breaksContinues), _step5; !(_step5 = _iterator5()).done;) {
        var _path2 = _step5.value;
        var _node = _path2.node;
        var _type = _node.type,
          _label = _node.label;
        var _name = _type === "BreakStatement" ? "break" : "continue";
        if (_label) _name += " " + _label.name;
        var i = injected.indexOf(_name);
        var hasInjected = i !== -1;
        if (!hasInjected) {
          injected.push(_name);
          i = injected.length - 1;
        }
        _path2.replaceWith(addComment$2(returnStatement$3(numericLiteral$5(i)), "trailing", " " + _name, true));
        if (updaterNode) _path2.insertBefore(cloneNode$e(updaterNode));
        if (hasInjected) continue;
        bodyStmts.push(template$1.statement.ast(_templateObject4$3 || (_templateObject4$3 = _taggedTemplateLiteralLoose(["\n        if (", " === ", ") ", "\n      "])), identifier$d(completionId), numericLiteral$5(i), _node));
      }
      if (returnNum) {
        for (var _iterator6 = _createForOfIteratorHelperLoose(state.returns), _step6; !(_step6 = _iterator6()).done;) {
          var _path = _step6.value;
          var arg = _path.node.argument || _path.scope.buildUndefinedNode();
          _path.replaceWith(template$1.statement.ast(_templateObject3$8 || (_templateObject3$8 = _taggedTemplateLiteralLoose(["\n          return { v: ", " };\n        "])), arg));
        }
        bodyStmts.push(template$1.statement.ast(_templateObject2$c || (_templateObject2$c = _taggedTemplateLiteralLoose(["\n          if (", ") return ", ".v;\n        "])), identifier$d(completionId), identifier$d(completionId)));
      }
    }
    loopNode.body = blockStatement$6(bodyStmts);
    return varPath;
  }
  function isVarInLoopHead(path) {
    if (isForStatement$2(path.parent)) return path.key === "init";
    if (isForXStatement$1(path.parent)) return path.key === "left";
    return false;
  }
  function filterMap(list, fn) {
    var result = [];
    for (var _iterator9 = _createForOfIteratorHelperLoose(list), _step9; !(_step9 = _iterator9()).done;) {
      var item = _step9.value;
      var mapped = fn(item);
      if (mapped) result.push(mapped);
    }
    return result;
  }

function bool$2(value) {
    if (value == null) return false;
    return value && value !== "false" && value !== "0";
  }
  var globals = bool$2(browser$1$1.env["BABEL_8_BREAKING"]) ? requireGlobalsBABEL_8_BREAKINGFalse() : requireGlobalsBABEL_8_BREAKINGFalse();

var _templateObject$o;
  var helper$1 = template$1.statement(_templateObject$o || (_templateObject$o = _taggedTemplateLiteralLoose(["\n  function CALL_SUPER(\n    _this,\n    derived,\n    args,\n  ) {\n    function isNativeReflectConstruct() {\n      if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n\n      // core-js@3\n      if (Reflect.construct.sham) return false;\n\n      // Proxy can't be polyfilled. Every browser implemented\n      // proxies before or at the same time as Reflect.construct,\n      // so if they support Proxy they also support Reflect.construct.\n      if (typeof Proxy === \"function\") return true;\n\n      // Since Reflect.construct can't be properly polyfilled, some\n      // implementations (e.g. core-js@2) don't set the correct internal slots.\n      // Those polyfills don't allow us to subclass built-ins, so we need to\n      // use our fallback implementation.\n      try {\n        // If the internal slots aren't set, this throws an error similar to\n        //   TypeError: this is not a Boolean object.\n        return !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}),);\n      } catch (e) {\n        return false;\n      }\n    }\n\n    // Super\n    derived = GET_PROTOTYPE_OF(derived);\n    return POSSIBLE_CONSTRUCTOR_RETURN(\n      _this,\n      isNativeReflectConstruct()\n        ? // NOTE: This doesn't work if this.__proto__.constructor has been modified.\n          Reflect.construct(\n            derived,\n            args || [],\n            GET_PROTOTYPE_OF(_this).constructor,\n          )\n        : derived.apply(_this, args),\n    );\n  }\n"])));
  var helperIDs = new WeakMap();
  function addCallSuperHelper(file) {
    if (helperIDs.has(file)) {
      return (cloneNode$e || clone)(helperIDs.get(file));
    }
    try {
      return file.addHelper("callSuper");
    } catch (_unused) {}
    var id = file.scope.generateUidIdentifier("callSuper");
    helperIDs.set(file, id);
    var fn = helper$1({
      CALL_SUPER: id,
      GET_PROTOTYPE_OF: file.addHelper("getPrototypeOf"),
      POSSIBLE_CONSTRUCTOR_RETURN: file.addHelper("possibleConstructorReturn")
    });
    file.path.unshiftContainer("body", [fn]);
    file.scope.registerDeclaration(file.path.get("body.0"));
    return cloneNode$e(id);
  }

var _templateObject$n;
  function buildConstructor(classRef, constructorBody, node) {
    var func = functionDeclaration(cloneNode$e(classRef), [], constructorBody);
    inherits$3(func, node);
    return func;
  }
  function transformClass(path, file, builtinClasses, isLoose, assumptions, supportUnicodeId) {
    var classState = {
      parent: undefined,
      scope: undefined,
      node: undefined,
      path: undefined,
      file: undefined,
      classId: undefined,
      classRef: undefined,
      superName: null,
      superReturns: [],
      isDerived: false,
      extendsNative: false,
      construct: undefined,
      constructorBody: undefined,
      userConstructor: undefined,
      userConstructorPath: undefined,
      hasConstructor: false,
      body: [],
      superThises: [],
      pushedInherits: false,
      pushedCreateClass: false,
      protoAlias: null,
      isLoose: false,
      dynamicKeys: new Map(),
      methods: {
        instance: {
          hasComputed: false,
          list: [],
          map: new Map()
        },
        "static": {
          hasComputed: false,
          list: [],
          map: new Map()
        }
      }
    };
    var setState = function setState(newState) {
      Object.assign(classState, newState);
    };
    var findThisesVisitor = environmentVisitor({
      ThisExpression: function ThisExpression(path) {
        classState.superThises.push(path);
      }
    });
    function createClassHelper(args) {
      return callExpression$c(classState.file.addHelper("createClass"), args);
    }
    function maybeCreateConstructor() {
      var classBodyPath = classState.path.get("body");
      for (var _iterator = _createForOfIteratorHelperLoose(classBodyPath.get("body")), _step; !(_step = _iterator()).done;) {
        var _path = _step.value;
        if (_path.isClassMethod({
          kind: "constructor"
        })) return;
      }
      var params, body;
      if (classState.isDerived) {
        var constructor = template$1.expression.ast(_templateObject$n || (_templateObject$n = _taggedTemplateLiteralLoose(["\n        (function () {\n          super(...arguments);\n        })\n      "])));
        params = constructor.params;
        body = constructor.body;
      } else {
        params = [];
        body = blockStatement$6([]);
      }
      classBodyPath.unshiftContainer("body", classMethod("constructor", identifier$d("constructor"), params, body));
    }
    function buildBody() {
      maybeCreateConstructor();
      pushBody();
      verifyConstructor();
      if (classState.userConstructor) {
        var _constructorBody$body;
        var constructorBody = classState.constructorBody,
          userConstructor = classState.userConstructor,
          construct = classState.construct;
        (_constructorBody$body = constructorBody.body).push.apply(_constructorBody$body, _toConsumableArray(userConstructor.body.body));
        inherits$3(construct, userConstructor);
        inherits$3(constructorBody, userConstructor.body);
      }
      pushDescriptors();
    }
    function pushBody() {
      var classBodyPaths = classState.path.get("body.body");
      var _loop = function _loop() {
        var path = _step2.value;
        var node = path.node;
        if (path.isClassProperty() || path.isClassPrivateProperty()) {
          throw path.buildCodeFrameError("Missing class properties transform.");
        }
        if (node.decorators) {
          throw path.buildCodeFrameError("Method has decorators, put the decorator plugin before the classes one.");
        }
        if (isClassMethod(node)) {
          var isConstructor = node.kind === "constructor";
          var replaceSupers = new ReplaceSupers({
            methodPath: path,
            objectRef: classState.classRef,
            superRef: classState.superName,
            constantSuper: assumptions.constantSuper,
            file: classState.file,
            refToPreserve: classState.classRef
          });
          replaceSupers.replace();
          var superReturns = [];
          path.traverse(environmentVisitor({
            ReturnStatement: function ReturnStatement(path) {
              if (!path.getFunctionParent().isArrowFunctionExpression()) {
                superReturns.push(path);
              }
            }
          }));
          if (isConstructor) {
            pushConstructor(superReturns, node, path);
          } else {
            path.ensureFunctionName(supportUnicodeId);
            var wrapped;
            if (node !== path.node) {
              wrapped = path.node;
              path.replaceWith(node);
            }
            pushMethod(node, wrapped);
          }
        }
      };
      for (var _iterator2 = _createForOfIteratorHelperLoose(classBodyPaths), _step2; !(_step2 = _iterator2()).done;) {
        _loop();
      }
    }
    function pushDescriptors() {
      pushInheritsToBody();
      var body = classState.body;
      var props = {
        instance: null,
        "static": null
      };
      for (var _iterator3 = _createForOfIteratorHelperLoose(["static", "instance"]), _step3; !(_step3 = _iterator3()).done;) {
        var placement = _step3.value;
        if (classState.methods[placement].list.length) {
          props[placement] = classState.methods[placement].list.map(function (desc) {
            var obj = objectExpression$3([objectProperty$1(identifier$d("key"), desc.key)]);
            for (var _iterator4 = _createForOfIteratorHelperLoose(["get", "set", "value"]), _step4; !(_step4 = _iterator4()).done;) {
              var kind = _step4.value;
              if (desc[kind] != null) {
                obj.properties.push(objectProperty$1(identifier$d(kind), desc[kind]));
              }
            }
            return obj;
          });
        }
      }
      if (props.instance || props["static"]) {
        var args = [cloneNode$e(classState.classRef), props.instance ? arrayExpression$1(props.instance) : nullLiteral$2(), props["static"] ? arrayExpression$1(props["static"]) : nullLiteral$2()];
        var lastNonNullIndex = 0;
        for (var i = 0; i < args.length; i++) {
          if (!isNullLiteral$1(args[i])) lastNonNullIndex = i;
        }
        args = args.slice(0, lastNonNullIndex + 1);
        body.push(returnStatement$3(createClassHelper(args)));
        classState.pushedCreateClass = true;
      }
    }
    function wrapSuperCall(bareSuper, superRef, thisRef, body) {
      var bareSuperNode = bareSuper.node;
      var call;
      if (assumptions.superIsCallableConstructor) {
        bareSuperNode.arguments.unshift(thisExpression$4());
        if (bareSuperNode.arguments.length === 2 && isSpreadElement$1(bareSuperNode.arguments[1]) && isIdentifier$e(bareSuperNode.arguments[1].argument, {
          name: "arguments"
        })) {
          bareSuperNode.arguments[1] = bareSuperNode.arguments[1].argument;
          bareSuperNode.callee = memberExpression$9(cloneNode$e(superRef), identifier$d("apply"));
        } else {
          bareSuperNode.callee = memberExpression$9(cloneNode$e(superRef), identifier$d("call"));
        }
        call = logicalExpression$2("||", bareSuperNode, thisExpression$4());
      } else {
        var _bareSuperNode$argume;
        var args = [thisExpression$4(), cloneNode$e(classState.classRef)];
        if ((_bareSuperNode$argume = bareSuperNode.arguments) != null && _bareSuperNode$argume.length) {
          var bareSuperNodeArguments = bareSuperNode.arguments;
          if (bareSuperNodeArguments.length === 1 && isSpreadElement$1(bareSuperNodeArguments[0]) && isIdentifier$e(bareSuperNodeArguments[0].argument, {
            name: "arguments"
          })) {
            args.push(bareSuperNodeArguments[0].argument);
          } else {
            args.push(arrayExpression$1(bareSuperNodeArguments));
          }
        }
        call = callExpression$c(addCallSuperHelper(classState.file), args);
      }
      if (bareSuper.parentPath.isExpressionStatement() && bareSuper.parentPath.container === body.node.body && body.node.body.length - 1 === bareSuper.parentPath.key) {
        if (classState.superThises.length) {
          call = assignmentExpression$8("=", thisRef(), call);
        }
        bareSuper.parentPath.replaceWith(returnStatement$3(call));
      } else {
        bareSuper.replaceWith(assignmentExpression$8("=", thisRef(), call));
      }
    }
    function verifyConstructor() {
      if (!classState.isDerived) return;
      var path = classState.userConstructorPath;
      var body = path.get("body");
      var constructorBody = path.get("body");
      var maxGuaranteedSuperBeforeIndex = constructorBody.node.body.length;
      path.traverse(findThisesVisitor);
      var _thisRef = function thisRef() {
        var ref = path.scope.generateDeclaredUidIdentifier("this");
        maxGuaranteedSuperBeforeIndex++;
        _thisRef = function thisRef() {
          return cloneNode$e(ref);
        };
        return ref;
      };
      var buildAssertThisInitialized = function buildAssertThisInitialized() {
        return callExpression$c(classState.file.addHelper("assertThisInitialized"), [_thisRef()]);
      };
      var bareSupers = [];
      path.traverse(environmentVisitor({
        Super: function Super(path) {
          var node = path.node,
            parentPath = path.parentPath;
          if (parentPath.isCallExpression({
            callee: node
          })) {
            bareSupers.unshift(parentPath);
          }
        }
      }));
      var _loop2 = function _loop2() {
        var bareSuper = _bareSupers[_i];
        wrapSuperCall(bareSuper, classState.superName, _thisRef, body);
        if (maxGuaranteedSuperBeforeIndex >= 0) {
          var lastParentPath;
          bareSuper.find(function (parentPath) {
            if (parentPath === constructorBody) {
              maxGuaranteedSuperBeforeIndex = Math.min(maxGuaranteedSuperBeforeIndex, lastParentPath.key);
              return true;
            }
            var type = parentPath.type;
            switch (type) {
              case "ExpressionStatement":
              case "SequenceExpression":
              case "AssignmentExpression":
              case "BinaryExpression":
              case "MemberExpression":
              case "CallExpression":
              case "NewExpression":
              case "VariableDeclarator":
              case "VariableDeclaration":
              case "BlockStatement":
              case "ArrayExpression":
              case "ObjectExpression":
              case "ObjectProperty":
              case "TemplateLiteral":
                lastParentPath = parentPath;
                return false;
              default:
                if (type === "LogicalExpression" && parentPath.node.left === lastParentPath.node || parentPath.isConditional() && parentPath.node.test === lastParentPath.node || type === "OptionalCallExpression" && parentPath.node.callee === lastParentPath.node || type === "OptionalMemberExpression" && parentPath.node.object === lastParentPath.node) {
                  lastParentPath = parentPath;
                  return false;
                }
            }
            maxGuaranteedSuperBeforeIndex = -1;
            return true;
          });
        }
      };
      for (var _i = 0, _bareSupers = bareSupers; _i < _bareSupers.length; _i++) {
        _loop2();
      }
      var guaranteedCalls = new Set();
      var _loop3 = function _loop3() {
        var thisPath = _step5.value;
        var node = thisPath.node,
          parentPath = thisPath.parentPath;
        if (parentPath.isMemberExpression({
          object: node
        })) {
          thisPath.replaceWith(_thisRef());
          return 1;
        }
        var thisIndex;
        thisPath.find(function (parentPath) {
          if (parentPath.parentPath === constructorBody) {
            thisIndex = parentPath.key;
            return true;
          }
        });
        var exprPath = thisPath.parentPath.isSequenceExpression() ? thisPath.parentPath : thisPath;
        if (exprPath.listKey === "arguments" && (exprPath.parentPath.isCallExpression() || exprPath.parentPath.isOptionalCallExpression())) {
          exprPath = exprPath.parentPath;
        } else {
          exprPath = null;
        }
        if (maxGuaranteedSuperBeforeIndex !== -1 && thisIndex > maxGuaranteedSuperBeforeIndex || guaranteedCalls.has(exprPath)) {
          thisPath.replaceWith(_thisRef());
        } else {
          if (exprPath) {
            guaranteedCalls.add(exprPath);
          }
          thisPath.replaceWith(buildAssertThisInitialized());
        }
      };
      for (var _iterator5 = _createForOfIteratorHelperLoose(classState.superThises), _step5; !(_step5 = _iterator5()).done;) {
        if (_loop3()) continue;
      }
      var wrapReturn;
      if (classState.isLoose) {
        wrapReturn = function wrapReturn(returnArg) {
          var thisExpr = buildAssertThisInitialized();
          return returnArg ? logicalExpression$2("||", returnArg, thisExpr) : thisExpr;
        };
      } else {
        wrapReturn = function wrapReturn(returnArg) {
          var returnParams = [_thisRef()];
          if (returnArg != null) {
            returnParams.push(returnArg);
          }
          return callExpression$c(classState.file.addHelper("possibleConstructorReturn"), returnParams);
        };
      }
      var bodyPaths = body.get("body");
      var guaranteedSuperBeforeFinish = maxGuaranteedSuperBeforeIndex !== -1 && maxGuaranteedSuperBeforeIndex < bodyPaths.length;
      if (!bodyPaths.length || !bodyPaths.pop().isReturnStatement()) {
        body.pushContainer("body", returnStatement$3(guaranteedSuperBeforeFinish ? _thisRef() : buildAssertThisInitialized()));
      }
      for (var _iterator6 = _createForOfIteratorHelperLoose(classState.superReturns), _step6; !(_step6 = _iterator6()).done;) {
        var returnPath = _step6.value;
        returnPath.get("argument").replaceWith(wrapReturn(returnPath.node.argument));
      }
    }
    function pushMethod(node, wrapped) {
      if (node.kind === "method") {
        if (processMethod(node)) return;
      }
      var placement = node["static"] ? "static" : "instance";
      var methods = classState.methods[placement];
      var descKey = node.kind === "method" ? "value" : node.kind;
      var key = isNumericLiteral(node.key) || isBigIntLiteral(node.key) ? stringLiteral$6(String(node.key.value)) : toComputedKey$1(node);
      methods.hasComputed = !isStringLiteral$5(key);
      var fn = wrapped != null ? wrapped : toExpression$1(node);
      var descriptor;
      if (!methods.hasComputed && methods.map.has(key.value)) {
        descriptor = methods.map.get(key.value);
        descriptor[descKey] = fn;
        if (descKey === "value") {
          descriptor.get = null;
          descriptor.set = null;
        } else {
          descriptor.value = null;
        }
      } else {
        var _descriptor;
        descriptor = (_descriptor = {
          key: key
        }, _descriptor[descKey] = fn, _descriptor);
        methods.list.push(descriptor);
        if (!methods.hasComputed) {
          methods.map.set(key.value, descriptor);
        }
      }
    }
    function processMethod(node) {
      if (assumptions.setClassMethods && !node.decorators) {
        var classRef = classState.classRef;
        if (!node["static"]) {
          insertProtoAliasOnce();
          classRef = classState.protoAlias;
        }
        var methodName = memberExpression$9(cloneNode$e(classRef), node.key, node.computed || isLiteral$4(node.key));
        var func = functionExpression$2(node.id, node.params, node.body, node.generator, node.async);
        inherits$3(func, node);
        var expr = expressionStatement$7(assignmentExpression$8("=", methodName, func));
        inheritsComments$1(expr, node);
        classState.body.push(expr);
        return true;
      }
      return false;
    }
    function insertProtoAliasOnce() {
      if (classState.protoAlias === null) {
        setState({
          protoAlias: classState.scope.generateUidIdentifier("proto")
        });
        var classProto = memberExpression$9(classState.classRef, identifier$d("prototype"));
        var protoDeclaration = variableDeclaration$6("var", [variableDeclarator$6(classState.protoAlias, classProto)]);
        classState.body.push(protoDeclaration);
      }
    }
    function pushConstructor(superReturns, method, path) {
      setState({
        userConstructorPath: path,
        userConstructor: method,
        hasConstructor: true,
        superReturns: superReturns
      });
      var construct = classState.construct;
      inheritsComments$1(construct, method);
      construct.params = method.params;
      inherits$3(construct.body, method.body);
      construct.body.directives = method.body.directives;
      if (classState.hasInstanceDescriptors || classState.hasStaticDescriptors) {
        pushDescriptors();
      }
      pushInheritsToBody();
    }
    function pushInheritsToBody() {
      if (!classState.isDerived || classState.pushedInherits) return;
      classState.pushedInherits = true;
      classState.body.unshift(expressionStatement$7(callExpression$c(classState.file.addHelper(classState.isLoose ? "inheritsLoose" : "inherits"), [cloneNode$e(classState.classRef), cloneNode$e(classState.superName)])));
    }
    function extractDynamicKeys() {
      var dynamicKeys = classState.dynamicKeys,
        node = classState.node,
        scope = classState.scope;
      for (var _iterator7 = _createForOfIteratorHelperLoose(node.body.body), _step7; !(_step7 = _iterator7()).done;) {
        var elem = _step7.value;
        if (!isClassMethod(elem) || !elem.computed) continue;
        if (scope.isPure(elem.key, true)) continue;
        var id = scope.generateUidIdentifierBasedOnNode(elem.key);
        dynamicKeys.set(id.name, elem.key);
        elem.key = id;
      }
    }
    function setupClosureParamsArgs() {
      var superName = classState.superName,
        dynamicKeys = classState.dynamicKeys;
      var closureParams = [];
      var closureArgs = [];
      if (classState.isDerived) {
        var arg = cloneNode$e(superName);
        if (classState.extendsNative) {
          arg = callExpression$c(classState.file.addHelper("wrapNativeSuper"), [arg]);
          annotateAsPure(arg);
        }
        var param = classState.scope.generateUidIdentifierBasedOnNode(superName);
        closureParams.push(param);
        closureArgs.push(arg);
        setState({
          superName: cloneNode$e(param)
        });
      }
      for (var _iterator8 = _createForOfIteratorHelperLoose(dynamicKeys), _step8; !(_step8 = _iterator8()).done;) {
        var _step8$value = _slicedToArray(_step8.value, 2),
          name = _step8$value[0],
          value = _step8$value[1];
        closureParams.push(identifier$d(name));
        closureArgs.push(value);
      }
      return {
        closureParams: closureParams,
        closureArgs: closureArgs
      };
    }
    function classTransformer(path, file, builtinClasses, isLoose) {
      setState({
        parent: path.parent,
        scope: path.scope,
        node: path.node,
        path: path,
        file: file,
        isLoose: isLoose
      });
      setState({
        classId: classState.node.id,
        classRef: classState.node.id ? identifier$d(classState.node.id.name) : classState.scope.generateUidIdentifier("class"),
        superName: classState.node.superClass,
        isDerived: !!classState.node.superClass,
        constructorBody: blockStatement$6([])
      });
      setState({
        extendsNative: isIdentifier$e(classState.superName) && builtinClasses.has(classState.superName.name) && !classState.scope.hasBinding(classState.superName.name, true)
      });
      var classRef = classState.classRef,
        node = classState.node,
        constructorBody = classState.constructorBody;
      setState({
        construct: buildConstructor(classRef, constructorBody, node)
      });
      extractDynamicKeys();
      var body = classState.body;
      var _setupClosureParamsAr = setupClosureParamsArgs(),
        closureParams = _setupClosureParamsAr.closureParams,
        closureArgs = _setupClosureParamsAr.closureArgs;
      buildBody();
      if (!assumptions.noClassCalls) {
        constructorBody.body.unshift(expressionStatement$7(callExpression$c(classState.file.addHelper("classCallCheck"), [thisExpression$4(), cloneNode$e(classState.classRef)])));
      }
      var isStrict = path.isInStrictMode();
      var constructorOnly = body.length === 0;
      if (constructorOnly && !isStrict) {
        for (var _iterator9 = _createForOfIteratorHelperLoose(classState.construct.params), _step9; !(_step9 = _iterator9()).done;) {
          var param = _step9.value;
          if (!isIdentifier$e(param)) {
            constructorOnly = false;
            break;
          }
        }
      }
      var directives = constructorOnly ? classState.construct.body.directives : [];
      if (!isStrict) {
        directives.push(directive(directiveLiteral("use strict")));
      }
      if (constructorOnly) {
        var expr = toExpression$1(classState.construct);
        return classState.isLoose ? expr : createClassHelper([expr]);
      }
      if (!classState.pushedCreateClass) {
        body.push(returnStatement$3(classState.isLoose ? cloneNode$e(classState.classRef) : createClassHelper([cloneNode$e(classState.classRef)])));
      }
      body.unshift(classState.construct);
      var container = arrowFunctionExpression$4(closureParams, blockStatement$6(body, directives));
      return callExpression$c(container, closureArgs);
    }
    return classTransformer(path, file, builtinClasses, isLoose);
  }

var _templateObject$m;
  {
    var DefineAccessorHelper = template$1.expression.ast(_templateObject$m || (_templateObject$m = _taggedTemplateLiteralLoose(["\n    function (type, obj, key, fn) {\n      var desc = { configurable: true, enumerable: true };\n      desc[type] = fn;\n      return Object.defineProperty(obj, key, desc);\n    }\n  "])));
    DefineAccessorHelper._compact = true;
  }
  var _transformComputedProperties = declare(function (api, options) {
    var _api$assumption;
    api.assertVersion("*");
    var setComputedProperties = (_api$assumption = api.assumption("setComputedProperties")) != null ? _api$assumption : options.loose;
    var pushComputedProps = setComputedProperties ? pushComputedPropsLoose : pushComputedPropsSpec;
    function buildDefineAccessor(state, obj, prop) {
      var type = prop.kind;
      var key = !prop.computed && isIdentifier$e(prop.key) ? stringLiteral$6(prop.key.name) : prop.key;
      var fn = getValue(prop);
      {
        var helper;
        if (state.availableHelper("defineAccessor")) {
          helper = state.addHelper("defineAccessor");
        } else {
          var file = state.file;
          helper = file.get("fallbackDefineAccessorHelper");
          if (!helper) {
            var id = file.scope.generateUidIdentifier("defineAccessor");
            file.scope.push({
              id: id,
              init: DefineAccessorHelper
            });
            file.set("fallbackDefineAccessorHelper", helper = id);
          }
          helper = cloneNode$e(helper);
        }
        return callExpression$c(helper, [stringLiteral$6(type), obj, key, fn]);
      }
    }
    function getValue(prop) {
      if (isObjectProperty$3(prop)) {
        return prop.value;
      } else if (isObjectMethod(prop)) {
        return functionExpression$2(null, prop.params, prop.body, prop.generator, prop.async);
      }
    }
    function pushAssign(objId, prop, body) {
      body.push(expressionStatement$7(assignmentExpression$8("=", memberExpression$9(cloneNode$e(objId), prop.key, prop.computed || isLiteral$4(prop.key)), getValue(prop))));
    }
    function pushComputedPropsLoose(info) {
      var computedProps = info.computedProps,
        state = info.state,
        initPropExpression = info.initPropExpression,
        objId = info.objId,
        body = info.body;
      for (var _iterator = _createForOfIteratorHelperLoose(computedProps), _step; !(_step = _iterator()).done;) {
        var prop = _step.value;
        if (isObjectMethod(prop) && (prop.kind === "get" || prop.kind === "set")) {
          if (computedProps.length === 1) {
            return buildDefineAccessor(state, initPropExpression, prop);
          } else {
            body.push(expressionStatement$7(buildDefineAccessor(state, cloneNode$e(objId), prop)));
          }
        } else {
          pushAssign(cloneNode$e(objId), prop, body);
        }
      }
    }
    function pushComputedPropsSpec(info) {
      var objId = info.objId,
        body = info.body,
        computedProps = info.computedProps,
        state = info.state;
      var CHUNK_LENGTH_CAP = 10;
      var currentChunk = null;
      var computedPropsChunks = [];
      for (var _iterator2 = _createForOfIteratorHelperLoose(computedProps), _step2; !(_step2 = _iterator2()).done;) {
        var _prop = _step2.value;
        if (!currentChunk || currentChunk.length === CHUNK_LENGTH_CAP) {
          currentChunk = [];
          computedPropsChunks.push(currentChunk);
        }
        currentChunk.push(_prop);
      }
      for (var _i = 0, _computedPropsChunks = computedPropsChunks; _i < _computedPropsChunks.length; _i++) {
        var chunk = _computedPropsChunks[_i];
        var single = computedPropsChunks.length === 1;
        var node = single ? info.initPropExpression : cloneNode$e(objId);
        for (var _iterator3 = _createForOfIteratorHelperLoose(chunk), _step3; !(_step3 = _iterator3()).done;) {
          var prop = _step3.value;
          if (isObjectMethod(prop) && (prop.kind === "get" || prop.kind === "set")) {
            node = buildDefineAccessor(info.state, node, prop);
          } else {
            node = callExpression$c(state.addHelper("defineProperty"), [node, toComputedKey$1(prop), getValue(prop)]);
          }
        }
        if (single) return node;
        body.push(expressionStatement$7(node));
      }
    }
    return {
      name: "transform-computed-properties",
      visitor: {
        ObjectExpression: {
          exit: function exit(path, state) {
            var node = path.node,
              parent = path.parent,
              scope = path.scope;
            var hasComputed = false;
            for (var _iterator4 = _createForOfIteratorHelperLoose(node.properties), _step4; !(_step4 = _iterator4()).done;) {
              var prop = _step4.value;
              hasComputed = prop.computed === true;
              if (hasComputed) break;
            }
            if (!hasComputed) return;
            var initProps = [];
            var computedProps = [];
            var foundComputed = false;
            for (var _iterator5 = _createForOfIteratorHelperLoose(node.properties), _step5; !(_step5 = _iterator5()).done;) {
              var _prop2 = _step5.value;
              if (isSpreadElement$1(_prop2)) {
                continue;
              }
              if (_prop2.computed) {
                foundComputed = true;
              }
              if (foundComputed) {
                computedProps.push(_prop2);
              } else {
                initProps.push(_prop2);
              }
            }
            var objId = scope.generateUidIdentifierBasedOnNode(parent);
            var initPropExpression = objectExpression$3(initProps);
            var body = [];
            body.push(variableDeclaration$6("var", [variableDeclarator$6(objId, initPropExpression)]));
            var single = pushComputedProps({
              scope: scope,
              objId: objId,
              body: body,
              computedProps: computedProps,
              initPropExpression: initPropExpression,
              state: state
            });
            if (single) {
              path.replaceWith(single);
            } else {
              if (setComputedProperties) {
                body.push(expressionStatement$7(cloneNode$e(objId)));
              }
              path.replaceWithMultiple(body);
            }
          }
        }
      }
    };
  });

var _transformDotallRegex = declare(function (api) {
    api.assertVersion("*");
    return createRegExpFeaturePlugin({
      name: "transform-dotall-regex",
      feature: "dotAllFlag"
    });
  });

var _templateObject$l;
  var transformExponentialOperator = declare(function (api) {
    api.assertVersion("*");
    var t = api.types,
      template = api.template;
    function build(left, right) {
      return t.callExpression(t.memberExpression(t.identifier("Math"), t.identifier("pow")), [left, right]);
    }
    function maybeMemoize(node, scope) {
      if (scope.isStatic(node)) {
        return {
          assign: node,
          ref: t.cloneNode(node)
        };
      }
      if (scope.path.isPattern()) {
        return null;
      }
      var id = scope.generateUidIdentifierBasedOnNode(node);
      scope.push({
        id: id
      });
      return {
        assign: t.assignmentExpression("=", t.cloneNode(id), node),
        ref: t.cloneNode(id)
      };
    }
    return {
      name: "transform-exponentiation-operator",
      visitor: {
        AssignmentExpression: function AssignmentExpression(path) {
          var node = path.node,
            scope = path.scope;
          if (node.operator !== "**=") return;
          if (t.isMemberExpression(node.left)) {
            var member1;
            var member2;
            var object = maybeMemoize(node.left.object, scope);
            if (!object) {
              path.replaceWith(template.expression.ast(_templateObject$l || (_templateObject$l = _taggedTemplateLiteralLoose(["(() => ", ")()"])), path.node));
              return;
            }
            var _node$left = node.left,
              property = _node$left.property,
              computed = _node$left.computed;
            if (computed) {
              var prop = maybeMemoize(property, scope);
              member1 = t.memberExpression(object.assign, prop.assign, true);
              member2 = t.memberExpression(object.ref, prop.ref, true);
            } else {
              member1 = t.memberExpression(object.assign, property, false);
              member2 = t.memberExpression(object.ref, t.cloneNode(property), false);
            }
            path.replaceWith(t.assignmentExpression("=", member1, build(member2, node.right)));
          } else {
            path.replaceWith(t.assignmentExpression("=", node.left, build(t.cloneNode(node.left), node.right)));
          }
        },
        BinaryExpression: function BinaryExpression(path) {
          var node = path.node;
          if (node.operator === "**") {
            path.replaceWith(build(node.left, node.right));
          }
        }
      }
    };
  });

var _templateObject$k, _templateObject2$b, _templateObject3$7;
  function buildLoopBody(path, declar, newBody) {
    var block;
    var bodyPath = path.get("body");
    var body = newBody != null ? newBody : bodyPath.node;
    if (isBlockStatement$3(body) && Object.keys(path.getBindingIdentifiers()).some(function (id) {
      return bodyPath.scope.hasOwnBinding(id);
    })) {
      block = blockStatement$6([declar, body]);
    } else {
      block = toBlock(body);
      block.body.unshift(declar);
    }
    return block;
  }
  var _transformForOf = declare(function (api, options) {
    var _options$assumeArray, _options$allowArrayLi, _api$assumption;
    api.assertVersion("*");
    {
      var assumeArray = options.assumeArray,
        allowArrayLike = options.allowArrayLike,
        loose = options.loose;
      if (loose === true && assumeArray === true) {
        throw new Error("The loose and assumeArray options cannot be used together in @babel/plugin-transform-for-of");
      }
      if (assumeArray === true && allowArrayLike === true) {
        throw new Error("The assumeArray and allowArrayLike options cannot be used together in @babel/plugin-transform-for-of");
      }
      {
        if (allowArrayLike && /^7\.\d\./.test(api.version)) {
          throw new Error("The allowArrayLike is only supported when using @babel/core@^7.10.0");
        }
      }
    }
    var iterableIsArray = (_options$assumeArray = options.assumeArray) != null ? _options$assumeArray : !options.loose && api.assumption("iterableIsArray");
    var arrayLikeIsIterable = (_options$allowArrayLi = options.allowArrayLike) != null ? _options$allowArrayLi : api.assumption("arrayLikeIsIterable");
    var skipIteratorClosing = (_api$assumption = api.assumption("skipForOfIteratorClosing")) != null ? _api$assumption : options.loose;
    if (iterableIsArray && arrayLikeIsIterable) {
      throw new Error("The \"iterableIsArray\" and \"arrayLikeIsIterable\" assumptions are not compatible.");
    }
    if (iterableIsArray) {
      return {
        name: "transform-for-of",
        visitor: {
          ForOfStatement: function ForOfStatement(path) {
            var scope = path.scope;
            var _path$node = path.node,
              left = _path$node.left,
              isAwait = _path$node["await"];
            if (isAwait) {
              return;
            }
            var right = skipTransparentExprWrapperNodes(path.node.right);
            var i = scope.generateUidIdentifier("i");
            var array = scope.maybeGenerateMemoised(right, true);
            if (!array && isIdentifier$e(right) && path.get("body").scope.hasOwnBinding(right.name)) {
              array = scope.generateUidIdentifier("arr");
            }
            var inits = [variableDeclarator$6(i, numericLiteral$5(0))];
            if (array) {
              inits.push(variableDeclarator$6(array, right));
            } else {
              array = right;
            }
            var item = memberExpression$9(cloneNode$e(array), cloneNode$e(i), true);
            var assignment;
            if (isVariableDeclaration$3(left)) {
              assignment = left;
              assignment.declarations[0].init = item;
            } else {
              assignment = expressionStatement$7(assignmentExpression$8("=", left, item));
            }
            path.replaceWith(forStatement(variableDeclaration$6("let", inits), binaryExpression$4("<", cloneNode$e(i), memberExpression$9(cloneNode$e(array), identifier$d("length"))), updateExpression$1("++", cloneNode$e(i)), buildLoopBody(path, assignment)));
          }
        }
      };
    }
    var buildForOfArray = template$1(_templateObject$k || (_templateObject$k = _taggedTemplateLiteralLoose(["\n    for (var KEY = 0, NAME = ARR; KEY < NAME.length; KEY++) BODY;\n  "])));
    var buildForOfNoIteratorClosing = template$1.statements(_templateObject2$b || (_templateObject2$b = _taggedTemplateLiteralLoose(["\n    for (var ITERATOR_HELPER = CREATE_ITERATOR_HELPER(OBJECT, ARRAY_LIKE_IS_ITERABLE), STEP_KEY;\n        !(STEP_KEY = ITERATOR_HELPER()).done;) BODY;\n  "])));
    var buildForOf = template$1.statements(_templateObject3$7 || (_templateObject3$7 = _taggedTemplateLiteralLoose(["\n    var ITERATOR_HELPER = CREATE_ITERATOR_HELPER(OBJECT, ARRAY_LIKE_IS_ITERABLE), STEP_KEY;\n    try {\n      for (ITERATOR_HELPER.s(); !(STEP_KEY = ITERATOR_HELPER.n()).done;) BODY;\n    } catch (err) {\n      ITERATOR_HELPER.e(err);\n    } finally {\n      ITERATOR_HELPER.f();\n    }\n  "])));
    var builder = skipIteratorClosing ? {
      build: buildForOfNoIteratorClosing,
      helper: "createForOfIteratorHelperLoose",
      getContainer: function getContainer(nodes) {
        return nodes;
      }
    } : {
      build: buildForOf,
      helper: "createForOfIteratorHelper",
      getContainer: function getContainer(nodes) {
        return nodes[1].block.body;
      }
    };
    function _ForOfStatementArray(path) {
      var node = path.node,
        scope = path.scope;
      var right = scope.generateUidIdentifierBasedOnNode(node.right, "arr");
      var iterationKey = scope.generateUidIdentifier("i");
      var loop = buildForOfArray({
        BODY: node.body,
        KEY: iterationKey,
        NAME: right,
        ARR: node.right
      });
      inherits$3(loop, node);
      var iterationValue = memberExpression$9(cloneNode$e(right), cloneNode$e(iterationKey), true);
      var declar;
      var left = node.left;
      if (isVariableDeclaration$3(left)) {
        left.declarations[0].init = iterationValue;
        declar = left;
      } else {
        declar = expressionStatement$7(assignmentExpression$8("=", left, iterationValue));
      }
      loop.body = buildLoopBody(path, declar, loop.body);
      return loop;
    }
    return {
      name: "transform-for-of",
      visitor: {
        ForOfStatement: function ForOfStatement(path, state) {
          var right = path.get("right");
          if (right.isArrayExpression() || right.isGenericType("Array") || isArrayTypeAnnotation$2(right.getTypeAnnotation())) {
            path.replaceWith(_ForOfStatementArray(path));
            return;
          }
          {
            if (!state.availableHelper(builder.helper)) {
              transformWithoutHelper(skipIteratorClosing, path, state);
              return;
            }
          }
          var node = path.node,
            parent = path.parent,
            scope = path.scope;
          var left = node.left;
          var declar;
          var stepKey = scope.generateUid("step");
          var stepValue = memberExpression$9(identifier$d(stepKey), identifier$d("value"));
          if (isVariableDeclaration$3(left)) {
            declar = variableDeclaration$6(left.kind, [variableDeclarator$6(left.declarations[0].id, stepValue)]);
          } else {
            declar = expressionStatement$7(assignmentExpression$8("=", left, stepValue));
          }
          var nodes = builder.build({
            CREATE_ITERATOR_HELPER: state.addHelper(builder.helper),
            ITERATOR_HELPER: scope.generateUidIdentifier("iterator"),
            ARRAY_LIKE_IS_ITERABLE: arrayLikeIsIterable ? booleanLiteral$2(true) : null,
            STEP_KEY: identifier$d(stepKey),
            OBJECT: node.right,
            BODY: buildLoopBody(path, declar)
          });
          var container = builder.getContainer(nodes);
          inherits$3(container[0], node);
          inherits$3(container[0].body, node.body);
          if (isLabeledStatement(parent)) {
            container[0] = labeledStatement(parent.label, container[0]);
            path.parentPath.replaceWithMultiple(nodes);
            path.skip();
          } else {
            path.replaceWithMultiple(nodes);
          }
        }
      }
    };
  });

var _templateObject$j, _templateObject2$a, _templateObject3$6, _templateObject4$2, _templateObject5$1, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14, _templateObject15, _templateObject16, _templateObject17, _templateObject18, _templateObject19, _templateObject20, _templateObject21;
  function imp(path, name, module) {
    return addNamed(path, name, module, {
      importedType: "es6"
    });
  }
  var imr = function imr(s) {
    return template$1.expression.ast(_templateObject$j || (_templateObject$j = _taggedTemplateLiteralLoose(["\n  import.meta.resolve(", ")\n"])), s);
  };
  var imrWithFallback = function imrWithFallback(s) {
    return template$1.expression.ast(_templateObject2$a || (_templateObject2$a = _taggedTemplateLiteralLoose(["\n  import.meta.resolve?.(", ") ?? new URL(", ", import.meta.url)\n"])), s, cloneNode$e(s));
  };
  function importToPlatformApi(targets, transformers, toCommonJS) {
    var _buildFetchAsync;
    var _getSupport = getSupport(targets),
      needsNodeSupport = _getSupport.needsNodeSupport,
      needsWebSupport = _getSupport.needsWebSupport,
      nodeSupportsIMR = _getSupport.nodeSupportsIMR,
      webSupportsIMR = _getSupport.webSupportsIMR,
      nodeSupportsFsPromises = _getSupport.nodeSupportsFsPromises;
    var supportIsomorphicCJS = transformers.commonJS != null;
    var buildFetchAsync;
    var buildFetchSync;
    var p = function p(_ref) {
      var _ref$web = _ref.web,
        w = _ref$web === void 0 ? needsWebSupport : _ref$web,
        _ref$node = _ref.node,
        n = _ref$node === void 0 ? needsNodeSupport : _ref$node,
        _ref$nodeFSP = _ref.nodeFSP,
        nF = _ref$nodeFSP === void 0 ? nodeSupportsFsPromises : _ref$nodeFSP,
        _ref$webIMR = _ref.webIMR,
        wI = _ref$webIMR === void 0 ? webSupportsIMR : _ref$webIMR,
        _ref$nodeIMR = _ref.nodeIMR,
        nI = _ref$nodeIMR === void 0 ? nodeSupportsIMR : _ref$nodeIMR,
        _ref$toCJS = _ref.toCJS,
        c = _ref$toCJS === void 0 ? toCommonJS : _ref$toCJS,
        _ref$supportIsomorphi = _ref.supportIsomorphicCJS,
        iC = _ref$supportIsomorphi === void 0 ? supportIsomorphicCJS : _ref$supportIsomorphi;
      return +w + (+n << 1) + (+wI << 2) + (+nI << 3) + (+c << 4) + (+nF << 5) + (+iC << 6);
    };
    var readFileP = function readFileP(fs, arg) {
      if (nodeSupportsFsPromises) {
        return template$1.expression.ast(_templateObject3$6 || (_templateObject3$6 = _taggedTemplateLiteralLoose(["", ".promises.readFile(", ")"])), fs, arg);
      }
      return template$1.expression.ast(_templateObject4$2 || (_templateObject4$2 = _taggedTemplateLiteralLoose(["\n      new Promise(\n        (a =>\n          (r, j) => ", ".readFile(a, (e, d) => e ? j(e) : r(d))\n        )(", ")\n      )"])), fs, arg);
    };
    switch (p({
      web: needsWebSupport,
      node: needsNodeSupport,
      webIMR: webSupportsIMR,
      nodeIMR: nodeSupportsIMR,
      toCJS: toCommonJS
    })) {
      case p({
        toCJS: true,
        supportIsomorphicCJS: true
      }):
        buildFetchSync = function buildFetchSync(specifier) {
          return transformers.commonJS(identifier$d("require"), specifier);
        };
        break;
      case p({
        web: true,
        node: true
      }):
        buildFetchAsync = function buildFetchAsync(specifier) {
          var web = transformers.webFetch(callExpression$c(identifier$d("fetch"), [(webSupportsIMR ? imr : imrWithFallback)(cloneNode$e(specifier))]));
          var node = supportIsomorphicCJS ? template$1.expression.ast(_templateObject5$1 || (_templateObject5$1 = _taggedTemplateLiteralLoose(["\n              import(\"module\").then(module => ", ")\n            "])), transformers.commonJS(template$1.expression.ast(_templateObject6 || (_templateObject6 = _taggedTemplateLiteralLoose(["module.createRequire(import.meta.url)"]))), specifier)) : nodeSupportsIMR ? template$1.expression.ast(_templateObject7 || (_templateObject7 = _taggedTemplateLiteralLoose(["\n                import(\"fs\").then(\n                  fs => ", "\n                ).then(", ")\n              "])), readFileP(identifier$d("fs"), template$1.expression.ast(_templateObject8 || (_templateObject8 = _taggedTemplateLiteralLoose(["new URL(", ")"])), imr(specifier))), transformers.nodeFsAsync()) : template$1.expression.ast(_templateObject9 || (_templateObject9 = _taggedTemplateLiteralLoose(["\n                Promise.all([import(\"fs\"), import(\"module\")])\n                  .then(([fs, module]) =>\n                    ", "\n                  )\n                  .then(", ")\n              "])), readFileP(identifier$d("fs"), template$1.expression.ast(_templateObject10 || (_templateObject10 = _taggedTemplateLiteralLoose(["\n                        module.createRequire(import.meta.url).resolve(", ")\n                      "])), specifier)), transformers.nodeFsAsync());
          return template$1.expression.ast(_templateObject11 || (_templateObject11 = _taggedTemplateLiteralLoose(["\n            typeof process === \"object\" && process.versions?.node\n              ? ", "\n              : ", "\n          "])), node, web);
        };
        break;
      case p({
        web: true,
        node: false,
        webIMR: true
      }):
        buildFetchAsync = function buildFetchAsync(specifier) {
          return transformers.webFetch(callExpression$c(identifier$d("fetch"), [imr(specifier)]));
        };
        break;
      case p({
        web: true,
        node: false,
        webIMR: false
      }):
        buildFetchAsync = function buildFetchAsync(specifier) {
          return transformers.webFetch(callExpression$c(identifier$d("fetch"), [imrWithFallback(specifier)]));
        };
        break;
      case p({
        web: false,
        node: true,
        toCJS: true
      }):
        buildFetchSync = function buildFetchSync(specifier) {
          return transformers.nodeFsSync(template$1.expression.ast(_templateObject12 || (_templateObject12 = _taggedTemplateLiteralLoose(["\n            require(\"fs\").readFileSync(require.resolve(", "))\n          "])), specifier));
        };
        buildFetchAsync = function buildFetchAsync(specifier) {
          return template$1.expression.ast(_templateObject13 || (_templateObject13 = _taggedTemplateLiteralLoose(["\n            require(\"fs\").promises.readFile(require.resolve(", "))\n              .then(", ")\n          "])), specifier, transformers.nodeFsAsync());
        };
        break;
      case p({
        web: false,
        node: true,
        toCJS: false,
        supportIsomorphicCJS: true
      }):
        buildFetchSync = function buildFetchSync(specifier, path) {
          return transformers.commonJS(template$1.expression.ast(_templateObject14 || (_templateObject14 = _taggedTemplateLiteralLoose(["\n            ", "(import.meta.url)\n          "])), imp(path, "createRequire", "module")), specifier);
        };
        break;
      case p({
        web: false,
        node: true,
        toCJS: false,
        nodeIMR: true
      }):
        buildFetchSync = function buildFetchSync(specifier, path) {
          return transformers.nodeFsSync(template$1.expression.ast(_templateObject15 || (_templateObject15 = _taggedTemplateLiteralLoose(["\n            ", "(\n              new URL(", ")\n            )\n          "])), imp(path, "readFileSync", "fs"), imr(specifier)));
        };
        buildFetchAsync = function buildFetchAsync(specifier, path) {
          return template$1.expression.ast(_templateObject16 || (_templateObject16 = _taggedTemplateLiteralLoose(["\n          ", "\n            .readFile(new URL(", "))\n            .then(", ")\n        "])), imp(path, "promises", "fs"), imr(specifier), transformers.nodeFsAsync());
        };
        break;
      case p({
        web: false,
        node: true,
        toCJS: false,
        nodeIMR: false
      }):
        buildFetchSync = function buildFetchSync(specifier, path) {
          return transformers.nodeFsSync(template$1.expression.ast(_templateObject17 || (_templateObject17 = _taggedTemplateLiteralLoose(["\n            ", "(\n              ", "(import.meta.url)\n                .resolve(", ")\n            )\n          "])), imp(path, "readFileSync", "fs"), imp(path, "createRequire", "module"), specifier));
        };
        buildFetchAsync = function buildFetchAsync(specifier, path) {
          return transformers.webFetch(template$1.expression.ast(_templateObject18 || (_templateObject18 = _taggedTemplateLiteralLoose(["\n            ", "\n              .readFile(\n                ", "(import.meta.url)\n                  .resolve(", ")\n              )\n          "])), imp(path, "promises", "fs"), imp(path, "createRequire", "module"), specifier));
        };
        break;
      default:
        throw new Error("Internal Babel error: unreachable code.");
    }
    (_buildFetchAsync = buildFetchAsync) != null ? _buildFetchAsync : buildFetchAsync = buildFetchSync;
    var buildFetchAsyncWrapped = function buildFetchAsyncWrapped(expression, path) {
      if (isStringLiteral$5(expression)) {
        return template$1.expression.ast(_templateObject19 || (_templateObject19 = _taggedTemplateLiteralLoose(["\n        Promise.resolve().then(() => ", ")\n      "])), buildFetchAsync(expression, path));
      } else {
        return template$1.expression.ast(_templateObject20 || (_templateObject20 = _taggedTemplateLiteralLoose(["\n        Promise.resolve(`${", "}`).then((s) => ", ")\n      "], ["\n        Promise.resolve(\\`\\${", "}\\`).then((s) => ", ")\n      "])), expression, buildFetchAsync(identifier$d("s"), path));
      }
    };
    var buildFetch = buildFetchSync;
    if (!buildFetchSync) {
      if (toCommonJS) {
        buildFetch = function buildFetch(specifier, path) {
          throw path.buildCodeFrameError("Cannot compile to CommonJS, since it would require top-level await.");
        };
      } else {
        buildFetch = buildFetchAsync;
      }
    }
    return {
      buildFetch: buildFetch,
      buildFetchAsync: buildFetchAsyncWrapped,
      needsAwait: !buildFetchSync
    };
  }
  function buildParallelStaticImports(data, needsAwait) {
    if (data.length === 0) return null;
    var declarators = [];
    if (data.length === 1) {
      var rhs = data[0].fetch;
      if (needsAwait) rhs = awaitExpression$1(rhs);
      declarators.push(variableDeclarator$6(data[0].id, rhs));
    } else if (needsAwait) {
      var ids = data.map(function (_ref2) {
        var id = _ref2.id;
        return id;
      });
      var fetches = data.map(function (_ref3) {
        var fetch = _ref3.fetch;
        return fetch;
      });
      declarators.push(variableDeclarator$6(arrayPattern(ids), awaitExpression$1(template$1.expression.ast(_templateObject21 || (_templateObject21 = _taggedTemplateLiteralLoose(["\n            Promise.all(", ")\n          "])), arrayExpression$1(fetches)))));
    } else {
      for (var _iterator = _createForOfIteratorHelperLoose(data), _step; !(_step = _iterator()).done;) {
        var _step$value = _step.value,
          id = _step$value.id,
          fetch = _step$value.fetch;
        declarators.push(variableDeclarator$6(id, fetch));
      }
    }
    return variableDeclaration$6("const", declarators);
  }

var _templateObject$i, _templateObject2$9, _templateObject3$5, _templateObject4$1, _templateObject5;
  var transformJsonModules = declare(function (api, options) {
    var t = api.types,
      template = api.template;
    api.assertVersion("*");
    var targets = api.targets();
    var helperESM;
    var helperCJS;
    var transformers = {
      commonJS: options.uncheckedRequire ? function (require, specifier) {
        return t.callExpression(require, [specifier]);
      } : null,
      webFetch: function webFetch(fetch) {
        return template.expression.ast(_templateObject$i || (_templateObject$i = _taggedTemplateLiteralLoose(["", ".then(r => r.json())"])), fetch);
      },
      nodeFsSync: function nodeFsSync(read) {
        return template.expression.ast(_templateObject2$9 || (_templateObject2$9 = _taggedTemplateLiteralLoose(["JSON.parse(", ")"])), read);
      },
      nodeFsAsync: function nodeFsAsync() {
        return template.expression.ast(_templateObject3$5 || (_templateObject3$5 = _taggedTemplateLiteralLoose(["JSON.parse"])));
      }
    };
    var getHelper = function getHelper(file) {
      var modules = file.get("@babel/plugin-transform-modules-*");
      if (modules === "commonjs") {
        var _helperCJS;
        return (_helperCJS = helperCJS) != null ? _helperCJS : helperCJS = importToPlatformApi(targets, transformers, true);
      }
      if (modules == null) {
        var _helperESM;
        return (_helperESM = helperESM) != null ? _helperESM : helperESM = importToPlatformApi(targets, transformers, false);
      }
      throw new Error("@babel/plugin-transform-json-modules can only be used when not " + "compiling modules, or when compiling them to CommonJS.");
    };
    function getAttributeKey(_ref) {
      var key = _ref.key;
      return t.isIdentifier(key) ? key.name : key.value;
    }
    function hasTypeJson(attributes) {
      return !!(attributes != null && attributes.some(function (attr) {
        return getAttributeKey(attr) === "type" && attr.value.value === "json";
      }));
    }
    return {
      name: "transform-json-modules",
      inherits: syntaxImportAttributes,
      visitor: {
        Program: function Program(path) {
          if (path.node.sourceType !== "module") return;
          var helper = getHelper(this.file);
          var data = [];
          for (var _iterator = _createForOfIteratorHelperLoose(path.get("body")), _step; !(_step = _iterator()).done;) {
            var _id;
            var _decl = _step.value;
            if (!_decl.isImportDeclaration()) continue;
            var attributes = _decl.node.attributes || _decl.node.assertions;
            if (!hasTypeJson(attributes)) continue;
            if (_decl.node.phase != null) {
              throw _decl.buildCodeFrameError("JSON modules do not support phase modifiers.");
            }
            if (attributes.length > 1) {
              var paths = _decl.node.attributes ? _decl.get("attributes") : _decl.get("assertions");
              var index = getAttributeKey(attributes[0]) === "type" ? 1 : 0;
              throw paths[index].buildCodeFrameError("Unknown attribute for JSON modules.");
            }
            var id = void 0;
            var needsNS = false;
            for (var _iterator2 = _createForOfIteratorHelperLoose(_decl.get("specifiers")), _step2; !(_step2 = _iterator2()).done;) {
              var specifier = _step2.value;
              if (specifier.isImportSpecifier()) {
                throw specifier.buildCodeFrameError("JSON modules do not support named imports.");
              }
              id = specifier.node.local;
              needsNS = specifier.isImportNamespaceSpecifier();
            }
            (_id = id) != null ? _id : id = path.scope.generateUidIdentifier("_");
            var fetch = helper.buildFetch(_decl.node.source, path);
            if (needsNS) {
              if (helper.needsAwait) {
                fetch = template.expression.ast(_templateObject4$1 || (_templateObject4$1 = _taggedTemplateLiteralLoose(["\n                ", ".then(j => ({ default: j }))\n              "])), fetch);
              } else {
                fetch = template.expression.ast(_templateObject5 || (_templateObject5 = _taggedTemplateLiteralLoose(["{ default: ", " }"])), fetch);
              }
            }
            data.push({
              id: id,
              fetch: fetch
            });
            _decl.remove();
          }
          if (data.length === 0) return;
          var decl = buildParallelStaticImports(data, helper.needsAwait);
          if (decl) path.unshiftContainer("body", decl);
        }
      }
    };
  });

var _templateObject$h;
  var buildWrapper$1 = template$1.statement("\n  define(MODULE_NAME, AMD_ARGUMENTS, function(IMPORT_NAMES) {\n  })\n");
  var buildAnonymousWrapper = template$1.statement("\n  define([\"require\"], function(REQUIRE) {\n  })\n");
  function injectWrapper(path, wrapper) {
    var _path$node = path.node,
      body = _path$node.body,
      directives = _path$node.directives;
    path.node.directives = [];
    path.node.body = [];
    var amdFactoryCall = path.pushContainer("body", wrapper)[0].get("expression");
    var amdFactoryCallArgs = amdFactoryCall.get("arguments");
    var amdFactory = amdFactoryCallArgs[amdFactoryCallArgs.length - 1].get("body");
    amdFactory.pushContainer("directives", directives);
    amdFactory.pushContainer("body", body);
  }
  var _transformModulesAmd = declare(function (api, options) {
    var _api$assumption, _api$assumption2, _visitor;
    api.assertVersion("*");
    var allowTopLevelThis = options.allowTopLevelThis,
      strict = options.strict,
      strictMode = options.strictMode,
      importInterop = options.importInterop,
      noInterop = options.noInterop;
    var constantReexports = (_api$assumption = api.assumption("constantReexports")) != null ? _api$assumption : options.loose;
    var enumerableModuleMeta = (_api$assumption2 = api.assumption("enumerableModuleMeta")) != null ? _api$assumption2 : options.loose;
    return {
      name: "transform-modules-amd",
      pre: function pre() {
        this.file.set("@babel/plugin-transform-modules-*", "amd");
      },
      visitor: (_visitor = {}, _visitor["CallExpression" + (api.types.importExpression ? "|ImportExpression" : "")] = function (path, state) {
        if (!this.file.has("@babel/plugin-proposal-dynamic-import")) return;
        if (path.isCallExpression() && !path.get("callee").isImport()) return;
        var requireId = state.requireId,
          resolveId = state.resolveId,
          rejectId = state.rejectId;
        if (!requireId) {
          requireId = path.scope.generateUidIdentifier("require");
          state.requireId = requireId;
        }
        if (!resolveId || !rejectId) {
          resolveId = path.scope.generateUidIdentifier("resolve");
          rejectId = path.scope.generateUidIdentifier("reject");
          state.resolveId = resolveId;
          state.rejectId = rejectId;
        }
        var result = identifier$d("imported");
        if (!noInterop) {
          result = wrapInterop(this.file.path, result, "namespace");
        }
        path.replaceWith(buildDynamicImport(path.node, false, false, function (specifier) {
          return template$1.expression.ast(_templateObject$h || (_templateObject$h = _taggedTemplateLiteralLoose(["\n              new Promise((", ", ", ") =>\n                ", "(\n                  [", "],\n                  imported => ", "(", "),\n                  ", "\n                )\n              )\n            "])), resolveId, rejectId, requireId, specifier, cloneNode$e(resolveId), result, cloneNode$e(rejectId));
        }));
      }, _visitor.Program = {
        exit: function exit(path, _ref) {
          var requireId = _ref.requireId;
          if (!isModule(path)) {
            if (requireId) {
              injectWrapper(path, buildAnonymousWrapper({
                REQUIRE: cloneNode$e(requireId)
              }));
            }
            return;
          }
          var amdArgs = [];
          var importNames = [];
          if (requireId) {
            amdArgs.push(stringLiteral$6("require"));
            importNames.push(cloneNode$e(requireId));
          }
          var moduleName = getModuleName$1(this.file.opts, options);
          if (moduleName) moduleName = stringLiteral$6(moduleName);
          var _rewriteModuleStateme = rewriteModuleStatementsAndPrepareHeader(path, {
              enumerableModuleMeta: enumerableModuleMeta,
              constantReexports: constantReexports,
              strict: strict,
              strictMode: strictMode,
              allowTopLevelThis: allowTopLevelThis,
              importInterop: importInterop,
              noInterop: noInterop,
              filename: this.file.opts.filename
            }),
            meta = _rewriteModuleStateme.meta,
            headers = _rewriteModuleStateme.headers;
          if (hasExports(meta)) {
            amdArgs.push(stringLiteral$6("exports"));
            importNames.push(identifier$d(meta.exportName));
          }
          for (var _iterator = _createForOfIteratorHelperLoose(meta.source), _step; !(_step = _iterator()).done;) {
            var _step$value = _slicedToArray(_step.value, 2),
              source = _step$value[0],
              metadata = _step$value[1];
            amdArgs.push(stringLiteral$6(source));
            importNames.push(identifier$d(metadata.name));
            if (!isSideEffectImport(metadata)) {
              var interop = wrapInterop(path, identifier$d(metadata.name), metadata.interop);
              if (interop) {
                var header = expressionStatement$7(assignmentExpression$8("=", identifier$d(metadata.name), interop));
                header.loc = metadata.loc;
                headers.push(header);
              }
            }
            headers.push.apply(headers, _toConsumableArray(buildNamespaceInitStatements(meta, metadata, constantReexports)));
          }
          ensureStatementsHoisted(headers);
          path.unshiftContainer("body", headers);
          injectWrapper(path, buildWrapper$1({
            MODULE_NAME: moduleName,
            AMD_ARGUMENTS: arrayExpression$1(amdArgs),
            IMPORT_NAMES: importNames
          }));
        }
      }, _visitor)
    };
  });

var _templateObject$g;
  var requireNoInterop = function requireNoInterop(source) {
    return template$1.expression.ast(_templateObject$g || (_templateObject$g = _taggedTemplateLiteralLoose(["require(", ")"])), source);
  };
  var requireInterop = function requireInterop(source, file) {
    return callExpression$c(file.addHelper("interopRequireWildcard"), [requireNoInterop(source)]);
  };
  function transformDynamicImport(path, noInterop, file) {
    var buildRequire = noInterop ? requireNoInterop : requireInterop;
    path.replaceWith(buildDynamicImport(path.node, true, false, function (specifier) {
      return buildRequire(specifier, file);
    }));
  }

var _templateObject$f;
  var lazyImportsHook = function lazyImportsHook(lazy) {
    return {
      name: "@babel/plugin-transform-modules-commonjs" + "/lazy",
      version: "7.26.3",
      getWrapperPayload: function getWrapperPayload(source, metadata) {
        if (isSideEffectImport(metadata) || metadata.reexportAll) {
          return null;
        }
        if (lazy === true) {
          return source.includes(".") ? null : "lazy/function";
        }
        if (Array.isArray(lazy)) {
          return !lazy.includes(source) ? null : "lazy/function";
        }
        if (typeof lazy === "function") {
          return lazy(source) ? "lazy/function" : null;
        }
      },
      buildRequireWrapper: function buildRequireWrapper(name, init, payload, referenced) {
        if (payload === "lazy/function") {
          if (!referenced) return false;
          return template$1.statement.ast(_templateObject$f || (_templateObject$f = _taggedTemplateLiteralLoose(["\n        function ", "() {\n          const data = ", ";\n          ", " = function(){ return data; };\n          return data;\n        }\n      "])), name, init, name);
        }
      },
      wrapReference: function wrapReference(ref, payload) {
        if (payload === "lazy/function") return callExpression$c(ref, []);
      }
    };
  };

var _templateObject$e, _templateObject2$8;
  var transformModulesCommonJS = declare(function (api, options) {
    var _api$assumption, _api$assumption2, _api$assumption3, _visitor;
    api.assertVersion("*");
    var _options$strictNamesp = options.strictNamespace,
      strictNamespace = _options$strictNamesp === void 0 ? false : _options$strictNamesp,
      _options$mjsStrictNam = options.mjsStrictNamespace,
      mjsStrictNamespace = _options$mjsStrictNam === void 0 ? strictNamespace : _options$mjsStrictNam,
      allowTopLevelThis = options.allowTopLevelThis,
      strict = options.strict,
      strictMode = options.strictMode,
      noInterop = options.noInterop,
      importInterop = options.importInterop,
      _options$lazy = options.lazy,
      lazy = _options$lazy === void 0 ? false : _options$lazy,
      _options$allowCommonJ = options.allowCommonJSExports,
      allowCommonJSExports = _options$allowCommonJ === void 0 ? true : _options$allowCommonJ,
      _options$loose = options.loose,
      loose = _options$loose === void 0 ? false : _options$loose;
    var constantReexports = (_api$assumption = api.assumption("constantReexports")) != null ? _api$assumption : loose;
    var enumerableModuleMeta = (_api$assumption2 = api.assumption("enumerableModuleMeta")) != null ? _api$assumption2 : loose;
    var noIncompleteNsImportDetection = (_api$assumption3 = api.assumption("noIncompleteNsImportDetection")) != null ? _api$assumption3 : false;
    if (typeof lazy !== "boolean" && typeof lazy !== "function" && (!Array.isArray(lazy) || !lazy.every(function (item) {
      return 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");
    }
    var getAssertion = function getAssertion(localName) {
      return template$1.expression.ast(_templateObject$e || (_templateObject$e = _taggedTemplateLiteralLoose(["\n    (function(){\n      throw new Error(\n        \"The CommonJS '\" + \"", "\" + \"' variable is not available in ES6 modules.\" +\n        \"Consider setting setting sourceType:script or sourceType:unambiguous in your \" +\n        \"Babel config for this file.\");\n    })()\n  "])), localName);
    };
    var moduleExportsVisitor = {
      ReferencedIdentifier: function ReferencedIdentifier(path) {
        var localName = path.node.name;
        if (localName !== "module" && localName !== "exports") return;
        var localBinding = path.scope.getBinding(localName);
        var 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: function UpdateExpression(path) {
        var arg = path.get("argument");
        if (!arg.isIdentifier()) return;
        var localName = arg.node.name;
        if (localName !== "module" && localName !== "exports") return;
        var localBinding = path.scope.getBinding(localName);
        var rootBinding = this.scope.getBinding(localName);
        if (rootBinding !== localBinding) return;
        path.replaceWith(assignmentExpression$8(path.node.operator[0] + "=", arg.node, getAssertion(localName)));
      },
      AssignmentExpression: function AssignmentExpression(path) {
        var _this = this;
        var left = path.get("left");
        if (left.isIdentifier()) {
          var localName = left.node.name;
          if (localName !== "module" && localName !== "exports") return;
          var localBinding = path.scope.getBinding(localName);
          var rootBinding = this.scope.getBinding(localName);
          if (rootBinding !== localBinding) return;
          var right = path.get("right");
          right.replaceWith(sequenceExpression$6([right.node, getAssertion(localName)]));
        } else if (left.isPattern()) {
          var ids = left.getOuterBindingIdentifiers();
          var _localName = Object.keys(ids).find(function (localName) {
            if (localName !== "module" && localName !== "exports") return false;
            return _this.scope.getBinding(localName) === path.scope.getBinding(localName);
          });
          if (_localName) {
            var _right = path.get("right");
            _right.replaceWith(sequenceExpression$6([_right.node, getAssertion(_localName)]));
          }
        }
      }
    };
    return {
      name: "transform-modules-commonjs",
      pre: function pre() {
        this.file.set("@babel/plugin-transform-modules-*", "commonjs");
        if (lazy) defineCommonJSHook(this.file, lazyImportsHook(lazy));
      },
      visitor: (_visitor = {}, _visitor["CallExpression" + (api.types.importExpression ? "|ImportExpression" : "")] = function (path) {
        if (!this.file.has("@babel/plugin-proposal-dynamic-import")) return;
        if (path.isCallExpression() && !isImport(path.node.callee)) return;
        var scope = path.scope;
        do {
          scope.rename("require");
        } while (scope = scope.parent);
        transformDynamicImport(path, noInterop, this.file);
      }, _visitor.Program = {
        exit: function exit(path, state) {
          if (!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) {
            path.traverse(moduleExportsVisitor, {
              scope: path.scope
            });
          }
          var moduleName = getModuleName$1(this.file.opts, options);
          if (moduleName) moduleName = stringLiteral$6(moduleName);
          var hooks = makeInvokers(this.file);
          var _rewriteModuleStateme = rewriteModuleStatementsAndPrepareHeader(path, {
              exportName: "exports",
              constantReexports: constantReexports,
              enumerableModuleMeta: enumerableModuleMeta,
              strict: strict,
              strictMode: strictMode,
              allowTopLevelThis: allowTopLevelThis,
              noInterop: noInterop,
              importInterop: importInterop,
              wrapReference: hooks.wrapReference,
              getWrapperPayload: hooks.getWrapperPayload,
              esNamespaceOnly: typeof state.filename === "string" && /\.mjs$/.test(state.filename) ? mjsStrictNamespace : strictNamespace,
              noIncompleteNsImportDetection: noIncompleteNsImportDetection,
              filename: this.file.opts.filename
            }),
            meta = _rewriteModuleStateme.meta,
            headers = _rewriteModuleStateme.headers;
          for (var _iterator = _createForOfIteratorHelperLoose(meta.source), _step; !(_step = _iterator()).done;) {
            var _step$value = _slicedToArray(_step.value, 2),
              source = _step$value[0],
              metadata = _step$value[1];
            var loadExpr = callExpression$c(identifier$d("require"), [stringLiteral$6(source)]);
            var header = void 0;
            if (isSideEffectImport(metadata)) {
              if (lazy && metadata.wrap === "function") {
                throw new Error("Assertion failure");
              }
              header = expressionStatement$7(loadExpr);
            } else {
              var _header;
              var init = wrapInterop(path, loadExpr, metadata.interop) || loadExpr;
              if (metadata.wrap) {
                var res = hooks.buildRequireWrapper(metadata.name, init, metadata.wrap, metadata.referenced);
                if (res === false) continue;else header = res;
              }
              (_header = header) != null ? _header : header = template$1.statement.ast(_templateObject2$8 || (_templateObject2$8 = _taggedTemplateLiteralLoose(["\n                var ", " = ", ";\n              "])), metadata.name, init);
            }
            header.loc = metadata.loc;
            headers.push(header);
            headers.push.apply(headers, _toConsumableArray(buildNamespaceInitStatements(meta, metadata, constantReexports, hooks.wrapReference)));
          }
          ensureStatementsHoisted(headers);
          path.unshiftContainer("body", headers);
          path.get("body").forEach(function (path) {
            if (!headers.includes(path.node)) return;
            if (path.isVariableDeclaration()) {
              path.scope.registerDeclaration(path);
            }
          });
        }
      }, _visitor)
    };
  });

var _templateObject$d;
  var transformReactConstantElements = declare(function (api, options) {
    api.assertVersion("*");
    var allowMutablePropsOnTags = options.allowMutablePropsOnTags;
    if (allowMutablePropsOnTags != null && !Array.isArray(allowMutablePropsOnTags)) {
      throw new Error(".allowMutablePropsOnTags must be an array, null, or undefined.");
    }
    var HOISTED = new WeakMap();
    function declares(node, scope) {
      if (isJSXIdentifier$3(node, {
        name: "this"
      }) || isJSXIdentifier$3(node, {
        name: "arguments"
      }) || isJSXIdentifier$3(node, {
        name: "super"
      }) || isJSXIdentifier$3(node, {
        name: "new"
      })) {
        var path = scope.path;
        return path.isFunctionParent() && !path.isArrowFunctionExpression();
      }
      return scope.hasOwnBinding(node.name);
    }
    function isHoistingScope(_ref) {
      var path = _ref.path;
      return path.isFunctionParent() || path.isLoop() || path.isProgram();
    }
    function getHoistingScope(scope) {
      while (!isHoistingScope(scope)) scope = scope.parent;
      return scope;
    }
    var targetScopeVisitor = {
      ReferencedIdentifier: function ReferencedIdentifier(path, state) {
        var node = path.node;
        var scope = path.scope;
        while (scope !== state.jsxScope) {
          if (declares(node, scope)) return;
          scope = scope.parent;
        }
        while (scope) {
          if (scope === state.targetScope) return;
          if (declares(node, scope)) break;
          scope = scope.parent;
        }
        state.targetScope = getHoistingScope(scope);
      }
    };
    var immutabilityVisitor = {
      enter: function enter(path, state) {
        var _expressionResult$deo;
        var stop = function stop() {
          state.isImmutable = false;
          path.stop();
        };
        var skip = function skip() {
          path.skip();
        };
        if (path.isJSXClosingElement()) {
          skip();
          return;
        }
        if (path.isJSXIdentifier({
          name: "ref"
        }) && path.parentPath.isJSXAttribute({
          name: path.node
        })) {
          stop();
          return;
        }
        if (path.isJSXIdentifier() || path.isJSXMemberExpression() || path.isJSXNamespacedName() || path.isImmutable()) {
          return;
        }
        if (path.isIdentifier()) {
          var binding = path.scope.getBinding(path.node.name);
          if (binding != null && binding.constant) return;
        }
        var mutablePropsAllowed = state.mutablePropsAllowed;
        if (mutablePropsAllowed && path.isFunction()) {
          path.traverse(targetScopeVisitor, state);
          skip();
          return;
        }
        if (!path.isPure()) {
          stop();
          return;
        }
        var expressionResult = path.evaluate();
        if (expressionResult.confident) {
          var value = expressionResult.value;
          if (mutablePropsAllowed || value === null || typeof value !== "object" && typeof value !== "function") {
            skip();
            return;
          }
        } else if ((_expressionResult$deo = expressionResult.deopt) != null && _expressionResult$deo.isIdentifier()) {
          return;
        }
        stop();
      }
    };
    var hoistingVisitor = Object.assign({}, immutabilityVisitor, targetScopeVisitor);
    return {
      name: "transform-react-constant-elements",
      visitor: {
        "JSXElement|JSXFragment": function JSXElementJSXFragment(path) {
          var _jsxScope;
          if (HOISTED.has(path.node)) return;
          var mutablePropsAllowed = false;
          var name;
          if (path.isJSXElement()) {
            name = path.node.openingElement.name;
            if (allowMutablePropsOnTags != null) {
              var lastSegment = name;
              while (isJSXMemberExpression$2(lastSegment)) {
                lastSegment = lastSegment.property;
              }
              var elementName = lastSegment.name;
              mutablePropsAllowed = allowMutablePropsOnTags.includes(elementName);
            }
          } else {
            name = path.node;
          }
          var jsxScope;
          var current = path;
          while (!jsxScope && current.parentPath.isJSX()) {
            current = current.parentPath;
            jsxScope = HOISTED.get(current.node);
          }
          (_jsxScope = jsxScope) != null ? _jsxScope : jsxScope = path.scope;
          HOISTED.set(path.node, jsxScope);
          var visitorState = {
            isImmutable: true,
            mutablePropsAllowed: mutablePropsAllowed,
            jsxScope: jsxScope,
            targetScope: path.scope.getProgramParent()
          };
          path.traverse(hoistingVisitor, visitorState);
          if (!visitorState.isImmutable) return;
          var targetScope = visitorState.targetScope;
          for (var currentScope = jsxScope;;) {
            if (targetScope === currentScope) return;
            if (isHoistingScope(currentScope)) break;
            currentScope = currentScope.parent;
            if (!currentScope) {
              throw new Error("Internal @babel/plugin-transform-react-constant-elements error: " + "targetScope must be an ancestor of jsxScope. " + "This is a Babel bug, please report it.");
            }
          }
          var id = path.scope.generateUidBasedOnNode(name);
          targetScope.push({
            id: identifier$d(id)
          });
          HOISTED.set(path.node, targetScope);
          var replacement = template$1.expression.ast(_templateObject$d || (_templateObject$d = _taggedTemplateLiteralLoose(["\n          ", " || (", " = ", ")\n        "])), identifier$d(id), identifier$d(id), path.node);
          if (path.parentPath.isJSXElement() || path.parentPath.isJSXAttribute() || path.parentPath.isJSXFragment()) {
            replacement = jsxExpressionContainer$1(replacement);
          }
          path.replaceWith(replacement);
        }
      }
    };
  });

var _templateObject$c;
  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 = function get(pass, name) {
    return pass.get("@babel/plugin-react-jsx/" + name);
  };
  var set = function set(pass, name, v) {
    return pass.set("@babel/plugin-react-jsx/" + name, v);
  };
  function hasProto(node) {
    return node.properties.some(function (value) {
      return isObjectProperty$3(value, {
        computed: false,
        shorthand: false
      }) && (isIdentifier$e(value.key, {
        name: "__proto__"
      }) || isStringLiteral$5(value.key, {
        value: "__proto__"
      }));
    });
  }
  function createPlugin(_ref) {
    var name = _ref.name,
      development = _ref.development;
    return declare(function (_, options) {
      var PURE_ANNOTATION = options.pure,
        _options$throwIfNames = options.throwIfNamespace,
        throwIfNamespace = _options$throwIfNames === void 0 ? true : _options$throwIfNames,
        filter = options.filter,
        _options$runtime = options.runtime,
        RUNTIME_DEFAULT = _options$runtime === void 0 ? development ? "automatic" : "classic" : _options$runtime,
        _options$importSource = options.importSource,
        IMPORT_SOURCE_DEFAULT = _options$importSource === void 0 ? DEFAULT.importSource : _options$importSource,
        _options$pragma = options.pragma,
        PRAGMA_DEFAULT = _options$pragma === void 0 ? DEFAULT.pragma : _options$pragma,
        _options$pragmaFrag = options.pragmaFrag,
        PRAGMA_FRAG_DEFAULT = _options$pragmaFrag === void 0 ? DEFAULT.pragmaFrag : _options$pragmaFrag;
      {
        var _options$useSpread = options.useSpread,
          useSpread = _options$useSpread === void 0 ? false : _options$useSpread,
          _options$useBuiltIns = options.useBuiltIns,
          useBuiltIns = _options$useBuiltIns === void 0 ? false : _options$useBuiltIns;
        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");
          }
        }
      }
      var injectMetaPropertiesVisitor = {
        JSXOpeningElement: function JSXOpeningElement(path, state) {
          var attributes = [];
          if (isThisAllowed(path.scope)) {
            attributes.push(jsxAttribute(jsxIdentifier$1("__self"), jsxExpressionContainer$1(thisExpression$4())));
          }
          attributes.push(jsxAttribute(jsxIdentifier$1("__source"), jsxExpressionContainer$1(makeSource(path, state))));
          path.pushContainer("attributes", attributes);
        }
      };
      return {
        name: name,
        inherits: syntaxJsx,
        visitor: {
          JSXNamespacedName: function 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: function JSXSpreadChild(path) {
            throw path.buildCodeFrameError("Spread children are not supported in React.");
          },
          Program: {
            enter: function enter(path, state) {
              var file = state.file;
              var runtime = RUNTIME_DEFAULT;
              var source = IMPORT_SOURCE_DEFAULT;
              var pragma = PRAGMA_DEFAULT;
              var pragmaFrag = PRAGMA_FRAG_DEFAULT;
              var sourceSet = !!options.importSource;
              var pragmaSet = !!options.pragma;
              var pragmaFragSet = !!options.pragmaFrag;
              if (file.ast.comments) {
                for (var _iterator = _createForOfIteratorHelperLoose(file.ast.comments), _step; !(_step = _iterator()).done;) {
                  var comment = _step.value;
                  var sourceMatches = JSX_SOURCE_ANNOTATION_REGEX.exec(comment.value);
                  if (sourceMatches) {
                    source = sourceMatches[1];
                    sourceSet = true;
                  }
                  var runtimeMatches = JSX_RUNTIME_ANNOTATION_REGEX.exec(comment.value);
                  if (runtimeMatches) {
                    runtime = runtimeMatches[1];
                  }
                  var jsxMatches = JSX_ANNOTATION_REGEX.exec(comment.value);
                  if (jsxMatches) {
                    pragma = jsxMatches[1];
                    pragmaSet = true;
                  }
                  var jsxFragMatches = JSX_FRAG_ANNOTATION_REGEX.exec(comment.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.");
                }
                var createElement = toMemberExpression(pragma);
                var fragment = toMemberExpression(pragmaFrag);
                set(state, "id/createElement", function () {
                  return cloneNode$e(createElement);
                });
                set(state, "id/fragment", function () {
                  return cloneNode$e(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.");
                }
                var define = function define(name, id) {
                  return set(state, name, createImportLazily(state, path, id, source));
                };
                define("id/jsx", development ? "jsxDEV" : "jsx");
                define("id/jsxs", development ? "jsxDEV" : "jsxs");
                define("id/createElement", "createElement");
                define("id/fragment", "Fragment");
                set(state, "defaultPure", source === DEFAULT.importSource);
              } else {
                throw path.buildCodeFrameError("Runtime must be either \"classic\" or \"automatic\".");
              }
              if (development) {
                path.traverse(injectMetaPropertiesVisitor, state);
              }
            }
          },
          JSXFragment: {
            exit: function exit(path, file) {
              var callExpr;
              if (get(file, "runtime") === "classic") {
                callExpr = buildCreateElementFragmentCall(path, file);
              } else {
                callExpr = buildJSXFragmentCall(path, file);
              }
              path.replaceWith(inherits$3(callExpr, path.node));
            }
          },
          JSXElement: {
            exit: function exit(path, file) {
              var callExpr;
              if (get(file, "runtime") === "classic" || shouldUseCreateElement(path)) {
                callExpr = buildCreateElementCall(path, file);
              } else {
                callExpr = buildJSXElementCall(path, file);
              }
              path.replaceWith(inherits$3(callExpr, path.node));
            }
          },
          JSXAttribute: function JSXAttribute(path) {
            if (isJSXElement(path.node.value)) {
              path.node.value = jsxExpressionContainer$1(path.node.value);
            }
          }
        }
      };
      function isDerivedClass(classPath) {
        return classPath.node.superClass !== null;
      }
      function isThisAllowed(scope) {
        do {
          var _scope = scope,
            path = _scope.path;
          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, name, args) {
        var node = callExpression$c(get(pass, "id/" + name)(), args);
        if (PURE_ANNOTATION != null ? PURE_ANNOTATION : get(pass, "defaultPure")) annotateAsPure(node);
        return node;
      }
      function shouldUseCreateElement(path) {
        var openingPath = path.get("openingElement");
        var attributes = openingPath.node.attributes;
        var seenPropsSpread = false;
        for (var i = 0; i < attributes.length; i++) {
          var attr = attributes[i];
          if (seenPropsSpread && isJSXAttribute(attr) && attr.name.name === "key") {
            return true;
          } else if (isJSXSpreadAttribute$1(attr)) {
            seenPropsSpread = true;
          }
        }
        return false;
      }
      function convertJSXIdentifier(node, parent) {
        if (isJSXIdentifier$3(node)) {
          if (node.name === "this" && isReferenced$2(node, parent)) {
            return thisExpression$4();
          } else if (isValidIdentifier$1(node.name, false)) {
            node.type = "Identifier";
            return node;
          } else {
            return stringLiteral$6(node.name);
          }
        } else if (isJSXMemberExpression$2(node)) {
          return memberExpression$9(convertJSXIdentifier(node.object, node), convertJSXIdentifier(node.property, node));
        } else if (isJSXNamespacedName$1(node)) {
          return stringLiteral$6(node.namespace.name + ":" + node.name.name);
        }
        return node;
      }
      function convertAttributeValue(node) {
        if (isJSXExpressionContainer$1(node)) {
          return node.expression;
        } else {
          return node;
        }
      }
      function accumulateAttribute(array, attribute) {
        if (isJSXSpreadAttribute$1(attribute.node)) {
          var arg = attribute.node.argument;
          if (isObjectExpression$3(arg) && !hasProto(arg)) {
            array.push.apply(array, _toConsumableArray(arg.properties));
          } else {
            array.push(spreadElement$2(arg));
          }
          return array;
        }
        var value = convertAttributeValue(attribute.node.name.name !== "key" ? attribute.node.value || booleanLiteral$2(true) : attribute.node.value);
        if (attribute.node.name.name === "key" && value === null) {
          throw attribute.buildCodeFrameError('Please provide an explicit key value. Using "key" as a shorthand for "key={true}" is not allowed.');
        }
        if (isStringLiteral$5(value) && !isJSXExpressionContainer$1(attribute.node.value)) {
          var _value$extra;
          value.value = value.value.replace(/\n\s+/g, " ");
          (_value$extra = value.extra) == null || delete _value$extra.raw;
        }
        if (isJSXNamespacedName$1(attribute.node.name)) {
          attribute.node.name = stringLiteral$6(attribute.node.name.namespace.name + ":" + attribute.node.name.name.name);
        } else if (isValidIdentifier$1(attribute.node.name.name, false)) {
          attribute.node.name.type = "Identifier";
        } else {
          attribute.node.name = stringLiteral$6(attribute.node.name.name);
        }
        array.push(inherits$3(objectProperty$1(attribute.node.name, value), attribute.node));
        return array;
      }
      function buildChildrenProperty(children) {
        var childrenNode;
        if (children.length === 1) {
          childrenNode = children[0];
        } else if (children.length > 1) {
          childrenNode = arrayExpression$1(children);
        } else {
          return undefined;
        }
        return objectProperty$1(identifier$d("children"), childrenNode);
      }
      function buildJSXElementCall(path, file) {
        var openingPath = path.get("openingElement");
        var args = [getTag(openingPath)];
        var attribsArray = [];
        var extracted = Object.create(null);
        for (var _iterator2 = _createForOfIteratorHelperLoose(openingPath.get("attributes")), _step2; !(_step2 = _iterator2()).done;) {
          var attr = _step2.value;
          if (attr.isJSXAttribute() && isJSXIdentifier$3(attr.node.name)) {
            var _name = attr.node.name.name;
            switch (_name) {
              case "__source":
              case "__self":
                if (extracted[_name]) throw sourceSelfError(path, _name);
              case "key":
                {
                  var 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[_name] = keyValue;
                  break;
                }
              default:
                attribsArray.push(attr);
            }
          } else {
            attribsArray.push(attr);
          }
        }
        var children = react$3.buildChildren(path.node);
        var attribs;
        if (attribsArray.length || children.length) {
          attribs = buildJSXOpeningElementAttributes(attribsArray, children);
        } else {
          attribs = objectExpression$3([]);
        }
        args.push(attribs);
        if (development) {
          var _extracted$key;
          args.push((_extracted$key = extracted.key) != null ? _extracted$key : path.scope.buildUndefinedNode(), booleanLiteral$2(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 !== undefined) {
          args.push(extracted.key);
        }
        return call(file, children.length > 1 ? "jsxs" : "jsx", args);
      }
      function buildJSXOpeningElementAttributes(attribs, children) {
        var props = attribs.reduce(accumulateAttribute, []);
        if ((children == null ? void 0 : children.length) > 0) {
          props.push(buildChildrenProperty(children));
        }
        return objectExpression$3(props);
      }
      function buildJSXFragmentCall(path, file) {
        var args = [get(file, "id/fragment")()];
        var children = react$3.buildChildren(path.node);
        args.push(objectExpression$3(children.length > 0 ? [buildChildrenProperty(children)] : []));
        if (development) {
          args.push(path.scope.buildUndefinedNode(), booleanLiteral$2(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")(), nullLiteral$2()].concat(_toConsumableArray(react$3.buildChildren(path.node))));
      }
      function buildCreateElementCall(path, file) {
        var openingPath = path.get("openingElement");
        return call(file, "createElement", [getTag(openingPath), buildCreateElementOpeningElementAttributes(file, path, openingPath.get("attributes"))].concat(_toConsumableArray(react$3.buildChildren(path.node))));
      }
      function getTag(openingPath) {
        var tagExpr = convertJSXIdentifier(openingPath.node.name, openingPath.node);
        var tagName;
        if (isIdentifier$e(tagExpr)) {
          tagName = tagExpr.name;
        } else if (isStringLiteral$5(tagExpr)) {
          tagName = tagExpr.value;
        }
        if (react$3.isCompatTag(tagName)) {
          return stringLiteral$6(tagName);
        } else {
          return tagExpr;
        }
      }
      function buildCreateElementOpeningElementAttributes(file, path, attribs) {
        var runtime = get(file, "runtime");
        {
          if (runtime !== "automatic") {
            var objs = [];
            var _props = attribs.reduce(accumulateAttribute, []);
            if (!useSpread) {
              var start = 0;
              _props.forEach(function (prop, i) {
                if (isSpreadElement$1(prop)) {
                  if (i > start) {
                    objs.push(objectExpression$3(_props.slice(start, i)));
                  }
                  objs.push(prop.argument);
                  start = i + 1;
                }
              });
              if (_props.length > start) {
                objs.push(objectExpression$3(_props.slice(start)));
              }
            } else if (_props.length) {
              objs.push(objectExpression$3(_props));
            }
            if (!objs.length) {
              return nullLiteral$2();
            }
            if (objs.length === 1) {
              if (!(isSpreadElement$1(_props[0]) && isObjectExpression$3(_props[0].argument))) {
                return objs[0];
              }
            }
            if (!isObjectExpression$3(objs[0])) {
              objs.unshift(objectExpression$3([]));
            }
            var helper = useBuiltIns ? memberExpression$9(identifier$d("Object"), identifier$d("assign")) : file.addHelper("extends");
            return callExpression$c(helper, objs);
          }
        }
        var props = [];
        var found = Object.create(null);
        for (var _iterator3 = _createForOfIteratorHelperLoose(attribs), _step3; !(_step3 = _iterator3()).done;) {
          var attr = _step3.value;
          var node = attr.node;
          var _name2 = isJSXAttribute(node) && isJSXIdentifier$3(node.name) && node.name.name;
          if (runtime === "automatic" && (_name2 === "__source" || _name2 === "__self")) {
            if (found[_name2]) throw sourceSelfError(path, _name2);
            found[_name2] = true;
          }
          accumulateAttribute(props, attr);
        }
        return props.length === 1 && isSpreadElement$1(props[0]) && !isObjectExpression$3(props[0].argument) ? props[0].argument : props.length > 0 ? objectExpression$3(props) : nullLiteral$2();
      }
    });
    function getSource(source, importName) {
      switch (importName) {
        case "Fragment":
          return source + "/" + (development ? "jsx-dev-runtime" : "jsx-runtime");
        case "jsxDEV":
          return source + "/jsx-dev-runtime";
        case "jsx":
        case "jsxs":
          return source + "/jsx-runtime";
        case "createElement":
          return source;
      }
    }
    function createImportLazily(pass, path, importName, source) {
      return function () {
        var actualSource = getSource(source, importName);
        if (isModule(path)) {
          var reference = get(pass, "imports/" + importName);
          if (reference) return cloneNode$e(reference);
          reference = addNamed(path, importName, actualSource, {
            importedInterop: "uncompiled",
            importPosition: "after"
          });
          set(pass, "imports/" + importName, reference);
          return reference;
        } else {
          var _reference = get(pass, "requires/" + actualSource);
          if (_reference) {
            _reference = cloneNode$e(_reference);
          } else {
            _reference = addNamespace(path, actualSource, {
              importedInterop: "uncompiled"
            });
            set(pass, "requires/" + actualSource, _reference);
          }
          return memberExpression$9(_reference, identifier$d(importName));
        }
      };
    }
  }
  function toMemberExpression(id) {
    return id.split(".").map(function (name) {
      return identifier$d(name);
    }).reduce(function (object, property) {
      return memberExpression$9(object, property);
    });
  }
  function makeSource(path, state) {
    var location = path.node.loc;
    if (!location) {
      return path.scope.buildUndefinedNode();
    }
    if (!state.fileNameIdentifier) {
      var _state$filename = state.filename,
        filename = _state$filename === void 0 ? "" : _state$filename;
      var fileNameIdentifier = path.scope.generateUidIdentifier("_jsxFileName");
      path.scope.getProgramParent().push({
        id: fileNameIdentifier,
        init: stringLiteral$6(filename)
      });
      state.fileNameIdentifier = fileNameIdentifier;
    }
    return makeTrace(cloneNode$e(state.fileNameIdentifier), location.start.line, location.start.column);
  }
  function makeTrace(fileNameIdentifier, lineNumber, column0Based) {
    var fileLineLiteral = lineNumber != null ? numericLiteral$5(lineNumber) : nullLiteral$2();
    var fileColumnLiteral = column0Based != null ? numericLiteral$5(column0Based + 1) : nullLiteral$2();
    return template$1.expression.ast(_templateObject$c || (_templateObject$c = _taggedTemplateLiteralLoose(["{\n    fileName: ", ",\n    lineNumber: ", ",\n    columnNumber: ", ",\n  }"])), fileNameIdentifier, fileLineLiteral, fileColumnLiteral);
  }
  function sourceSelfError(path, name) {
    var pluginName = "transform-react-jsx-" + name.slice(2);
    return path.buildCodeFrameError("Duplicate " + name + " 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.");
  }

var transformReactJSX = createPlugin({
    name: "transform-react-jsx",
    development: false
  });

var plugin = createPlugin({
    name: "transform-react-jsx/development",
    development: true
  });

var _templateObject$b;
  var TRACE_ID = "__source";
  var FILE_NAME_VAR = "_jsxFileName";
  var createNodeFromNullish = function createNodeFromNullish(val, fn) {
    return val == null ? nullLiteral$2() : fn(val);
  };
  var transformReactJsxSource = declare(function (api) {
    api.assertVersion("*");
    function makeTrace(fileNameIdentifier, _ref) {
      var line = _ref.line,
        column = _ref.column;
      var fileLineLiteral = createNodeFromNullish(line, numericLiteral$5);
      var fileColumnLiteral = createNodeFromNullish(column, function (c) {
        return (numericLiteral$5(c + 1)
        );
      });
      return template$1.expression.ast(_templateObject$b || (_templateObject$b = _taggedTemplateLiteralLoose(["{\n      fileName: ", ",\n      lineNumber: ", ",\n      columnNumber: ", ",\n    }"])), fileNameIdentifier, fileLineLiteral, fileColumnLiteral);
    }
    var isSourceAttr = function isSourceAttr(attr) {
      return isJSXAttribute(attr) && attr.name.name === TRACE_ID;
    };
    return {
      name: "transform-react-jsx-source",
      visitor: {
        JSXOpeningElement: function JSXOpeningElement(path, state) {
          var node = path.node;
          if (!node.loc || path.node.attributes.some(isSourceAttr)) {
            return;
          }
          if (!state.fileNameIdentifier) {
            var fileNameId = path.scope.generateUidIdentifier(FILE_NAME_VAR);
            state.fileNameIdentifier = fileNameId;
            path.scope.getProgramParent().push({
              id: fileNameId,
              init: stringLiteral$6(state.filename || "")
            });
          }
          node.attributes.push(jsxAttribute(jsxIdentifier$1(TRACE_ID), jsxExpressionContainer$1(makeTrace(cloneNode$e(state.fileNameIdentifier), node.loc.start))));
        }
      }
    };
  });

var lib$7 = {};

var visit = {};

var interopRequireDefault = {exports: {}};

var require$$1$3 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_assert);

var hoist$1 = {};

var util$1 = {};

var hasRequiredUtil;
  function requireUtil() {
    if (hasRequiredUtil) return util$1;
    hasRequiredUtil = 1;
    util$1.__esModule = true;
    util$1.getTypes = getTypes;
    util$1.isReference = isReference;
    util$1.replaceWithOrRemove = replaceWithOrRemove;
    util$1.runtimeProperty = runtimeProperty;
    util$1.wrapWithTypes = wrapWithTypes;
    var currentTypes = null;
    function wrapWithTypes(types, fn) {
      return function () {
        var oldTypes = currentTypes;
        currentTypes = types;
        try {
          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }
          return fn.apply(this, args);
        } finally {
          currentTypes = oldTypes;
        }
      };
    }
    function getTypes() {
      return currentTypes;
    }
    function runtimeProperty(name) {
      var t = getTypes();
      return t.memberExpression(t.identifier("regeneratorRuntime"), t.identifier(name), false);
    }
    function isReference(path) {
      return path.isReferenced() || path.parentPath.isAssignmentExpression({
        left: path.node
      });
    }
    function replaceWithOrRemove(path, replacement) {
      if (replacement) {
        path.replaceWith(replacement);
      } else {
        path.remove();
      }
    }
    return util$1;
  }

var hasRequiredHoist;
  function requireHoist() {
    if (hasRequiredHoist) return hoist$1;
    hasRequiredHoist = 1;
    var util = _interopRequireWildcard(requireUtil());
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    var hasOwn = Object.prototype.hasOwnProperty;
    hoist$1.hoist = function (funPath) {
      var t = util.getTypes();
      t.assertFunction(funPath.node);
      var vars = {};
      function varDeclToExpr(_ref, includeIdentifiers) {
        var vdec = _ref.node,
          scope = _ref.scope;
        t.assertVariableDeclaration(vdec);
        var exprs = [];
        vdec.declarations.forEach(function (dec) {
          vars[dec.id.name] = t.identifier(dec.id.name);
          scope.removeBinding(dec.id.name);
          if (dec.init) {
            exprs.push(t.assignmentExpression("=", dec.id, dec.init));
          } else if (includeIdentifiers) {
            exprs.push(dec.id);
          }
        });
        if (exprs.length === 0) return null;
        if (exprs.length === 1) return exprs[0];
        return t.sequenceExpression(exprs);
      }
      funPath.get("body").traverse({
        VariableDeclaration: {
          exit: function exit(path) {
            var expr = varDeclToExpr(path, false);
            if (expr === null) {
              path.remove();
            } else {
              util.replaceWithOrRemove(path, t.expressionStatement(expr));
            }
            path.skip();
          }
        },
        ForStatement: function ForStatement(path) {
          var init = path.get("init");
          if (init.isVariableDeclaration()) {
            util.replaceWithOrRemove(init, varDeclToExpr(init, false));
          }
        },
        ForXStatement: function ForXStatement(path) {
          var left = path.get("left");
          if (left.isVariableDeclaration()) {
            util.replaceWithOrRemove(left, varDeclToExpr(left, true));
          }
        },
        FunctionDeclaration: function FunctionDeclaration(path) {
          var node = path.node;
          vars[node.id.name] = node.id;
          var assignment = t.expressionStatement(t.assignmentExpression("=", t.clone(node.id), t.functionExpression(path.scope.generateUidIdentifierBasedOnNode(node), node.params, node.body, node.generator, node.expression)));
          if (path.parentPath.isBlockStatement()) {
            path.parentPath.unshiftContainer("body", assignment);
            path.remove();
          } else {
            util.replaceWithOrRemove(path, assignment);
          }
          path.scope.removeBinding(node.id.name);
          path.skip();
        },
        FunctionExpression: function FunctionExpression(path) {
          path.skip();
        },
        ArrowFunctionExpression: function ArrowFunctionExpression(path) {
          path.skip();
        }
      });
      var paramNames = {};
      funPath.get("params").forEach(function (paramPath) {
        var param = paramPath.node;
        if (t.isIdentifier(param)) {
          paramNames[param.name] = param;
        }
      });
      var declarations = [];
      Object.keys(vars).forEach(function (name) {
        if (!hasOwn.call(paramNames, name)) {
          declarations.push(t.variableDeclarator(vars[name], null));
        }
      });
      if (declarations.length === 0) {
        return null;
      }
      return t.variableDeclaration("var", declarations);
    };
    return hoist$1;
  }

var emit = {};

var leap = {};

var require$$3 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_util$1);

var hasRequiredLeap;
  function requireLeap() {
    if (hasRequiredLeap) return leap;
    hasRequiredLeap = 1;
    var _interopRequireDefault = interopRequireDefaultExports;
    var _assert = _interopRequireDefault(require$$1$3);
    var _emit = requireEmit();
    var _util = require$$3;
    var _util2 = requireUtil();
    function Entry() {
      _assert["default"].ok(this instanceof Entry);
    }
    function FunctionEntry(returnLoc) {
      Entry.call(this);
      (0, _util2.getTypes)().assertLiteral(returnLoc);
      this.returnLoc = returnLoc;
    }
    (0, _util.inherits)(FunctionEntry, Entry);
    leap.FunctionEntry = FunctionEntry;
    function LoopEntry(breakLoc, continueLoc, label) {
      Entry.call(this);
      var t = (0, _util2.getTypes)();
      t.assertLiteral(breakLoc);
      t.assertLiteral(continueLoc);
      if (label) {
        t.assertIdentifier(label);
      } else {
        label = null;
      }
      this.breakLoc = breakLoc;
      this.continueLoc = continueLoc;
      this.label = label;
    }
    (0, _util.inherits)(LoopEntry, Entry);
    leap.LoopEntry = LoopEntry;
    function SwitchEntry(breakLoc) {
      Entry.call(this);
      (0, _util2.getTypes)().assertLiteral(breakLoc);
      this.breakLoc = breakLoc;
    }
    (0, _util.inherits)(SwitchEntry, Entry);
    leap.SwitchEntry = SwitchEntry;
    function TryEntry(firstLoc, catchEntry, finallyEntry) {
      Entry.call(this);
      var t = (0, _util2.getTypes)();
      t.assertLiteral(firstLoc);
      if (catchEntry) {
        _assert["default"].ok(catchEntry instanceof CatchEntry);
      } else {
        catchEntry = null;
      }
      if (finallyEntry) {
        _assert["default"].ok(finallyEntry instanceof FinallyEntry);
      } else {
        finallyEntry = null;
      }
      _assert["default"].ok(catchEntry || finallyEntry);
      this.firstLoc = firstLoc;
      this.catchEntry = catchEntry;
      this.finallyEntry = finallyEntry;
    }
    (0, _util.inherits)(TryEntry, Entry);
    leap.TryEntry = TryEntry;
    function CatchEntry(firstLoc, paramId) {
      Entry.call(this);
      var t = (0, _util2.getTypes)();
      t.assertLiteral(firstLoc);
      t.assertIdentifier(paramId);
      this.firstLoc = firstLoc;
      this.paramId = paramId;
    }
    (0, _util.inherits)(CatchEntry, Entry);
    leap.CatchEntry = CatchEntry;
    function FinallyEntry(firstLoc, afterLoc) {
      Entry.call(this);
      var t = (0, _util2.getTypes)();
      t.assertLiteral(firstLoc);
      t.assertLiteral(afterLoc);
      this.firstLoc = firstLoc;
      this.afterLoc = afterLoc;
    }
    (0, _util.inherits)(FinallyEntry, Entry);
    leap.FinallyEntry = FinallyEntry;
    function LabeledEntry(breakLoc, label) {
      Entry.call(this);
      var t = (0, _util2.getTypes)();
      t.assertLiteral(breakLoc);
      t.assertIdentifier(label);
      this.breakLoc = breakLoc;
      this.label = label;
    }
    (0, _util.inherits)(LabeledEntry, Entry);
    leap.LabeledEntry = LabeledEntry;
    function LeapManager(emitter) {
      _assert["default"].ok(this instanceof LeapManager);
      _assert["default"].ok(emitter instanceof _emit.Emitter);
      this.emitter = emitter;
      this.entryStack = [new FunctionEntry(emitter.finalLoc)];
    }
    var LMp = LeapManager.prototype;
    leap.LeapManager = LeapManager;
    LMp.withEntry = function (entry, callback) {
      _assert["default"].ok(entry instanceof Entry);
      this.entryStack.push(entry);
      try {
        callback.call(this.emitter);
      } finally {
        var popped = this.entryStack.pop();
        _assert["default"].strictEqual(popped, entry);
      }
    };
    LMp._findLeapLocation = function (property, label) {
      for (var i = this.entryStack.length - 1; i >= 0; --i) {
        var entry = this.entryStack[i];
        var loc = entry[property];
        if (loc) {
          if (label) {
            if (entry.label && entry.label.name === label.name) {
              return loc;
            }
          } else if (entry instanceof LabeledEntry) ; else {
            return loc;
          }
        }
      }
      return null;
    };
    LMp.getBreakLoc = function (label) {
      return this._findLeapLocation("breakLoc", label);
    };
    LMp.getContinueLoc = function (label) {
      return this._findLeapLocation("continueLoc", label);
    };
    return leap;
  }

var meta = {};

var hasRequiredMeta;
  function requireMeta() {
    if (hasRequiredMeta) return meta;
    hasRequiredMeta = 1;
    var _interopRequireDefault = interopRequireDefaultExports;
    var _assert = _interopRequireDefault(require$$1$3);
    var _util = requireUtil();
    var mMap = new WeakMap();
    function m(node) {
      if (!mMap.has(node)) {
        mMap.set(node, {});
      }
      return mMap.get(node);
    }
    var hasOwn = Object.prototype.hasOwnProperty;
    function makePredicate(propertyName, knownTypes) {
      function onlyChildren(node) {
        var t = (0, _util.getTypes)();
        t.assertNode(node);
        var result = false;
        function check(child) {
          if (result) ; else if (Array.isArray(child)) {
            child.some(check);
          } else if (t.isNode(child)) {
            _assert["default"].strictEqual(result, false);
            result = predicate(child);
          }
          return result;
        }
        var keys = t.VISITOR_KEYS[node.type];
        if (keys) {
          for (var i = 0; i < keys.length; i++) {
            var key = keys[i];
            var child = node[key];
            check(child);
          }
        }
        return result;
      }
      function predicate(node) {
        (0, _util.getTypes)().assertNode(node);
        var meta = m(node);
        if (hasOwn.call(meta, propertyName)) return meta[propertyName];
        if (hasOwn.call(opaqueTypes, node.type)) return meta[propertyName] = false;
        if (hasOwn.call(knownTypes, node.type)) return meta[propertyName] = true;
        return meta[propertyName] = onlyChildren(node);
      }
      predicate.onlyChildren = onlyChildren;
      return predicate;
    }
    var opaqueTypes = {
      FunctionExpression: true,
      ArrowFunctionExpression: true
    };
    var sideEffectTypes = {
      CallExpression: true,
      ForInStatement: true,
      UnaryExpression: true,
      BinaryExpression: true,
      AssignmentExpression: true,
      UpdateExpression: true,
      NewExpression: true
    };
    var leapTypes = {
      YieldExpression: true,
      BreakStatement: true,
      ContinueStatement: true,
      ReturnStatement: true,
      ThrowStatement: true
    };
    for (var type in leapTypes) {
      if (hasOwn.call(leapTypes, type)) {
        sideEffectTypes[type] = leapTypes[type];
      }
    }
    meta.hasSideEffects = makePredicate("hasSideEffects", sideEffectTypes);
    meta.containsLeap = makePredicate("containsLeap", leapTypes);
    return meta;
  }

var hasRequiredEmit;
  function requireEmit() {
    if (hasRequiredEmit) return emit;
    hasRequiredEmit = 1;
    var _interopRequireDefault = interopRequireDefaultExports;
    var _assert = _interopRequireDefault(require$$1$3);
    var leap = _interopRequireWildcard(requireLeap());
    var meta = _interopRequireWildcard(requireMeta());
    var util = _interopRequireWildcard(requireUtil());
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    var hasOwn = Object.prototype.hasOwnProperty;
    function Emitter(contextId) {
      _assert["default"].ok(this instanceof Emitter);
      util.getTypes().assertIdentifier(contextId);
      this.nextTempId = 0;
      this.contextId = contextId;
      this.listing = [];
      this.marked = [true];
      this.insertedLocs = new Set();
      this.finalLoc = this.loc();
      this.tryEntries = [];
      this.leapManager = new leap.LeapManager(this);
    }
    var Ep = Emitter.prototype;
    emit.Emitter = Emitter;
    var PENDING_LOCATION = Number.MAX_VALUE;
    Ep.loc = function () {
      var l = util.getTypes().numericLiteral(PENDING_LOCATION);
      this.insertedLocs.add(l);
      return l;
    };
    Ep.getInsertedLocs = function () {
      return this.insertedLocs;
    };
    Ep.getContextId = function () {
      return util.getTypes().clone(this.contextId);
    };
    Ep.mark = function (loc) {
      util.getTypes().assertLiteral(loc);
      var index = this.listing.length;
      if (loc.value === PENDING_LOCATION) {
        loc.value = index;
      } else {
        _assert["default"].strictEqual(loc.value, index);
      }
      this.marked[index] = true;
      return loc;
    };
    Ep.emit = function (node) {
      var t = util.getTypes();
      if (t.isExpression(node)) {
        node = t.expressionStatement(node);
      }
      t.assertStatement(node);
      this.listing.push(node);
    };
    Ep.emitAssign = function (lhs, rhs) {
      this.emit(this.assign(lhs, rhs));
      return lhs;
    };
    Ep.assign = function (lhs, rhs) {
      var t = util.getTypes();
      return t.expressionStatement(t.assignmentExpression("=", t.cloneDeep(lhs), rhs));
    };
    Ep.contextProperty = function (name, computed) {
      var t = util.getTypes();
      return t.memberExpression(this.getContextId(), computed ? t.stringLiteral(name) : t.identifier(name), !!computed);
    };
    Ep.stop = function (rval) {
      if (rval) {
        this.setReturnValue(rval);
      }
      this.jump(this.finalLoc);
    };
    Ep.setReturnValue = function (valuePath) {
      util.getTypes().assertExpression(valuePath.value);
      this.emitAssign(this.contextProperty("rval"), this.explodeExpression(valuePath));
    };
    Ep.clearPendingException = function (tryLoc, assignee) {
      var t = util.getTypes();
      t.assertLiteral(tryLoc);
      var catchCall = t.callExpression(this.contextProperty("catch", true), [t.clone(tryLoc)]);
      if (assignee) {
        this.emitAssign(assignee, catchCall);
      } else {
        this.emit(catchCall);
      }
    };
    Ep.jump = function (toLoc) {
      this.emitAssign(this.contextProperty("next"), toLoc);
      this.emit(util.getTypes().breakStatement());
    };
    Ep.jumpIf = function (test, toLoc) {
      var t = util.getTypes();
      t.assertExpression(test);
      t.assertLiteral(toLoc);
      this.emit(t.ifStatement(test, t.blockStatement([this.assign(this.contextProperty("next"), toLoc), t.breakStatement()])));
    };
    Ep.jumpIfNot = function (test, toLoc) {
      var t = util.getTypes();
      t.assertExpression(test);
      t.assertLiteral(toLoc);
      var negatedTest;
      if (t.isUnaryExpression(test) && test.operator === "!") {
        negatedTest = test.argument;
      } else {
        negatedTest = t.unaryExpression("!", test);
      }
      this.emit(t.ifStatement(negatedTest, t.blockStatement([this.assign(this.contextProperty("next"), toLoc), t.breakStatement()])));
    };
    Ep.makeTempVar = function () {
      return this.contextProperty("t" + this.nextTempId++);
    };
    Ep.getContextFunction = function (id) {
      var t = util.getTypes();
      return t.functionExpression(id || null, [this.getContextId()], t.blockStatement([this.getDispatchLoop()]), false, false);
    };
    Ep.getDispatchLoop = function () {
      var self = this;
      var t = util.getTypes();
      var cases = [];
      var current;
      var alreadyEnded = false;
      self.listing.forEach(function (stmt, i) {
        if (self.marked.hasOwnProperty(i)) {
          cases.push(t.switchCase(t.numericLiteral(i), current = []));
          alreadyEnded = false;
        }
        if (!alreadyEnded) {
          current.push(stmt);
          if (t.isCompletionStatement(stmt)) alreadyEnded = true;
        }
      });
      this.finalLoc.value = this.listing.length;
      cases.push(t.switchCase(this.finalLoc, []), t.switchCase(t.stringLiteral("end"), [t.returnStatement(t.callExpression(this.contextProperty("stop"), []))]));
      return t.whileStatement(t.numericLiteral(1), t.switchStatement(t.assignmentExpression("=", this.contextProperty("prev"), this.contextProperty("next")), cases));
    };
    Ep.getTryLocsList = function () {
      if (this.tryEntries.length === 0) {
        return null;
      }
      var t = util.getTypes();
      var lastLocValue = 0;
      return t.arrayExpression(this.tryEntries.map(function (tryEntry) {
        var thisLocValue = tryEntry.firstLoc.value;
        _assert["default"].ok(thisLocValue >= lastLocValue, "try entries out of order");
        lastLocValue = thisLocValue;
        var ce = tryEntry.catchEntry;
        var fe = tryEntry.finallyEntry;
        var locs = [tryEntry.firstLoc, ce ? ce.firstLoc : null];
        if (fe) {
          locs[2] = fe.firstLoc;
          locs[3] = fe.afterLoc;
        }
        return t.arrayExpression(locs.map(function (loc) {
          return loc && t.clone(loc);
        }));
      }));
    };
    Ep.explode = function (path, ignoreResult) {
      var t = util.getTypes();
      var node = path.node;
      var self = this;
      t.assertNode(node);
      if (t.isDeclaration(node)) throw getDeclError(node);
      if (t.isStatement(node)) return self.explodeStatement(path);
      if (t.isExpression(node)) return self.explodeExpression(path, ignoreResult);
      switch (node.type) {
        case "Program":
          return path.get("body").map(self.explodeStatement, self);
        case "VariableDeclarator":
          throw getDeclError(node);
        case "Property":
        case "SwitchCase":
        case "CatchClause":
          throw new Error(node.type + " nodes should be handled by their parents");
        default:
          throw new Error("unknown Node of type " + JSON.stringify(node.type));
      }
    };
    function getDeclError(node) {
      return new Error("all declarations should have been transformed into " + "assignments before the Exploder began its work: " + JSON.stringify(node));
    }
    Ep.explodeStatement = function (path, labelId) {
      var t = util.getTypes();
      var stmt = path.node;
      var self = this;
      var before, after, head;
      t.assertStatement(stmt);
      if (labelId) {
        t.assertIdentifier(labelId);
      } else {
        labelId = null;
      }
      if (t.isBlockStatement(stmt)) {
        path.get("body").forEach(function (path) {
          self.explodeStatement(path);
        });
        return;
      }
      if (!meta.containsLeap(stmt)) {
        self.emit(stmt);
        return;
      }
      switch (stmt.type) {
        case "ExpressionStatement":
          self.explodeExpression(path.get("expression"), true);
          break;
        case "LabeledStatement":
          after = this.loc();
          self.leapManager.withEntry(new leap.LabeledEntry(after, stmt.label), function () {
            self.explodeStatement(path.get("body"), stmt.label);
          });
          self.mark(after);
          break;
        case "WhileStatement":
          before = this.loc();
          after = this.loc();
          self.mark(before);
          self.jumpIfNot(self.explodeExpression(path.get("test")), after);
          self.leapManager.withEntry(new leap.LoopEntry(after, before, labelId), function () {
            self.explodeStatement(path.get("body"));
          });
          self.jump(before);
          self.mark(after);
          break;
        case "DoWhileStatement":
          var first = this.loc();
          var test = this.loc();
          after = this.loc();
          self.mark(first);
          self.leapManager.withEntry(new leap.LoopEntry(after, test, labelId), function () {
            self.explode(path.get("body"));
          });
          self.mark(test);
          self.jumpIf(self.explodeExpression(path.get("test")), first);
          self.mark(after);
          break;
        case "ForStatement":
          head = this.loc();
          var update = this.loc();
          after = this.loc();
          if (stmt.init) {
            self.explode(path.get("init"), true);
          }
          self.mark(head);
          if (stmt.test) {
            self.jumpIfNot(self.explodeExpression(path.get("test")), after);
          }
          self.leapManager.withEntry(new leap.LoopEntry(after, update, labelId), function () {
            self.explodeStatement(path.get("body"));
          });
          self.mark(update);
          if (stmt.update) {
            self.explode(path.get("update"), true);
          }
          self.jump(head);
          self.mark(after);
          break;
        case "TypeCastExpression":
          return self.explodeExpression(path.get("expression"));
        case "ForInStatement":
          head = this.loc();
          after = this.loc();
          var keyIterNextFn = self.makeTempVar();
          self.emitAssign(keyIterNextFn, t.callExpression(util.runtimeProperty("keys"), [self.explodeExpression(path.get("right"))]));
          self.mark(head);
          var keyInfoTmpVar = self.makeTempVar();
          self.jumpIf(t.memberExpression(t.assignmentExpression("=", keyInfoTmpVar, t.callExpression(t.cloneDeep(keyIterNextFn), [])), t.identifier("done"), false), after);
          self.emitAssign(stmt.left, t.memberExpression(t.cloneDeep(keyInfoTmpVar), t.identifier("value"), false));
          self.leapManager.withEntry(new leap.LoopEntry(after, head, labelId), function () {
            self.explodeStatement(path.get("body"));
          });
          self.jump(head);
          self.mark(after);
          break;
        case "BreakStatement":
          self.emitAbruptCompletion({
            type: "break",
            target: self.leapManager.getBreakLoc(stmt.label)
          });
          break;
        case "ContinueStatement":
          self.emitAbruptCompletion({
            type: "continue",
            target: self.leapManager.getContinueLoc(stmt.label)
          });
          break;
        case "SwitchStatement":
          var disc = self.emitAssign(self.makeTempVar(), self.explodeExpression(path.get("discriminant")));
          after = this.loc();
          var defaultLoc = this.loc();
          var condition = defaultLoc;
          var caseLocs = [];
          var cases = stmt.cases || [];
          for (var i = cases.length - 1; i >= 0; --i) {
            var c = cases[i];
            t.assertSwitchCase(c);
            if (c.test) {
              condition = t.conditionalExpression(t.binaryExpression("===", t.cloneDeep(disc), c.test), caseLocs[i] = this.loc(), condition);
            } else {
              caseLocs[i] = defaultLoc;
            }
          }
          var discriminant = path.get("discriminant");
          util.replaceWithOrRemove(discriminant, condition);
          self.jump(self.explodeExpression(discriminant));
          self.leapManager.withEntry(new leap.SwitchEntry(after), function () {
            path.get("cases").forEach(function (casePath) {
              var i = casePath.key;
              self.mark(caseLocs[i]);
              casePath.get("consequent").forEach(function (path) {
                self.explodeStatement(path);
              });
            });
          });
          self.mark(after);
          if (defaultLoc.value === PENDING_LOCATION) {
            self.mark(defaultLoc);
            _assert["default"].strictEqual(after.value, defaultLoc.value);
          }
          break;
        case "IfStatement":
          var elseLoc = stmt.alternate && this.loc();
          after = this.loc();
          self.jumpIfNot(self.explodeExpression(path.get("test")), elseLoc || after);
          self.explodeStatement(path.get("consequent"));
          if (elseLoc) {
            self.jump(after);
            self.mark(elseLoc);
            self.explodeStatement(path.get("alternate"));
          }
          self.mark(after);
          break;
        case "ReturnStatement":
          self.emitAbruptCompletion({
            type: "return",
            value: self.explodeExpression(path.get("argument"))
          });
          break;
        case "WithStatement":
          throw new Error("WithStatement not supported in generator functions.");
        case "TryStatement":
          after = this.loc();
          var handler = stmt.handler;
          var catchLoc = handler && this.loc();
          var catchEntry = catchLoc && new leap.CatchEntry(catchLoc, handler.param);
          var finallyLoc = stmt.finalizer && this.loc();
          var finallyEntry = finallyLoc && new leap.FinallyEntry(finallyLoc, after);
          var tryEntry = new leap.TryEntry(self.getUnmarkedCurrentLoc(), catchEntry, finallyEntry);
          self.tryEntries.push(tryEntry);
          self.updateContextPrevLoc(tryEntry.firstLoc);
          self.leapManager.withEntry(tryEntry, function () {
            self.explodeStatement(path.get("block"));
            if (catchLoc) {
              if (finallyLoc) {
                self.jump(finallyLoc);
              } else {
                self.jump(after);
              }
              self.updateContextPrevLoc(self.mark(catchLoc));
              var bodyPath = path.get("handler.body");
              var safeParam = self.makeTempVar();
              self.clearPendingException(tryEntry.firstLoc, safeParam);
              bodyPath.traverse(catchParamVisitor, {
                getSafeParam: function getSafeParam() {
                  return t.cloneDeep(safeParam);
                },
                catchParamName: handler.param.name
              });
              self.leapManager.withEntry(catchEntry, function () {
                self.explodeStatement(bodyPath);
              });
            }
            if (finallyLoc) {
              self.updateContextPrevLoc(self.mark(finallyLoc));
              self.leapManager.withEntry(finallyEntry, function () {
                self.explodeStatement(path.get("finalizer"));
              });
              self.emit(t.returnStatement(t.callExpression(self.contextProperty("finish"), [finallyEntry.firstLoc])));
            }
          });
          self.mark(after);
          break;
        case "ThrowStatement":
          self.emit(t.throwStatement(self.explodeExpression(path.get("argument"))));
          break;
        case "ClassDeclaration":
          self.emit(self.explodeClass(path));
          break;
        default:
          throw new Error("unknown Statement of type " + JSON.stringify(stmt.type));
      }
    };
    var catchParamVisitor = {
      Identifier: function Identifier(path, state) {
        if (path.node.name === state.catchParamName && util.isReference(path)) {
          util.replaceWithOrRemove(path, state.getSafeParam());
        }
      },
      Scope: function Scope(path, state) {
        if (path.scope.hasOwnBinding(state.catchParamName)) {
          path.skip();
        }
      }
    };
    Ep.emitAbruptCompletion = function (record) {
      if (!isValidCompletion(record)) {
        _assert["default"].ok(false, "invalid completion record: " + JSON.stringify(record));
      }
      _assert["default"].notStrictEqual(record.type, "normal", "normal completions are not abrupt");
      var t = util.getTypes();
      var abruptArgs = [t.stringLiteral(record.type)];
      if (record.type === "break" || record.type === "continue") {
        t.assertLiteral(record.target);
        abruptArgs[1] = this.insertedLocs.has(record.target) ? record.target : t.cloneDeep(record.target);
      } else if (record.type === "return" || record.type === "throw") {
        if (record.value) {
          t.assertExpression(record.value);
          abruptArgs[1] = this.insertedLocs.has(record.value) ? record.value : t.cloneDeep(record.value);
        }
      }
      this.emit(t.returnStatement(t.callExpression(this.contextProperty("abrupt"), abruptArgs)));
    };
    function isValidCompletion(record) {
      var type = record.type;
      if (type === "normal") {
        return !hasOwn.call(record, "target");
      }
      if (type === "break" || type === "continue") {
        return !hasOwn.call(record, "value") && util.getTypes().isLiteral(record.target);
      }
      if (type === "return" || type === "throw") {
        return hasOwn.call(record, "value") && !hasOwn.call(record, "target");
      }
      return false;
    }
    Ep.getUnmarkedCurrentLoc = function () {
      return util.getTypes().numericLiteral(this.listing.length);
    };
    Ep.updateContextPrevLoc = function (loc) {
      var t = util.getTypes();
      if (loc) {
        t.assertLiteral(loc);
        if (loc.value === PENDING_LOCATION) {
          loc.value = this.listing.length;
        } else {
          _assert["default"].strictEqual(loc.value, this.listing.length);
        }
      } else {
        loc = this.getUnmarkedCurrentLoc();
      }
      this.emitAssign(this.contextProperty("prev"), loc);
    };
    Ep.explodeViaTempVar = function (tempVar, childPath, hasLeapingChildren, ignoreChildResult) {
      _assert["default"].ok(!ignoreChildResult || !tempVar, "Ignoring the result of a child expression but forcing it to " + "be assigned to a temporary variable?");
      var t = util.getTypes();
      var result = this.explodeExpression(childPath, ignoreChildResult);
      if (ignoreChildResult) ; else if (tempVar || hasLeapingChildren && !t.isLiteral(result)) {
        result = this.emitAssign(tempVar || this.makeTempVar(), result);
      }
      return result;
    };
    Ep.explodeExpression = function (path, ignoreResult) {
      var t = util.getTypes();
      var expr = path.node;
      if (expr) {
        t.assertExpression(expr);
      } else {
        return expr;
      }
      var self = this;
      var result;
      var after;
      function finish(expr) {
        t.assertExpression(expr);
        if (ignoreResult) {
          self.emit(expr);
        }
        return expr;
      }
      if (!meta.containsLeap(expr)) {
        return finish(expr);
      }
      var hasLeapingChildren = meta.containsLeap.onlyChildren(expr);
      switch (expr.type) {
        case "MemberExpression":
          return finish(t.memberExpression(self.explodeExpression(path.get("object")), expr.computed ? self.explodeViaTempVar(null, path.get("property"), hasLeapingChildren) : expr.property, expr.computed));
        case "CallExpression":
          var calleePath = path.get("callee");
          var argsPath = path.get("arguments");
          var newCallee;
          var newArgs;
          var hasLeapingArgs = argsPath.some(function (argPath) {
            return meta.containsLeap(argPath.node);
          });
          var injectFirstArg = null;
          if (t.isMemberExpression(calleePath.node)) {
            if (hasLeapingArgs) {
              var newObject = self.explodeViaTempVar(self.makeTempVar(), calleePath.get("object"), hasLeapingChildren);
              var newProperty = calleePath.node.computed ? self.explodeViaTempVar(null, calleePath.get("property"), hasLeapingChildren) : calleePath.node.property;
              injectFirstArg = newObject;
              newCallee = t.memberExpression(t.memberExpression(t.cloneDeep(newObject), newProperty, calleePath.node.computed), t.identifier("call"), false);
            } else {
              newCallee = self.explodeExpression(calleePath);
            }
          } else {
            newCallee = self.explodeViaTempVar(null, calleePath, hasLeapingChildren);
            if (t.isMemberExpression(newCallee)) {
              newCallee = t.sequenceExpression([t.numericLiteral(0), t.cloneDeep(newCallee)]);
            }
          }
          if (hasLeapingArgs) {
            newArgs = argsPath.map(function (argPath) {
              return self.explodeViaTempVar(null, argPath, hasLeapingChildren);
            });
            if (injectFirstArg) newArgs.unshift(injectFirstArg);
            newArgs = newArgs.map(function (arg) {
              return t.cloneDeep(arg);
            });
          } else {
            newArgs = path.node.arguments;
          }
          return finish(t.callExpression(newCallee, newArgs));
        case "NewExpression":
          return finish(t.newExpression(self.explodeViaTempVar(null, path.get("callee"), hasLeapingChildren), path.get("arguments").map(function (argPath) {
            return self.explodeViaTempVar(null, argPath, hasLeapingChildren);
          })));
        case "ObjectExpression":
          return finish(t.objectExpression(path.get("properties").map(function (propPath) {
            if (propPath.isObjectProperty()) {
              return t.objectProperty(propPath.node.key, self.explodeViaTempVar(null, propPath.get("value"), hasLeapingChildren), propPath.node.computed);
            } else {
              return propPath.node;
            }
          })));
        case "ArrayExpression":
          return finish(t.arrayExpression(path.get("elements").map(function (elemPath) {
            if (!elemPath.node) {
              return null;
            }
            if (elemPath.isSpreadElement()) {
              return t.spreadElement(self.explodeViaTempVar(null, elemPath.get("argument"), hasLeapingChildren));
            } else {
              return self.explodeViaTempVar(null, elemPath, hasLeapingChildren);
            }
          })));
        case "SequenceExpression":
          var lastIndex = expr.expressions.length - 1;
          path.get("expressions").forEach(function (exprPath) {
            if (exprPath.key === lastIndex) {
              result = self.explodeExpression(exprPath, ignoreResult);
            } else {
              self.explodeExpression(exprPath, true);
            }
          });
          return result;
        case "LogicalExpression":
          after = this.loc();
          if (!ignoreResult) {
            result = self.makeTempVar();
          }
          var left = self.explodeViaTempVar(result, path.get("left"), hasLeapingChildren);
          if (expr.operator === "&&") {
            self.jumpIfNot(left, after);
          } else {
            _assert["default"].strictEqual(expr.operator, "||");
            self.jumpIf(left, after);
          }
          self.explodeViaTempVar(result, path.get("right"), hasLeapingChildren, ignoreResult);
          self.mark(after);
          return result;
        case "ConditionalExpression":
          var elseLoc = this.loc();
          after = this.loc();
          var test = self.explodeExpression(path.get("test"));
          self.jumpIfNot(test, elseLoc);
          if (!ignoreResult) {
            result = self.makeTempVar();
          }
          self.explodeViaTempVar(result, path.get("consequent"), hasLeapingChildren, ignoreResult);
          self.jump(after);
          self.mark(elseLoc);
          self.explodeViaTempVar(result, path.get("alternate"), hasLeapingChildren, ignoreResult);
          self.mark(after);
          return result;
        case "UnaryExpression":
          return finish(t.unaryExpression(expr.operator, self.explodeExpression(path.get("argument")), !!expr.prefix));
        case "BinaryExpression":
          return finish(t.binaryExpression(expr.operator, self.explodeViaTempVar(null, path.get("left"), hasLeapingChildren), self.explodeViaTempVar(null, path.get("right"), hasLeapingChildren)));
        case "AssignmentExpression":
          if (expr.operator === "=") {
            return finish(t.assignmentExpression(expr.operator, self.explodeExpression(path.get("left")), self.explodeExpression(path.get("right"))));
          }
          var lhs = self.explodeExpression(path.get("left"));
          var temp = self.emitAssign(self.makeTempVar(), lhs);
          return finish(t.assignmentExpression("=", t.cloneDeep(lhs), t.assignmentExpression(expr.operator, t.cloneDeep(temp), self.explodeExpression(path.get("right")))));
        case "UpdateExpression":
          return finish(t.updateExpression(expr.operator, self.explodeExpression(path.get("argument")), expr.prefix));
        case "YieldExpression":
          after = this.loc();
          var arg = expr.argument && self.explodeExpression(path.get("argument"));
          if (arg && expr.delegate) {
            var _result = self.makeTempVar();
            var _ret = t.returnStatement(t.callExpression(self.contextProperty("delegateYield"), [arg, t.stringLiteral(_result.property.name), after]));
            _ret.loc = expr.loc;
            self.emit(_ret);
            self.mark(after);
            return _result;
          }
          self.emitAssign(self.contextProperty("next"), after);
          var ret = t.returnStatement(t.cloneDeep(arg) || null);
          ret.loc = expr.loc;
          self.emit(ret);
          self.mark(after);
          return self.contextProperty("sent");
        case "ClassExpression":
          return finish(self.explodeClass(path));
        default:
          throw new Error("unknown Expression of type " + JSON.stringify(expr.type));
      }
    };
    Ep.explodeClass = function (path) {
      var explodingChildren = [];
      if (path.node.superClass) {
        explodingChildren.push(path.get("superClass"));
      }
      path.get("body.body").forEach(function (member) {
        if (member.node.computed) {
          explodingChildren.push(member.get("key"));
        }
      });
      var hasLeapingChildren = explodingChildren.some(function (child) {
        return meta.containsLeap(child);
      });
      for (var i = 0; i < explodingChildren.length; i++) {
        var child = explodingChildren[i];
        var isLast = i === explodingChildren.length - 1;
        if (isLast) {
          child.replaceWith(this.explodeExpression(child));
        } else {
          child.replaceWith(this.explodeViaTempVar(null, child, hasLeapingChildren));
        }
      }
      return path.node;
    };
    return emit;
  }

var replaceShorthandObjectMethod = {};

var hasRequiredReplaceShorthandObjectMethod;
  function requireReplaceShorthandObjectMethod() {
    if (hasRequiredReplaceShorthandObjectMethod) return replaceShorthandObjectMethod;
    hasRequiredReplaceShorthandObjectMethod = 1;
    (function (exports) {

exports.__esModule = true;
      exports["default"] = replaceShorthandObjectMethod;
      var util = _interopRequireWildcard(requireUtil());
      function _getRequireWildcardCache(nodeInterop) {
        if (typeof WeakMap !== "function") return null;
        var cacheBabelInterop = new WeakMap();
        var cacheNodeInterop = new WeakMap();
        return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
          return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
        })(nodeInterop);
      }
      function _interopRequireWildcard(obj, nodeInterop) {
        if (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;
      }
      function replaceShorthandObjectMethod(path) {
        var t = util.getTypes();
        if (!path.node || !t.isFunction(path.node)) {
          throw new Error("replaceShorthandObjectMethod can only be called on Function AST node paths.");
        }
        if (!t.isObjectMethod(path.node)) {
          return path;
        }
        if (!path.node.generator) {
          return path;
        }
        var parameters = path.node.params.map(function (param) {
          return t.cloneDeep(param);
        });
        var functionExpression = t.functionExpression(null, parameters, t.cloneDeep(path.node.body), path.node.generator, path.node.async);
        util.replaceWithOrRemove(path, t.objectProperty(t.cloneDeep(path.node.key), functionExpression, path.node.computed, false));
        return path.get("value");
      }
    })(replaceShorthandObjectMethod);
    return replaceShorthandObjectMethod;
  }

(function (exports) {

exports.__esModule = true;
    exports["default"] = _default;
    var _visit = visit;
    function _default(context) {
      var plugin = {
        visitor: (0, _visit.getVisitor)(context)
      };
      var version = context && context.version;
      if (version && parseInt(version, 10) >= 7) {
        plugin.name = "regenerator-transform";
      }
      return plugin;
    }
  })(lib$7);

function bool$1(value) {
    if (value == null) return false;
    return value && value !== "false" && value !== "0";
  }
  var semver$5 = bool$1(browser$1$1.env["BABEL_8_BREAKING"]) ? requireSemver$2() : requireSemver$2();

function hasMinVersion(minVersion, runtimeVersion) {
    if (!runtimeVersion) return true;
    if (semver$5.valid(runtimeVersion)) runtimeVersion = "^" + runtimeVersion;
    return !semver$5.intersects("<" + minVersion, runtimeVersion) && !semver$5.intersects(">=8.0.0", runtimeVersion);
  }

function getRuntimePath (moduleName, dirname, absoluteRuntime) {
    if (absoluteRuntime === false) return moduleName;
    resolveFSPath();
  }
  function resolveFSPath() {
    throw new Error("The 'absoluteRuntime' option is not supported when using @babel/standalone.");
  }

var babel7 = {};

var lib$6 = {};

var require$$0$5 = {
  	"es6.array.copy-within": {
  	chrome: "45",
  	opera: "32",
  	edge: "12",
  	firefox: "32",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "5",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.31"
  },
  	"es6.array.every": {
  	chrome: "5",
  	opera: "10.10",
  	edge: "12",
  	firefox: "2",
  	safari: "3.1",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.array.fill": {
  	chrome: "45",
  	opera: "32",
  	edge: "12",
  	firefox: "31",
  	safari: "7.1",
  	node: "4",
  	deno: "1",
  	ios: "8",
  	samsung: "5",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.31"
  },
  	"es6.array.filter": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.array.find": {
  	chrome: "45",
  	opera: "32",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "4",
  	deno: "1",
  	ios: "8",
  	samsung: "5",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.31"
  },
  	"es6.array.find-index": {
  	chrome: "45",
  	opera: "32",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "4",
  	deno: "1",
  	ios: "8",
  	samsung: "5",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.31"
  },
  	"es7.array.flat-map": {
  	chrome: "69",
  	opera: "56",
  	edge: "79",
  	firefox: "62",
  	safari: "12",
  	node: "11",
  	deno: "1",
  	ios: "12",
  	samsung: "10",
  	rhino: "1.7.15",
  	opera_mobile: "48",
  	electron: "4.0"
  },
  	"es6.array.for-each": {
  	chrome: "5",
  	opera: "10.10",
  	edge: "12",
  	firefox: "2",
  	safari: "3.1",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.array.from": {
  	chrome: "51",
  	opera: "38",
  	edge: "15",
  	firefox: "36",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	rhino: "1.7.15",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es7.array.includes": {
  	chrome: "47",
  	opera: "34",
  	edge: "14",
  	firefox: "102",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "34",
  	electron: "0.36"
  },
  	"es6.array.index-of": {
  	chrome: "5",
  	opera: "10.10",
  	edge: "12",
  	firefox: "2",
  	safari: "3.1",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.array.is-array": {
  	chrome: "5",
  	opera: "10.50",
  	edge: "12",
  	firefox: "4",
  	safari: "4",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.array.iterator": {
  	chrome: "66",
  	opera: "53",
  	edge: "12",
  	firefox: "60",
  	safari: "9",
  	node: "10",
  	deno: "1",
  	ios: "9",
  	samsung: "9",
  	rhino: "1.7.13",
  	opera_mobile: "47",
  	electron: "3.0"
  },
  	"es6.array.last-index-of": {
  	chrome: "5",
  	opera: "10.10",
  	edge: "12",
  	firefox: "2",
  	safari: "3.1",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.array.map": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.array.of": {
  	chrome: "45",
  	opera: "32",
  	edge: "12",
  	firefox: "25",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "5",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.31"
  },
  	"es6.array.reduce": {
  	chrome: "5",
  	opera: "10.50",
  	edge: "12",
  	firefox: "3",
  	safari: "4",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.array.reduce-right": {
  	chrome: "5",
  	opera: "10.50",
  	edge: "12",
  	firefox: "3",
  	safari: "4",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.array.slice": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.array.some": {
  	chrome: "5",
  	opera: "10.10",
  	edge: "12",
  	firefox: "2",
  	safari: "3.1",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.array.sort": {
  	chrome: "63",
  	opera: "50",
  	edge: "12",
  	firefox: "5",
  	safari: "12",
  	node: "10",
  	deno: "1",
  	ie: "9",
  	ios: "12",
  	samsung: "8",
  	rhino: "1.7.13",
  	opera_mobile: "46",
  	electron: "3.0"
  },
  	"es6.array.species": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	rhino: "1.7.15",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.date.now": {
  	chrome: "5",
  	opera: "10.50",
  	edge: "12",
  	firefox: "2",
  	safari: "4",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.date.to-iso-string": {
  	chrome: "5",
  	opera: "10.50",
  	edge: "12",
  	firefox: "3.5",
  	safari: "4",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.date.to-json": {
  	chrome: "5",
  	opera: "12.10",
  	edge: "12",
  	firefox: "4",
  	safari: "10",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "10",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "12.1",
  	electron: "0.20"
  },
  	"es6.date.to-primitive": {
  	chrome: "47",
  	opera: "34",
  	edge: "15",
  	firefox: "44",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "34",
  	electron: "0.36"
  },
  	"es6.date.to-string": {
  	chrome: "5",
  	opera: "10.50",
  	edge: "12",
  	firefox: "2",
  	safari: "3.1",
  	node: "0.4",
  	deno: "1",
  	ie: "10",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.function.bind": {
  	chrome: "7",
  	opera: "12",
  	edge: "12",
  	firefox: "4",
  	safari: "5.1",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "12",
  	electron: "0.20"
  },
  	"es6.function.has-instance": {
  	chrome: "51",
  	opera: "38",
  	edge: "15",
  	firefox: "50",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.function.name": {
  	chrome: "5",
  	opera: "10.50",
  	edge: "14",
  	firefox: "2",
  	safari: "4",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es6.map": {
  	chrome: "51",
  	opera: "38",
  	edge: "15",
  	firefox: "53",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.math.acosh": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.asinh": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.atanh": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.cbrt": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.clz32": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "31",
  	safari: "9",
  	node: "0.12",
  	deno: "1",
  	ios: "9",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.cosh": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.expm1": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.fround": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "26",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.hypot": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "27",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.imul": {
  	chrome: "30",
  	opera: "17",
  	edge: "12",
  	firefox: "23",
  	safari: "7",
  	node: "0.12",
  	deno: "1",
  	android: "4.4",
  	ios: "7",
  	samsung: "2",
  	rhino: "1.7.13",
  	opera_mobile: "18",
  	electron: "0.20"
  },
  	"es6.math.log1p": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.log10": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.log2": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.sign": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "9",
  	node: "0.12",
  	deno: "1",
  	ios: "9",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.sinh": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.tanh": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.math.trunc": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "25",
  	safari: "7.1",
  	node: "0.12",
  	deno: "1",
  	ios: "8",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.number.constructor": {
  	chrome: "41",
  	opera: "28",
  	edge: "12",
  	firefox: "36",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "3.4",
  	rhino: "1.7.13",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"es6.number.epsilon": {
  	chrome: "34",
  	opera: "21",
  	edge: "12",
  	firefox: "25",
  	safari: "9",
  	node: "0.12",
  	deno: "1",
  	ios: "9",
  	samsung: "2",
  	rhino: "1.7.14",
  	opera_mobile: "21",
  	electron: "0.20"
  },
  	"es6.number.is-finite": {
  	chrome: "19",
  	opera: "15",
  	edge: "12",
  	firefox: "16",
  	safari: "9",
  	node: "0.8",
  	deno: "1",
  	android: "4.1",
  	ios: "9",
  	samsung: "1.5",
  	rhino: "1.7.13",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.number.is-integer": {
  	chrome: "34",
  	opera: "21",
  	edge: "12",
  	firefox: "16",
  	safari: "9",
  	node: "0.12",
  	deno: "1",
  	ios: "9",
  	samsung: "2",
  	rhino: "1.7.13",
  	opera_mobile: "21",
  	electron: "0.20"
  },
  	"es6.number.is-nan": {
  	chrome: "19",
  	opera: "15",
  	edge: "12",
  	firefox: "15",
  	safari: "9",
  	node: "0.8",
  	deno: "1",
  	android: "4.1",
  	ios: "9",
  	samsung: "1.5",
  	rhino: "1.7.13",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.number.is-safe-integer": {
  	chrome: "34",
  	opera: "21",
  	edge: "12",
  	firefox: "32",
  	safari: "9",
  	node: "0.12",
  	deno: "1",
  	ios: "9",
  	samsung: "2",
  	rhino: "1.7.13",
  	opera_mobile: "21",
  	electron: "0.20"
  },
  	"es6.number.max-safe-integer": {
  	chrome: "34",
  	opera: "21",
  	edge: "12",
  	firefox: "31",
  	safari: "9",
  	node: "0.12",
  	deno: "1",
  	ios: "9",
  	samsung: "2",
  	rhino: "1.7.13",
  	opera_mobile: "21",
  	electron: "0.20"
  },
  	"es6.number.min-safe-integer": {
  	chrome: "34",
  	opera: "21",
  	edge: "12",
  	firefox: "31",
  	safari: "9",
  	node: "0.12",
  	deno: "1",
  	ios: "9",
  	samsung: "2",
  	rhino: "1.7.13",
  	opera_mobile: "21",
  	electron: "0.20"
  },
  	"es6.number.parse-float": {
  	chrome: "34",
  	opera: "21",
  	edge: "12",
  	firefox: "25",
  	safari: "9",
  	node: "0.12",
  	deno: "1",
  	ios: "9",
  	samsung: "2",
  	rhino: "1.7.14",
  	opera_mobile: "21",
  	electron: "0.20"
  },
  	"es6.number.parse-int": {
  	chrome: "34",
  	opera: "21",
  	edge: "12",
  	firefox: "25",
  	safari: "9",
  	node: "0.12",
  	deno: "1",
  	ios: "9",
  	samsung: "2",
  	rhino: "1.7.14",
  	opera_mobile: "21",
  	electron: "0.20"
  },
  	"es6.object.assign": {
  	chrome: "49",
  	opera: "36",
  	edge: "13",
  	firefox: "36",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.object.create": {
  	chrome: "5",
  	opera: "12",
  	edge: "12",
  	firefox: "4",
  	safari: "4",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "12",
  	electron: "0.20"
  },
  	"es7.object.define-getter": {
  	chrome: "62",
  	opera: "49",
  	edge: "16",
  	firefox: "48",
  	safari: "9",
  	node: "8.10",
  	deno: "1",
  	ios: "9",
  	samsung: "8",
  	opera_mobile: "46",
  	electron: "3.0"
  },
  	"es7.object.define-setter": {
  	chrome: "62",
  	opera: "49",
  	edge: "16",
  	firefox: "48",
  	safari: "9",
  	node: "8.10",
  	deno: "1",
  	ios: "9",
  	samsung: "8",
  	opera_mobile: "46",
  	electron: "3.0"
  },
  	"es6.object.define-property": {
  	chrome: "5",
  	opera: "12",
  	edge: "12",
  	firefox: "4",
  	safari: "5.1",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "12",
  	electron: "0.20"
  },
  	"es6.object.define-properties": {
  	chrome: "5",
  	opera: "12",
  	edge: "12",
  	firefox: "4",
  	safari: "4",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "12",
  	electron: "0.20"
  },
  	"es7.object.entries": {
  	chrome: "54",
  	opera: "41",
  	edge: "14",
  	firefox: "47",
  	safari: "10.1",
  	node: "7",
  	deno: "1",
  	ios: "10.3",
  	samsung: "6",
  	rhino: "1.7.14",
  	opera_mobile: "41",
  	electron: "1.4"
  },
  	"es6.object.freeze": {
  	chrome: "44",
  	opera: "31",
  	edge: "12",
  	firefox: "35",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "4",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.30"
  },
  	"es6.object.get-own-property-descriptor": {
  	chrome: "44",
  	opera: "31",
  	edge: "12",
  	firefox: "35",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "4",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.30"
  },
  	"es7.object.get-own-property-descriptors": {
  	chrome: "54",
  	opera: "41",
  	edge: "15",
  	firefox: "50",
  	safari: "10.1",
  	node: "7",
  	deno: "1",
  	ios: "10.3",
  	samsung: "6",
  	opera_mobile: "41",
  	electron: "1.4"
  },
  	"es6.object.get-own-property-names": {
  	chrome: "40",
  	opera: "27",
  	edge: "12",
  	firefox: "33",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "3.4",
  	rhino: "1.7.13",
  	opera_mobile: "27",
  	electron: "0.21"
  },
  	"es6.object.get-prototype-of": {
  	chrome: "44",
  	opera: "31",
  	edge: "12",
  	firefox: "35",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "4",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.30"
  },
  	"es7.object.lookup-getter": {
  	chrome: "62",
  	opera: "49",
  	edge: "79",
  	firefox: "36",
  	safari: "9",
  	node: "8.10",
  	deno: "1",
  	ios: "9",
  	samsung: "8",
  	opera_mobile: "46",
  	electron: "3.0"
  },
  	"es7.object.lookup-setter": {
  	chrome: "62",
  	opera: "49",
  	edge: "79",
  	firefox: "36",
  	safari: "9",
  	node: "8.10",
  	deno: "1",
  	ios: "9",
  	samsung: "8",
  	opera_mobile: "46",
  	electron: "3.0"
  },
  	"es6.object.prevent-extensions": {
  	chrome: "44",
  	opera: "31",
  	edge: "12",
  	firefox: "35",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "4",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.30"
  },
  	"es6.object.to-string": {
  	chrome: "57",
  	opera: "44",
  	edge: "15",
  	firefox: "51",
  	safari: "10",
  	node: "8",
  	deno: "1",
  	ios: "10",
  	samsung: "7",
  	opera_mobile: "43",
  	electron: "1.7"
  },
  	"es6.object.is": {
  	chrome: "19",
  	opera: "15",
  	edge: "12",
  	firefox: "22",
  	safari: "9",
  	node: "0.8",
  	deno: "1",
  	android: "4.1",
  	ios: "9",
  	samsung: "1.5",
  	rhino: "1.7.13",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.object.is-frozen": {
  	chrome: "44",
  	opera: "31",
  	edge: "12",
  	firefox: "35",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "4",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.30"
  },
  	"es6.object.is-sealed": {
  	chrome: "44",
  	opera: "31",
  	edge: "12",
  	firefox: "35",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "4",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.30"
  },
  	"es6.object.is-extensible": {
  	chrome: "44",
  	opera: "31",
  	edge: "12",
  	firefox: "35",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "4",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.30"
  },
  	"es6.object.keys": {
  	chrome: "40",
  	opera: "27",
  	edge: "12",
  	firefox: "35",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "3.4",
  	rhino: "1.7.13",
  	opera_mobile: "27",
  	electron: "0.21"
  },
  	"es6.object.seal": {
  	chrome: "44",
  	opera: "31",
  	edge: "12",
  	firefox: "35",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "4",
  	rhino: "1.7.13",
  	opera_mobile: "32",
  	electron: "0.30"
  },
  	"es6.object.set-prototype-of": {
  	chrome: "34",
  	opera: "21",
  	edge: "12",
  	firefox: "31",
  	safari: "9",
  	node: "0.12",
  	deno: "1",
  	ie: "11",
  	ios: "9",
  	samsung: "2",
  	rhino: "1.7.13",
  	opera_mobile: "21",
  	electron: "0.20"
  },
  	"es7.object.values": {
  	chrome: "54",
  	opera: "41",
  	edge: "14",
  	firefox: "47",
  	safari: "10.1",
  	node: "7",
  	deno: "1",
  	ios: "10.3",
  	samsung: "6",
  	rhino: "1.7.14",
  	opera_mobile: "41",
  	electron: "1.4"
  },
  	"es6.promise": {
  	chrome: "51",
  	opera: "38",
  	edge: "14",
  	firefox: "45",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	rhino: "1.7.15",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es7.promise.finally": {
  	chrome: "63",
  	opera: "50",
  	edge: "18",
  	firefox: "58",
  	safari: "11.1",
  	node: "10",
  	deno: "1",
  	ios: "11.3",
  	samsung: "8",
  	rhino: "1.7.15",
  	opera_mobile: "46",
  	electron: "3.0"
  },
  	"es6.reflect.apply": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.construct": {
  	chrome: "49",
  	opera: "36",
  	edge: "13",
  	firefox: "49",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.define-property": {
  	chrome: "49",
  	opera: "36",
  	edge: "13",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.delete-property": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.get": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.get-own-property-descriptor": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.get-prototype-of": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.has": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.is-extensible": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.own-keys": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.prevent-extensions": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.set": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.reflect.set-prototype-of": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "42",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.regexp.constructor": {
  	chrome: "50",
  	opera: "37",
  	edge: "79",
  	firefox: "40",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "37",
  	electron: "1.1"
  },
  	"es6.regexp.flags": {
  	chrome: "49",
  	opera: "36",
  	edge: "79",
  	firefox: "37",
  	safari: "9",
  	node: "6",
  	deno: "1",
  	ios: "9",
  	samsung: "5",
  	rhino: "1.7.15",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"es6.regexp.match": {
  	chrome: "50",
  	opera: "37",
  	edge: "79",
  	firefox: "49",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	rhino: "1.7.13",
  	opera_mobile: "37",
  	electron: "1.1"
  },
  	"es6.regexp.replace": {
  	chrome: "50",
  	opera: "37",
  	edge: "79",
  	firefox: "49",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "37",
  	electron: "1.1"
  },
  	"es6.regexp.split": {
  	chrome: "50",
  	opera: "37",
  	edge: "79",
  	firefox: "49",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "37",
  	electron: "1.1"
  },
  	"es6.regexp.search": {
  	chrome: "50",
  	opera: "37",
  	edge: "79",
  	firefox: "49",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	rhino: "1.7.13",
  	opera_mobile: "37",
  	electron: "1.1"
  },
  	"es6.regexp.to-string": {
  	chrome: "50",
  	opera: "37",
  	edge: "79",
  	firefox: "39",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	rhino: "1.7.15",
  	opera_mobile: "37",
  	electron: "1.1"
  },
  	"es6.set": {
  	chrome: "51",
  	opera: "38",
  	edge: "15",
  	firefox: "53",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.symbol": {
  	chrome: "51",
  	opera: "38",
  	edge: "79",
  	firefox: "51",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es7.symbol.async-iterator": {
  	chrome: "63",
  	opera: "50",
  	edge: "79",
  	firefox: "57",
  	safari: "12",
  	node: "10",
  	deno: "1",
  	ios: "12",
  	samsung: "8",
  	opera_mobile: "46",
  	electron: "3.0"
  },
  	"es6.string.anchor": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.big": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.blink": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.bold": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.code-point-at": {
  	chrome: "41",
  	opera: "28",
  	edge: "12",
  	firefox: "29",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "3.4",
  	rhino: "1.7.13",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"es6.string.ends-with": {
  	chrome: "41",
  	opera: "28",
  	edge: "12",
  	firefox: "29",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "3.4",
  	rhino: "1.7.13",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"es6.string.fixed": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.fontcolor": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.fontsize": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.from-code-point": {
  	chrome: "41",
  	opera: "28",
  	edge: "12",
  	firefox: "29",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "3.4",
  	rhino: "1.7.13",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"es6.string.includes": {
  	chrome: "41",
  	opera: "28",
  	edge: "12",
  	firefox: "40",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "3.4",
  	rhino: "1.7.13",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"es6.string.italics": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.iterator": {
  	chrome: "38",
  	opera: "25",
  	edge: "12",
  	firefox: "36",
  	safari: "9",
  	node: "0.12",
  	deno: "1",
  	ios: "9",
  	samsung: "3",
  	rhino: "1.7.13",
  	opera_mobile: "25",
  	electron: "0.20"
  },
  	"es6.string.link": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es7.string.pad-start": {
  	chrome: "57",
  	opera: "44",
  	edge: "15",
  	firefox: "48",
  	safari: "10",
  	node: "8",
  	deno: "1",
  	ios: "10",
  	samsung: "7",
  	rhino: "1.7.13",
  	opera_mobile: "43",
  	electron: "1.7"
  },
  	"es7.string.pad-end": {
  	chrome: "57",
  	opera: "44",
  	edge: "15",
  	firefox: "48",
  	safari: "10",
  	node: "8",
  	deno: "1",
  	ios: "10",
  	samsung: "7",
  	rhino: "1.7.13",
  	opera_mobile: "43",
  	electron: "1.7"
  },
  	"es6.string.raw": {
  	chrome: "41",
  	opera: "28",
  	edge: "12",
  	firefox: "34",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "3.4",
  	rhino: "1.7.14",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"es6.string.repeat": {
  	chrome: "41",
  	opera: "28",
  	edge: "12",
  	firefox: "24",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "3.4",
  	rhino: "1.7.13",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"es6.string.small": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.starts-with": {
  	chrome: "41",
  	opera: "28",
  	edge: "12",
  	firefox: "29",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "3.4",
  	rhino: "1.7.13",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"es6.string.strike": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.sub": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.sup": {
  	chrome: "5",
  	opera: "15",
  	edge: "12",
  	firefox: "17",
  	safari: "6",
  	node: "0.4",
  	deno: "1",
  	android: "4",
  	ios: "7",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.14",
  	opera_mobile: "14",
  	electron: "0.20"
  },
  	"es6.string.trim": {
  	chrome: "5",
  	opera: "10.50",
  	edge: "12",
  	firefox: "3.5",
  	safari: "4",
  	node: "0.4",
  	deno: "1",
  	ie: "9",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "10.1",
  	electron: "0.20"
  },
  	"es7.string.trim-left": {
  	chrome: "66",
  	opera: "53",
  	edge: "79",
  	firefox: "61",
  	safari: "12",
  	node: "10",
  	deno: "1",
  	ios: "12",
  	samsung: "9",
  	rhino: "1.7.13",
  	opera_mobile: "47",
  	electron: "3.0"
  },
  	"es7.string.trim-right": {
  	chrome: "66",
  	opera: "53",
  	edge: "79",
  	firefox: "61",
  	safari: "12",
  	node: "10",
  	deno: "1",
  	ios: "12",
  	samsung: "9",
  	rhino: "1.7.13",
  	opera_mobile: "47",
  	electron: "3.0"
  },
  	"es6.typed.array-buffer": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.typed.data-view": {
  	chrome: "5",
  	opera: "12",
  	edge: "12",
  	firefox: "15",
  	safari: "5.1",
  	node: "0.4",
  	deno: "1",
  	ie: "10",
  	android: "4",
  	ios: "6",
  	phantom: "1.9",
  	samsung: "1",
  	rhino: "1.7.13",
  	opera_mobile: "12",
  	electron: "0.20"
  },
  	"es6.typed.int8-array": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.typed.uint8-array": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.typed.uint8-clamped-array": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.typed.int16-array": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.typed.uint16-array": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.typed.int32-array": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.typed.uint32-array": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.typed.float32-array": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.typed.float64-array": {
  	chrome: "51",
  	opera: "38",
  	edge: "13",
  	firefox: "48",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.weak-map": {
  	chrome: "51",
  	opera: "38",
  	edge: "15",
  	firefox: "53",
  	safari: "9",
  	node: "6.5",
  	deno: "1",
  	ios: "9",
  	samsung: "5",
  	rhino: "1.7.15",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"es6.weak-set": {
  	chrome: "51",
  	opera: "38",
  	edge: "15",
  	firefox: "53",
  	safari: "9",
  	node: "6.5",
  	deno: "1",
  	ios: "9",
  	samsung: "5",
  	rhino: "1.7.15",
  	opera_mobile: "41",
  	electron: "1.2"
  }
  };

var corejs2BuiltIns;
  var hasRequiredCorejs2BuiltIns;
  function requireCorejs2BuiltIns() {
    if (hasRequiredCorejs2BuiltIns) return corejs2BuiltIns;
    hasRequiredCorejs2BuiltIns = 1;
    corejs2BuiltIns = require$$0$5;
    return corejs2BuiltIns;
  }

var builtInDefinitions$2 = {};

var hasRequiredBuiltInDefinitions$2;
  function requireBuiltInDefinitions$2() {
    if (hasRequiredBuiltInDefinitions$2) return builtInDefinitions$2;
    hasRequiredBuiltInDefinitions$2 = 1;
    builtInDefinitions$2.__esModule = true;
    builtInDefinitions$2.StaticProperties = builtInDefinitions$2.InstanceProperties = builtInDefinitions$2.CommonIterators = builtInDefinitions$2.BuiltIns = void 0;
    var _corejs2BuiltIns = _interopRequireDefault(requireCorejs2BuiltIns());
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    var define = function define(name, pure, global, meta) {
      if (global === void 0) {
        global = [];
      }
      return {
        name: name,
        pure: pure,
        global: global,
        meta: meta
      };
    };
    var pureAndGlobal = function pureAndGlobal(pure, global, minRuntimeVersion) {
      if (minRuntimeVersion === void 0) {
        minRuntimeVersion = null;
      }
      return define(global[0], pure, global, {
        minRuntimeVersion: minRuntimeVersion
      });
    };
    var globalOnly = function globalOnly(global) {
      return define(global[0], null, global);
    };
    var pureOnly = function pureOnly(pure, name) {
      return define(name, pure, []);
    };
    var ArrayNatureIterators = ["es6.object.to-string", "es6.array.iterator", "web.dom.iterable"];
    var CommonIterators = ["es6.string.iterator"].concat(ArrayNatureIterators);
    builtInDefinitions$2.CommonIterators = CommonIterators;
    var PromiseDependencies = ["es6.object.to-string", "es6.promise"];
    var BuiltIns = {
      DataView: globalOnly(["es6.typed.data-view"]),
      Float32Array: globalOnly(["es6.typed.float32-array"]),
      Float64Array: globalOnly(["es6.typed.float64-array"]),
      Int8Array: globalOnly(["es6.typed.int8-array"]),
      Int16Array: globalOnly(["es6.typed.int16-array"]),
      Int32Array: globalOnly(["es6.typed.int32-array"]),
      Map: pureAndGlobal("map", ["es6.map"].concat(_toConsumableArray(CommonIterators))),
      Number: globalOnly(["es6.number.constructor"]),
      Promise: pureAndGlobal("promise", PromiseDependencies),
      RegExp: globalOnly(["es6.regexp.constructor"]),
      Set: pureAndGlobal("set", ["es6.set"].concat(_toConsumableArray(CommonIterators))),
      Symbol: pureAndGlobal("symbol/index", ["es6.symbol"]),
      Uint8Array: globalOnly(["es6.typed.uint8-array"]),
      Uint8ClampedArray: globalOnly(["es6.typed.uint8-clamped-array"]),
      Uint16Array: globalOnly(["es6.typed.uint16-array"]),
      Uint32Array: globalOnly(["es6.typed.uint32-array"]),
      WeakMap: pureAndGlobal("weak-map", ["es6.weak-map"].concat(_toConsumableArray(CommonIterators))),
      WeakSet: pureAndGlobal("weak-set", ["es6.weak-set"].concat(_toConsumableArray(CommonIterators))),
      setImmediate: pureOnly("set-immediate", "web.immediate"),
      clearImmediate: pureOnly("clear-immediate", "web.immediate"),
      parseFloat: pureOnly("parse-float", "es6.parse-float"),
      parseInt: pureOnly("parse-int", "es6.parse-int")
    };
    builtInDefinitions$2.BuiltIns = BuiltIns;
    var InstanceProperties = {
      __defineGetter__: globalOnly(["es7.object.define-getter"]),
      __defineSetter__: globalOnly(["es7.object.define-setter"]),
      __lookupGetter__: globalOnly(["es7.object.lookup-getter"]),
      __lookupSetter__: globalOnly(["es7.object.lookup-setter"]),
      anchor: globalOnly(["es6.string.anchor"]),
      big: globalOnly(["es6.string.big"]),
      bind: globalOnly(["es6.function.bind"]),
      blink: globalOnly(["es6.string.blink"]),
      bold: globalOnly(["es6.string.bold"]),
      codePointAt: globalOnly(["es6.string.code-point-at"]),
      copyWithin: globalOnly(["es6.array.copy-within"]),
      endsWith: globalOnly(["es6.string.ends-with"]),
      entries: globalOnly(ArrayNatureIterators),
      every: globalOnly(["es6.array.every"]),
      fill: globalOnly(["es6.array.fill"]),
      filter: globalOnly(["es6.array.filter"]),
      "finally": globalOnly(["es7.promise.finally"].concat(PromiseDependencies)),
      find: globalOnly(["es6.array.find"]),
      findIndex: globalOnly(["es6.array.find-index"]),
      fixed: globalOnly(["es6.string.fixed"]),
      flags: globalOnly(["es6.regexp.flags"]),
      flatMap: globalOnly(["es7.array.flat-map"]),
      fontcolor: globalOnly(["es6.string.fontcolor"]),
      fontsize: globalOnly(["es6.string.fontsize"]),
      forEach: globalOnly(["es6.array.for-each"]),
      includes: globalOnly(["es6.string.includes", "es7.array.includes"]),
      indexOf: globalOnly(["es6.array.index-of"]),
      italics: globalOnly(["es6.string.italics"]),
      keys: globalOnly(ArrayNatureIterators),
      lastIndexOf: globalOnly(["es6.array.last-index-of"]),
      link: globalOnly(["es6.string.link"]),
      map: globalOnly(["es6.array.map"]),
      match: globalOnly(["es6.regexp.match"]),
      name: globalOnly(["es6.function.name"]),
      padStart: globalOnly(["es7.string.pad-start"]),
      padEnd: globalOnly(["es7.string.pad-end"]),
      reduce: globalOnly(["es6.array.reduce"]),
      reduceRight: globalOnly(["es6.array.reduce-right"]),
      repeat: globalOnly(["es6.string.repeat"]),
      replace: globalOnly(["es6.regexp.replace"]),
      search: globalOnly(["es6.regexp.search"]),
      small: globalOnly(["es6.string.small"]),
      some: globalOnly(["es6.array.some"]),
      sort: globalOnly(["es6.array.sort"]),
      split: globalOnly(["es6.regexp.split"]),
      startsWith: globalOnly(["es6.string.starts-with"]),
      strike: globalOnly(["es6.string.strike"]),
      sub: globalOnly(["es6.string.sub"]),
      sup: globalOnly(["es6.string.sup"]),
      toISOString: globalOnly(["es6.date.to-iso-string"]),
      toJSON: globalOnly(["es6.date.to-json"]),
      toString: globalOnly(["es6.object.to-string", "es6.date.to-string", "es6.regexp.to-string"]),
      trim: globalOnly(["es6.string.trim"]),
      trimEnd: globalOnly(["es7.string.trim-right"]),
      trimLeft: globalOnly(["es7.string.trim-left"]),
      trimRight: globalOnly(["es7.string.trim-right"]),
      trimStart: globalOnly(["es7.string.trim-left"]),
      values: globalOnly(ArrayNatureIterators)
    };
    builtInDefinitions$2.InstanceProperties = InstanceProperties;
    if ("es6.array.slice" in _corejs2BuiltIns["default"]) {
      InstanceProperties.slice = globalOnly(["es6.array.slice"]);
    }
    var StaticProperties = {
      Array: {
        from: pureAndGlobal("array/from", ["es6.symbol", "es6.array.from"].concat(_toConsumableArray(CommonIterators))),
        isArray: pureAndGlobal("array/is-array", ["es6.array.is-array"]),
        of: pureAndGlobal("array/of", ["es6.array.of"])
      },
      Date: {
        now: pureAndGlobal("date/now", ["es6.date.now"])
      },
      JSON: {
        stringify: pureOnly("json/stringify", "es6.symbol")
      },
      Math: {
        acosh: pureAndGlobal("math/acosh", ["es6.math.acosh"], "7.0.1"),
        asinh: pureAndGlobal("math/asinh", ["es6.math.asinh"], "7.0.1"),
        atanh: pureAndGlobal("math/atanh", ["es6.math.atanh"], "7.0.1"),
        cbrt: pureAndGlobal("math/cbrt", ["es6.math.cbrt"], "7.0.1"),
        clz32: pureAndGlobal("math/clz32", ["es6.math.clz32"], "7.0.1"),
        cosh: pureAndGlobal("math/cosh", ["es6.math.cosh"], "7.0.1"),
        expm1: pureAndGlobal("math/expm1", ["es6.math.expm1"], "7.0.1"),
        fround: pureAndGlobal("math/fround", ["es6.math.fround"], "7.0.1"),
        hypot: pureAndGlobal("math/hypot", ["es6.math.hypot"], "7.0.1"),
        imul: pureAndGlobal("math/imul", ["es6.math.imul"], "7.0.1"),
        log1p: pureAndGlobal("math/log1p", ["es6.math.log1p"], "7.0.1"),
        log10: pureAndGlobal("math/log10", ["es6.math.log10"], "7.0.1"),
        log2: pureAndGlobal("math/log2", ["es6.math.log2"], "7.0.1"),
        sign: pureAndGlobal("math/sign", ["es6.math.sign"], "7.0.1"),
        sinh: pureAndGlobal("math/sinh", ["es6.math.sinh"], "7.0.1"),
        tanh: pureAndGlobal("math/tanh", ["es6.math.tanh"], "7.0.1"),
        trunc: pureAndGlobal("math/trunc", ["es6.math.trunc"], "7.0.1")
      },
      Number: {
        EPSILON: pureAndGlobal("number/epsilon", ["es6.number.epsilon"]),
        MIN_SAFE_INTEGER: pureAndGlobal("number/min-safe-integer", ["es6.number.min-safe-integer"]),
        MAX_SAFE_INTEGER: pureAndGlobal("number/max-safe-integer", ["es6.number.max-safe-integer"]),
        isFinite: pureAndGlobal("number/is-finite", ["es6.number.is-finite"]),
        isInteger: pureAndGlobal("number/is-integer", ["es6.number.is-integer"]),
        isSafeInteger: pureAndGlobal("number/is-safe-integer", ["es6.number.is-safe-integer"]),
        isNaN: pureAndGlobal("number/is-nan", ["es6.number.is-nan"]),
        parseFloat: pureAndGlobal("number/parse-float", ["es6.number.parse-float"]),
        parseInt: pureAndGlobal("number/parse-int", ["es6.number.parse-int"])
      },
      Object: {
        assign: pureAndGlobal("object/assign", ["es6.object.assign"]),
        create: pureAndGlobal("object/create", ["es6.object.create"]),
        defineProperties: pureAndGlobal("object/define-properties", ["es6.object.define-properties"]),
        defineProperty: pureAndGlobal("object/define-property", ["es6.object.define-property"]),
        entries: pureAndGlobal("object/entries", ["es7.object.entries"]),
        freeze: pureAndGlobal("object/freeze", ["es6.object.freeze"]),
        getOwnPropertyDescriptor: pureAndGlobal("object/get-own-property-descriptor", ["es6.object.get-own-property-descriptor"]),
        getOwnPropertyDescriptors: pureAndGlobal("object/get-own-property-descriptors", ["es7.object.get-own-property-descriptors"]),
        getOwnPropertyNames: pureAndGlobal("object/get-own-property-names", ["es6.object.get-own-property-names"]),
        getOwnPropertySymbols: pureAndGlobal("object/get-own-property-symbols", ["es6.symbol"]),
        getPrototypeOf: pureAndGlobal("object/get-prototype-of", ["es6.object.get-prototype-of"]),
        is: pureAndGlobal("object/is", ["es6.object.is"]),
        isExtensible: pureAndGlobal("object/is-extensible", ["es6.object.is-extensible"]),
        isFrozen: pureAndGlobal("object/is-frozen", ["es6.object.is-frozen"]),
        isSealed: pureAndGlobal("object/is-sealed", ["es6.object.is-sealed"]),
        keys: pureAndGlobal("object/keys", ["es6.object.keys"]),
        preventExtensions: pureAndGlobal("object/prevent-extensions", ["es6.object.prevent-extensions"]),
        seal: pureAndGlobal("object/seal", ["es6.object.seal"]),
        setPrototypeOf: pureAndGlobal("object/set-prototype-of", ["es6.object.set-prototype-of"]),
        values: pureAndGlobal("object/values", ["es7.object.values"])
      },
      Promise: {
        all: globalOnly(CommonIterators),
        race: globalOnly(CommonIterators)
      },
      Reflect: {
        apply: pureAndGlobal("reflect/apply", ["es6.reflect.apply"]),
        construct: pureAndGlobal("reflect/construct", ["es6.reflect.construct"]),
        defineProperty: pureAndGlobal("reflect/define-property", ["es6.reflect.define-property"]),
        deleteProperty: pureAndGlobal("reflect/delete-property", ["es6.reflect.delete-property"]),
        get: pureAndGlobal("reflect/get", ["es6.reflect.get"]),
        getOwnPropertyDescriptor: pureAndGlobal("reflect/get-own-property-descriptor", ["es6.reflect.get-own-property-descriptor"]),
        getPrototypeOf: pureAndGlobal("reflect/get-prototype-of", ["es6.reflect.get-prototype-of"]),
        has: pureAndGlobal("reflect/has", ["es6.reflect.has"]),
        isExtensible: pureAndGlobal("reflect/is-extensible", ["es6.reflect.is-extensible"]),
        ownKeys: pureAndGlobal("reflect/own-keys", ["es6.reflect.own-keys"]),
        preventExtensions: pureAndGlobal("reflect/prevent-extensions", ["es6.reflect.prevent-extensions"]),
        set: pureAndGlobal("reflect/set", ["es6.reflect.set"]),
        setPrototypeOf: pureAndGlobal("reflect/set-prototype-of", ["es6.reflect.set-prototype-of"])
      },
      String: {
        at: pureOnly("string/at", "es7.string.at"),
        fromCodePoint: pureAndGlobal("string/from-code-point", ["es6.string.from-code-point"]),
        raw: pureAndGlobal("string/raw", ["es6.string.raw"])
      },
      Symbol: {
        asyncIterator: globalOnly(["es6.symbol", "es7.symbol.async-iterator"]),
        "for": pureOnly("symbol/for", "es6.symbol"),
        hasInstance: pureOnly("symbol/has-instance", "es6.symbol"),
        isConcatSpreadable: pureOnly("symbol/is-concat-spreadable", "es6.symbol"),
        iterator: define("es6.symbol", "symbol/iterator", CommonIterators),
        keyFor: pureOnly("symbol/key-for", "es6.symbol"),
        match: pureAndGlobal("symbol/match", ["es6.regexp.match"]),
        replace: pureOnly("symbol/replace", "es6.symbol"),
        search: pureOnly("symbol/search", "es6.symbol"),
        species: pureOnly("symbol/species", "es6.symbol"),
        split: pureOnly("symbol/split", "es6.symbol"),
        toPrimitive: pureOnly("symbol/to-primitive", "es6.symbol"),
        toStringTag: pureOnly("symbol/to-string-tag", "es6.symbol"),
        unscopables: pureOnly("symbol/unscopables", "es6.symbol")
      }
    };
    builtInDefinitions$2.StaticProperties = StaticProperties;
    return builtInDefinitions$2;
  }

var addPlatformSpecificPolyfills$1 = {};

var hasRequiredAddPlatformSpecificPolyfills$1;
  function requireAddPlatformSpecificPolyfills$1() {
    if (hasRequiredAddPlatformSpecificPolyfills$1) return addPlatformSpecificPolyfills$1;
    hasRequiredAddPlatformSpecificPolyfills$1 = 1;
    addPlatformSpecificPolyfills$1.__esModule = true;
    addPlatformSpecificPolyfills$1["default"] = _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);
    }
    var webPolyfills = {
      "web.timers": {},
      "web.immediate": {},
      "web.dom.iterable": {}
    };
    var purePolyfills = {
      "es6.parse-float": {},
      "es6.parse-int": {},
      "es7.string.at": {}
    };
    function _default(targets, method, polyfills) {
      var targetNames = Object.keys(targets);
      var isAnyTarget = !targetNames.length;
      var isWebTarget = targetNames.some(function (name) {
        return name !== "node";
      });
      return _extends({}, polyfills, method === "usage-pure" ? purePolyfills : null, isAnyTarget || isWebTarget ? webPolyfills : null);
    }
    return addPlatformSpecificPolyfills$1;
  }

var helpers$2 = {};

var semver$4 = {exports: {}};

var hasRequiredSemver$1;
  function requireSemver$1() {
    if (hasRequiredSemver$1) return semver$4.exports;
    hasRequiredSemver$1 = 1;
    (function (module, exports) {
      exports = module.exports = SemVer;
      var debug;
      if (typeof browser$1$1 === 'object' && browser$1$1.env && browser$1$1.env.NODE_DEBUG && /\bsemver\b/i.test(browser$1$1.env.NODE_DEBUG)) {
        debug = function debug() {
          var args = Array.prototype.slice.call(arguments, 0);
          args.unshift('SEMVER');
          console.log.apply(console, args);
        };
      } else {
        debug = function debug() {};
      }
      exports.SEMVER_SPEC_VERSION = '2.0.0';
      var MAX_LENGTH = 256;
      var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
      var MAX_SAFE_COMPONENT_LENGTH = 16;
      var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
      var re = exports.re = [];
      var safeRe = exports.safeRe = [];
      var src = exports.src = [];
      var t = exports.tokens = {};
      var R = 0;
      function tok(n) {
        t[n] = R++;
      }
      var LETTERDASHNUMBER = '[a-zA-Z0-9-]';
      var safeRegexReplacements = [['\\s', 1], ['\\d', MAX_LENGTH], [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]];
      function makeSafeRe(value) {
        for (var i = 0; i < safeRegexReplacements.length; i++) {
          var token = safeRegexReplacements[i][0];
          var max = safeRegexReplacements[i][1];
          value = value.split(token + '*').join(token + '{0,' + max + '}').split(token + '+').join(token + '{1,' + max + '}');
        }
        return value;
      }
      tok('NUMERICIDENTIFIER');
      src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*';
      tok('NUMERICIDENTIFIERLOOSE');
      src[t.NUMERICIDENTIFIERLOOSE] = '\\d+';
      tok('NONNUMERICIDENTIFIER');
      src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-]' + LETTERDASHNUMBER + '*';
      tok('MAINVERSION');
      src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')';
      tok('MAINVERSIONLOOSE');
      src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')';
      tok('PRERELEASEIDENTIFIER');
      src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + '|' + src[t.NONNUMERICIDENTIFIER] + ')';
      tok('PRERELEASEIDENTIFIERLOOSE');
      src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + '|' + src[t.NONNUMERICIDENTIFIER] + ')';
      tok('PRERELEASE');
      src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))';
      tok('PRERELEASELOOSE');
      src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))';
      tok('BUILDIDENTIFIER');
      src[t.BUILDIDENTIFIER] = LETTERDASHNUMBER + '+';
      tok('BUILD');
      src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] + '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))';
      tok('FULL');
      tok('FULLPLAIN');
      src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + src[t.PRERELEASE] + '?' + src[t.BUILD] + '?';
      src[t.FULL] = '^' + src[t.FULLPLAIN] + '$';
      tok('LOOSEPLAIN');
      src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + src[t.PRERELEASELOOSE] + '?' + src[t.BUILD] + '?';
      tok('LOOSE');
      src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$';
      tok('GTLT');
      src[t.GTLT] = '((?:<|>)?=?)';
      tok('XRANGEIDENTIFIERLOOSE');
      src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*';
      tok('XRANGEIDENTIFIER');
      src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*';
      tok('XRANGEPLAIN');
      src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:' + src[t.PRERELEASE] + ')?' + src[t.BUILD] + '?' + ')?)?';
      tok('XRANGEPLAINLOOSE');
      src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:' + src[t.PRERELEASELOOSE] + ')?' + src[t.BUILD] + '?' + ')?)?';
      tok('XRANGE');
      src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$';
      tok('XRANGELOOSE');
      src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$';
      tok('COERCE');
      src[t.COERCE] = '(^|[^\\d])' + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:$|[^\\d])';
      tok('COERCERTL');
      re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g');
      safeRe[t.COERCERTL] = new RegExp(makeSafeRe(src[t.COERCE]), 'g');
      tok('LONETILDE');
      src[t.LONETILDE] = '(?:~>?)';
      tok('TILDETRIM');
      src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+';
      re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g');
      safeRe[t.TILDETRIM] = new RegExp(makeSafeRe(src[t.TILDETRIM]), 'g');
      var tildeTrimReplace = '$1~';
      tok('TILDE');
      src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$';
      tok('TILDELOOSE');
      src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$';
      tok('LONECARET');
      src[t.LONECARET] = '(?:\\^)';
      tok('CARETTRIM');
      src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+';
      re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g');
      safeRe[t.CARETTRIM] = new RegExp(makeSafeRe(src[t.CARETTRIM]), 'g');
      var caretTrimReplace = '$1^';
      tok('CARET');
      src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$';
      tok('CARETLOOSE');
      src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$';
      tok('COMPARATORLOOSE');
      src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$';
      tok('COMPARATOR');
      src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$';
      tok('COMPARATORTRIM');
      src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')';
      re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g');
      safeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(src[t.COMPARATORTRIM]), 'g');
      var comparatorTrimReplace = '$1$2$3';
      tok('HYPHENRANGE');
      src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAIN] + ')' + '\\s*$';
      tok('HYPHENRANGELOOSE');
      src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s*$';
      tok('STAR');
      src[t.STAR] = '(<|>)?=?\\s*\\*';
      for (var i = 0; i < R; i++) {
        debug(i, src[i]);
        if (!re[i]) {
          re[i] = new RegExp(src[i]);
          safeRe[i] = new RegExp(makeSafeRe(src[i]));
        }
      }
      exports.parse = parse;
      function parse(version, options) {
        if (!options || typeof options !== 'object') {
          options = {
            loose: !!options,
            includePrerelease: false
          };
        }
        if (version instanceof SemVer) {
          return version;
        }
        if (typeof version !== 'string') {
          return null;
        }
        if (version.length > MAX_LENGTH) {
          return null;
        }
        var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL];
        if (!r.test(version)) {
          return null;
        }
        try {
          return new SemVer(version, options);
        } catch (er) {
          return null;
        }
      }
      exports.valid = valid;
      function valid(version, options) {
        var v = parse(version, options);
        return v ? v.version : null;
      }
      exports.clean = clean;
      function clean(version, options) {
        var s = parse(version.trim().replace(/^[=v]+/, ''), options);
        return s ? s.version : null;
      }
      exports.SemVer = SemVer;
      function SemVer(version, options) {
        if (!options || typeof options !== 'object') {
          options = {
            loose: !!options,
            includePrerelease: false
          };
        }
        if (version instanceof SemVer) {
          if (version.loose === options.loose) {
            return version;
          } else {
            version = version.version;
          }
        } else if (typeof version !== 'string') {
          throw new TypeError('Invalid Version: ' + version);
        }
        if (version.length > MAX_LENGTH) {
          throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters');
        }
        if (!(this instanceof SemVer)) {
          return new SemVer(version, options);
        }
        debug('SemVer', version, options);
        this.options = options;
        this.loose = !!options.loose;
        var m = version.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]);
        if (!m) {
          throw new TypeError('Invalid Version: ' + version);
        }
        this.raw = version;
        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 i = 0;
        do {
          var a = this.prerelease[i];
          var b = other.prerelease[i];
          debug('prerelease compare', i, a, b);
          if (a === undefined && b === undefined) {
            return 0;
          } else if (b === undefined) {
            return 1;
          } else if (a === undefined) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      };
      SemVer.prototype.compareBuild = function (other) {
        if (!(other instanceof SemVer)) {
          other = new SemVer(other, this.options);
        }
        var i = 0;
        do {
          var a = this.build[i];
          var b = other.build[i];
          debug('prerelease compare', i, a, b);
          if (a === undefined && b === undefined) {
            return 0;
          } else if (b === undefined) {
            return 1;
          } else if (a === undefined) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      };
      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 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 (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(version, release, loose, identifier) {
        if (typeof loose === 'string') {
          identifier = loose;
          loose = undefined;
        }
        try {
          return new SemVer(version, loose).inc(release, identifier).version;
        } catch (er) {
          return null;
        }
      }
      exports.diff = diff;
      function diff(version1, version2) {
        if (eq(version1, version2)) {
          return null;
        } else {
          var v1 = parse(version1);
          var v2 = parse(version2);
          var prefix = '';
          if (v1.prerelease.length || v2.prerelease.length) {
            prefix = 'pre';
            var defaultResult = 'prerelease';
          }
          for (var key in v1) {
            if (key === 'major' || key === 'minor' || key === 'patch') {
              if (v1[key] !== v2[key]) {
                return prefix + key;
              }
            }
          }
          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 = patch;
      function patch(a, loose) {
        return new SemVer(a, loose).patch;
      }
      exports.compare = compare;
      function compare(a, b, loose) {
        return new SemVer(a, loose).compare(new SemVer(b, loose));
      }
      exports.compareLoose = compareLoose;
      function compareLoose(a, b) {
        return compare(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 compare(b, a, loose);
      }
      exports.sort = sort;
      function sort(list, loose) {
        return list.sort(function (a, b) {
          return exports.compareBuild(a, b, loose);
        });
      }
      exports.rsort = rsort;
      function rsort(list, loose) {
        return list.sort(function (a, b) {
          return exports.compareBuild(b, a, loose);
        });
      }
      exports.gt = gt;
      function gt(a, b, loose) {
        return compare(a, b, loose) > 0;
      }
      exports.lt = lt;
      function lt(a, b, loose) {
        return compare(a, b, loose) < 0;
      }
      exports.eq = eq;
      function eq(a, b, loose) {
        return compare(a, b, loose) === 0;
      }
      exports.neq = neq;
      function neq(a, b, loose) {
        return compare(a, b, loose) !== 0;
      }
      exports.gte = gte;
      function gte(a, b, loose) {
        return compare(a, b, loose) >= 0;
      }
      exports.lte = lte;
      function lte(a, b, loose) {
        return compare(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);
        }
        comp = comp.trim().split(/\s+/).join(' ');
        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 ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];
        var m = comp.match(r);
        if (!m) {
          throw new TypeError('Invalid comparator: ' + comp);
        }
        this.operator = m[1] !== undefined ? 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 (version) {
        debug('Comparator.test', version, this.options.loose);
        if (this.semver === ANY || version === ANY) {
          return true;
        }
        if (typeof version === 'string') {
          try {
            version = new SemVer(version, this.options);
          } catch (er) {
            return false;
          }
        }
        return cmp(version, 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.trim().split(/\s+/).join(' ');
        this.set = this.raw.split('||').map(function (range) {
          return this.parseRange(range.trim());
        }, this).filter(function (c) {
          return c.length;
        });
        if (!this.set.length) {
          throw new TypeError('Invalid SemVer Range: ' + this.raw);
        }
        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;
        var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE];
        range = range.replace(hr, hyphenReplace);
        debug('hyphen replace', range);
        range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace);
        debug('comparator trim', range, safeRe[t.COMPARATORTRIM]);
        range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace);
        range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace);
        range = range.split(/\s+/).join(' ');
        var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.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 (c) {
            return c.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 (comp) {
          return replaceTilde(comp, options);
        }).join(' ');
      }
      function replaceTilde(comp, options) {
        var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.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 (comp) {
          return replaceCaret(comp, options);
        }).join(' ');
      }
      function replaceCaret(comp, options) {
        debug('caret', comp, options);
        var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.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 (comp) {
          return replaceXRange(comp, options);
        }).join(' ');
      }
      function replaceXRange(comp, options) {
        comp = comp.trim();
        var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.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(safeRe[t.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 (version) {
        if (!version) {
          return false;
        }
        if (typeof version === 'string') {
          try {
            version = new SemVer(version, this.options);
          } catch (er) {
            return false;
          }
        }
        for (var i = 0; i < this.set.length; i++) {
          if (testSet(this.set[i], version, this.options)) {
            return true;
          }
        }
        return false;
      };
      function testSet(set, version, options) {
        for (var i = 0; i < set.length; i++) {
          if (!set[i].test(version)) {
            return false;
          }
        }
        if (version.prerelease.length && !options.includePrerelease) {
          for (i = 0; i < set.length; i++) {
            debug(set[i].semver);
            if (set[i].semver === ANY) {
              continue;
            }
            if (set[i].semver.prerelease.length > 0) {
              var allowed = set[i].semver;
              if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
                return true;
              }
            }
          }
          return false;
        }
        return true;
      }
      exports.satisfies = satisfies;
      function satisfies(version, range, options) {
        try {
          range = new Range(range, options);
        } catch (er) {
          return false;
        }
        return range.test(version);
      }
      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 i = 0; i < range.set.length; ++i) {
          var comparators = range.set[i];
          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(version, range, options) {
        return outside(version, range, '<', options);
      }
      exports.gtr = gtr;
      function gtr(version, range, options) {
        return outside(version, range, '>', options);
      }
      exports.outside = outside;
      function outside(version, range, hilo, options) {
        version = new SemVer(version, 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(version, range, options)) {
          return false;
        }
        for (var i = 0; i < range.set.length; ++i) {
          var comparators = range.set[i];
          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(version, low.semver)) {
            return false;
          } else if (low.operator === ecomp && ltfn(version, low.semver)) {
            return false;
          }
        }
        return true;
      }
      exports.prerelease = prerelease;
      function prerelease(version, options) {
        var parsed = parse(version, 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(version, options) {
        if (version instanceof SemVer) {
          return version;
        }
        if (typeof version === 'number') {
          version = String(version);
        }
        if (typeof version !== 'string') {
          return null;
        }
        options = options || {};
        var match = null;
        if (!options.rtl) {
          match = version.match(safeRe[t.COERCE]);
        } else {
          var next;
          while ((next = safeRe[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
            if (!match || next.index + next[0].length !== match.index + match[0].length) {
              match = next;
            }
            safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
          }
          safeRe[t.COERCERTL].lastIndex = -1;
        }
        if (match === null) {
          return null;
        }
        return parse(match[2] + '.' + (match[3] || '0') + '.' + (match[4] || '0'), options);
      }
    })(semver$4, semver$4.exports);
    return semver$4.exports;
  }

var hasRequiredHelpers$1;
  function requireHelpers$1() {
    if (hasRequiredHelpers$1) return helpers$2;
    hasRequiredHelpers$1 = 1;
    helpers$2.__esModule = true;
    helpers$2.hasMinVersion = hasMinVersion;
    var _semver = _interopRequireDefault(requireSemver$1());
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    function hasMinVersion(minVersion, runtimeVersion) {
      if (!runtimeVersion || !minVersion) return true;
      runtimeVersion = String(runtimeVersion);
      if (_semver["default"].valid(runtimeVersion)) runtimeVersion = "^" + runtimeVersion;
      return !_semver["default"].intersects("<" + minVersion, runtimeVersion) && !_semver["default"].intersects(">=8.0.0", runtimeVersion);
    }
    return helpers$2;
  }

var lib$5 = {};

var require$$1$2 = /*@__PURE__*/getAugmentedNamespace(src$2);

var utils$3 = {};

var require$$5 = /*@__PURE__*/getAugmentedNamespace(_babel);

var _templateObject$a, _templateObject2$7, _templateObject3$4;
  var hasRequiredUtils$3;
  function requireUtils$3() {
    if (hasRequiredUtils$3) return utils$3;
    hasRequiredUtils$3 = 1;
    utils$3.__esModule = true;
    utils$3.createUtilsGetter = createUtilsGetter;
    utils$3.getImportSource = getImportSource;
    utils$3.getRequireSource = getRequireSource;
    utils$3.has = has;
    utils$3.intersection = intersection;
    utils$3.resolveKey = resolveKey;
    utils$3.resolveSource = resolveSource;
    var _babel = _interopRequireWildcard(require$$5);
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    var _ref = _babel["default"] || _babel,
      t = _ref.types,
      template = _ref.template;
    function intersection(a, b) {
      var result = new Set();
      a.forEach(function (v) {
        return b.has(v) && result.add(v);
      });
      return result;
    }
    function has(object, key) {
      return Object.prototype.hasOwnProperty.call(object, key);
    }
    function getType(target) {
      return Object.prototype.toString.call(target).slice(8, -1);
    }
    function resolveId(path) {
      if (path.isIdentifier() && !path.scope.hasBinding(path.node.name, true)) {
        return path.node.name;
      }
      if (path.isPure()) {
        var _path$evaluate = path.evaluate(),
          deopt = _path$evaluate.deopt;
        if (deopt && deopt.isIdentifier()) {
          return deopt.node.name;
        }
      }
    }
    function resolveKey(path, computed) {
      if (computed === void 0) {
        computed = false;
      }
      var scope = path.scope;
      if (path.isStringLiteral()) return path.node.value;
      var isIdentifier = path.isIdentifier();
      if (isIdentifier && !(computed || path.parent.computed)) {
        return path.node.name;
      }
      if (computed && path.isMemberExpression() && path.get("object").isIdentifier({
        name: "Symbol"
      }) && !scope.hasBinding("Symbol", true)) {
        var sym = resolveKey(path.get("property"), path.node.computed);
        if (sym) return "Symbol." + sym;
      }
      if (isIdentifier ? scope.hasBinding(path.node.name, true) : path.isPure()) {
        var _path$evaluate2 = path.evaluate(),
          value = _path$evaluate2.value;
        if (typeof value === "string") return value;
      }
    }
    function resolveSource(obj) {
      if (obj.isMemberExpression() && obj.get("property").isIdentifier({
        name: "prototype"
      })) {
        var _id = resolveId(obj.get("object"));
        if (_id) {
          return {
            id: _id,
            placement: "prototype"
          };
        }
        return {
          id: null,
          placement: null
        };
      }
      var id = resolveId(obj);
      if (id) {
        return {
          id: id,
          placement: "static"
        };
      }
      if (obj.isRegExpLiteral()) {
        return {
          id: "RegExp",
          placement: "prototype"
        };
      } else if (obj.isFunction()) {
        return {
          id: "Function",
          placement: "prototype"
        };
      } else if (obj.isPure()) {
        var _obj$evaluate = obj.evaluate(),
          value = _obj$evaluate.value;
        if (value !== undefined) {
          return {
            id: getType(value),
            placement: "prototype"
          };
        }
      }
      return {
        id: null,
        placement: null
      };
    }
    function getImportSource(_ref2) {
      var node = _ref2.node;
      if (node.specifiers.length === 0) return node.source.value;
    }
    function getRequireSource(_ref3) {
      var node = _ref3.node;
      if (!t.isExpressionStatement(node)) return;
      var expression = node.expression;
      if (t.isCallExpression(expression) && t.isIdentifier(expression.callee) && expression.callee.name === "require" && expression.arguments.length === 1 && t.isStringLiteral(expression.arguments[0])) {
        return expression.arguments[0].value;
      }
    }
    function hoist(node) {
      node._blockHoist = 3;
      return node;
    }
    function createUtilsGetter(cache) {
      return function (path) {
        var prog = path.findParent(function (p) {
          return p.isProgram();
        });
        return {
          injectGlobalImport: function injectGlobalImport(url, moduleName) {
            cache.storeAnonymous(prog, url, moduleName, function (isScript, source) {
              return isScript ? template.statement.ast(_templateObject$a || (_templateObject$a = _taggedTemplateLiteralLoose(["require(", ")"])), source) : t.importDeclaration([], source);
            });
          },
          injectNamedImport: function injectNamedImport(url, name, hint, moduleName) {
            if (hint === void 0) {
              hint = name;
            }
            return cache.storeNamed(prog, url, name, moduleName, function (isScript, source, name) {
              var id = prog.scope.generateUidIdentifier(hint);
              return {
                node: isScript ? hoist(template.statement.ast(_templateObject2$7 || (_templateObject2$7 = _taggedTemplateLiteralLoose(["\n                  var ", " = require(", ").", "\n                "])), id, source, name)) : t.importDeclaration([t.importSpecifier(id, name)], source),
                name: id.name
              };
            });
          },
          injectDefaultImport: function injectDefaultImport(url, hint, moduleName) {
            if (hint === void 0) {
              hint = url;
            }
            return cache.storeNamed(prog, url, "default", moduleName, function (isScript, source) {
              var id = prog.scope.generateUidIdentifier(hint);
              return {
                node: isScript ? hoist(template.statement.ast(_templateObject3$4 || (_templateObject3$4 = _taggedTemplateLiteralLoose(["var ", " = require(", ")"])), id, source)) : t.importDeclaration([t.importDefaultSpecifier(id)], source),
                name: id.name
              };
            });
          }
        };
      };
    }
    return utils$3;
  }

var importsInjector$1 = {};

var hasRequiredImportsInjector$1;
  function requireImportsInjector$1() {
    if (hasRequiredImportsInjector$1) return importsInjector$1;
    hasRequiredImportsInjector$1 = 1;
    importsInjector$1.__esModule = true;
    importsInjector$1["default"] = void 0;
    var _babel = _interopRequireWildcard(require$$5);
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    var _ref = _babel["default"] || _babel,
      t = _ref.types;
    var ImportsCachedInjector = function () {
      function ImportsCachedInjector(resolver, getPreferredIndex) {
        this._imports = new WeakMap();
        this._anonymousImports = new WeakMap();
        this._lastImports = new WeakMap();
        this._resolver = resolver;
        this._getPreferredIndex = getPreferredIndex;
      }
      var _proto = ImportsCachedInjector.prototype;
      _proto.storeAnonymous = function storeAnonymous(programPath, url, moduleName, getVal) {
        var key = this._normalizeKey(programPath, url);
        var imports = this._ensure(this._anonymousImports, programPath, Set);
        if (imports.has(key)) return;
        var node = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)));
        imports.add(key);
        this._injectImport(programPath, node, moduleName);
      };
      _proto.storeNamed = function storeNamed(programPath, url, name, moduleName, getVal) {
        var key = this._normalizeKey(programPath, url, name);
        var imports = this._ensure(this._imports, programPath, Map);
        if (!imports.has(key)) {
          var _getVal = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)), t.identifier(name)),
            node = _getVal.node,
            id = _getVal.name;
          imports.set(key, id);
          this._injectImport(programPath, node, moduleName);
        }
        return t.identifier(imports.get(key));
      };
      _proto._injectImport = function _injectImport(programPath, node, moduleName) {
        var _this$_lastImports$ge;
        var newIndex = this._getPreferredIndex(moduleName);
        var lastImports = (_this$_lastImports$ge = this._lastImports.get(programPath)) != null ? _this$_lastImports$ge : [];
        var isPathStillValid = function isPathStillValid(path) {
          return path.node && path.parent === programPath.node && path.container === programPath.node.body;
        };
        var last;
        if (newIndex === Infinity) {
          if (lastImports.length > 0) {
            last = lastImports[lastImports.length - 1].path;
            if (!isPathStillValid(last)) last = undefined;
          }
        } else {
          for (var _iterator = _createForOfIteratorHelperLoose(lastImports.entries()), _step; !(_step = _iterator()).done;) {
            var _step$value = _slicedToArray(_step.value, 2),
              i = _step$value[0],
              data = _step$value[1];
            var path = data.path,
              index = data.index;
            if (isPathStillValid(path)) {
              if (newIndex < index) {
                var _path$insertBefore = path.insertBefore(node),
                  _path$insertBefore2 = _slicedToArray(_path$insertBefore, 1),
                  newPath = _path$insertBefore2[0];
                lastImports.splice(i, 0, {
                  path: newPath,
                  index: newIndex
                });
                return;
              }
              last = path;
            }
          }
        }
        if (last) {
          var _last$insertAfter = last.insertAfter(node),
            _last$insertAfter2 = _slicedToArray(_last$insertAfter, 1),
            _newPath = _last$insertAfter2[0];
          lastImports.push({
            path: _newPath,
            index: newIndex
          });
        } else {
          var _programPath$unshiftC = programPath.unshiftContainer("body", node),
            _programPath$unshiftC2 = _slicedToArray(_programPath$unshiftC, 1),
            _newPath2 = _programPath$unshiftC2[0];
          this._lastImports.set(programPath, [{
            path: _newPath2,
            index: newIndex
          }]);
        }
      };
      _proto._ensure = function _ensure(map, programPath, Collection) {
        var collection = map.get(programPath);
        if (!collection) {
          collection = new Collection();
          map.set(programPath, collection);
        }
        return collection;
      };
      _proto._normalizeKey = function _normalizeKey(programPath, url, name) {
        if (name === void 0) {
          name = "";
        }
        var sourceType = programPath.node.sourceType;
        return (name && sourceType) + "::" + url + "::" + name;
      };
      return _createClass(ImportsCachedInjector);
    }();
    importsInjector$1["default"] = ImportsCachedInjector;
    return importsInjector$1;
  }

var debugUtils$1 = {};

var hasRequiredDebugUtils$1;
  function requireDebugUtils$1() {
    if (hasRequiredDebugUtils$1) return debugUtils$1;
    hasRequiredDebugUtils$1 = 1;
    debugUtils$1.__esModule = true;
    debugUtils$1.presetEnvSilentDebugHeader = void 0;
    debugUtils$1.stringifyTargets = stringifyTargets;
    debugUtils$1.stringifyTargetsMultiline = stringifyTargetsMultiline;
    var _helperCompilationTargets = require$$1$2;
    var presetEnvSilentDebugHeader = "#__secret_key__@babel/preset-env__don't_log_debug_header_and_resolved_targets";
    debugUtils$1.presetEnvSilentDebugHeader = presetEnvSilentDebugHeader;
    function stringifyTargetsMultiline(targets) {
      return JSON.stringify((0, _helperCompilationTargets.prettifyTargets)(targets), null, 2);
    }
    function stringifyTargets(targets) {
      return JSON.stringify(targets).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');
    }
    return debugUtils$1;
  }

var normalizeOptions$5 = {};

var hasRequiredNormalizeOptions$1;
  function requireNormalizeOptions$1() {
    if (hasRequiredNormalizeOptions$1) return normalizeOptions$5;
    hasRequiredNormalizeOptions$1 = 1;
    normalizeOptions$5.__esModule = true;
    normalizeOptions$5.applyMissingDependenciesDefaults = applyMissingDependenciesDefaults;
    normalizeOptions$5.validateIncludeExclude = validateIncludeExclude;
    var _utils = requireUtils$3();
    function patternToRegExp(pattern) {
      if (pattern instanceof RegExp) return pattern;
      try {
        return new RegExp("^" + pattern + "$");
      } catch (_unused) {
        return null;
      }
    }
    function buildUnusedError(label, unused) {
      if (!unused.length) return "";
      return "  - The following \"" + label + "\" patterns didn't match any polyfill:\n" + unused.map(function (original) {
        return "    " + String(original) + "\n";
      }).join("");
    }
    function buldDuplicatesError(duplicates) {
      if (!duplicates.size) return "";
      return "  - The following polyfills were matched both by \"include\" and \"exclude\" patterns:\n" + Array.from(duplicates, function (name) {
        return "    " + name + "\n";
      }).join("");
    }
    function validateIncludeExclude(provider, polyfills, includePatterns, excludePatterns) {
      var current;
      var filter = function filter(pattern) {
        var regexp = patternToRegExp(pattern);
        if (!regexp) return false;
        var matched = false;
        for (var _iterator = _createForOfIteratorHelperLoose(polyfills.keys()), _step; !(_step = _iterator()).done;) {
          var polyfill = _step.value;
          if (regexp.test(polyfill)) {
            matched = true;
            current.add(polyfill);
          }
        }
        return !matched;
      };
      var include = current = new Set();
      var unusedInclude = Array.from(includePatterns).filter(filter);
      var exclude = current = new Set();
      var unusedExclude = Array.from(excludePatterns).filter(filter);
      var duplicates = (0, _utils.intersection)(include, exclude);
      if (duplicates.size > 0 || unusedInclude.length > 0 || unusedExclude.length > 0) {
        throw new Error("Error while validating the \"" + provider + "\" provider options:\n" + buildUnusedError("include", unusedInclude) + buildUnusedError("exclude", unusedExclude) + buldDuplicatesError(duplicates));
      }
      return {
        include: include,
        exclude: exclude
      };
    }
    function applyMissingDependenciesDefaults(options, babelApi) {
      var _options$missingDepen = options.missingDependencies,
        missingDependencies = _options$missingDepen === void 0 ? {} : _options$missingDepen;
      if (missingDependencies === false) return false;
      var caller = babelApi.caller(function (caller) {
        return caller == null ? void 0 : caller.name;
      });
      var _missingDependencies$ = missingDependencies.log,
        log = _missingDependencies$ === void 0 ? "deferred" : _missingDependencies$,
        _missingDependencies$2 = missingDependencies.inject,
        inject = _missingDependencies$2 === void 0 ? caller === "rollup-plugin-babel" ? "throw" : "import" : _missingDependencies$2,
        _missingDependencies$3 = missingDependencies.all,
        all = _missingDependencies$3 === void 0 ? false : _missingDependencies$3;
      return {
        log: log,
        inject: inject,
        all: all
      };
    }
    return normalizeOptions$5;
  }

var visitors$1 = {};

var usage$2 = {};

var hasRequiredUsage$1;
  function requireUsage$1() {
    if (hasRequiredUsage$1) return usage$2;
    hasRequiredUsage$1 = 1;
    usage$2.__esModule = true;
    usage$2["default"] = void 0;
    var _utils = requireUtils$3();
    function isRemoved(path) {
      if (path.removed) return true;
      if (!path.parentPath) return false;
      if (path.listKey) {
        var _path$parentPath$node;
        if (!((_path$parentPath$node = path.parentPath.node) != null && (_path$parentPath$node = _path$parentPath$node[path.listKey]) != null && _path$parentPath$node.includes(path.node))) return true;
      } else {
        if (path.parentPath.node[path.key] !== path.node) return true;
      }
      return isRemoved(path.parentPath);
    }
    var _default = function _default(callProvider) {
      function property(object, key, placement, path) {
        return callProvider({
          kind: "property",
          object: object,
          key: key,
          placement: placement
        }, path);
      }
      function handleReferencedIdentifier(path) {
        var name = path.node.name,
          scope = path.scope;
        if (scope.getBindingIdentifier(name)) return;
        callProvider({
          kind: "global",
          name: name
        }, path);
      }
      function analyzeMemberExpression(path) {
        var key = (0, _utils.resolveKey)(path.get("property"), path.node.computed);
        return {
          key: key,
          handleAsMemberExpression: !!key && key !== "prototype"
        };
      }
      return {
        ReferencedIdentifier: function ReferencedIdentifier(path) {
          var parentPath = path.parentPath;
          if (parentPath.isMemberExpression({
            object: path.node
          }) && analyzeMemberExpression(parentPath).handleAsMemberExpression) {
            return;
          }
          handleReferencedIdentifier(path);
        },
        MemberExpression: function MemberExpression(path) {
          var _analyzeMemberExpress = analyzeMemberExpression(path),
            key = _analyzeMemberExpress.key,
            handleAsMemberExpression = _analyzeMemberExpress.handleAsMemberExpression;
          if (!handleAsMemberExpression) return;
          var object = path.get("object");
          var objectIsGlobalIdentifier = object.isIdentifier();
          if (objectIsGlobalIdentifier) {
            var binding = object.scope.getBinding(object.node.name);
            if (binding) {
              if (binding.path.isImportNamespaceSpecifier()) return;
              objectIsGlobalIdentifier = false;
            }
          }
          var source = (0, _utils.resolveSource)(object);
          var skipObject = property(source.id, key, source.placement, path);
          skipObject || (skipObject = !objectIsGlobalIdentifier || path.shouldSkip || object.shouldSkip || isRemoved(object));
          if (!skipObject) handleReferencedIdentifier(object);
        },
        ObjectPattern: function ObjectPattern(path) {
          var parentPath = path.parentPath,
            parent = path.parent;
          var obj;
          if (parentPath.isVariableDeclarator()) {
            obj = parentPath.get("init");
          } else if (parentPath.isAssignmentExpression()) {
            obj = parentPath.get("right");
          } else if (parentPath.isFunction()) {
            var grand = parentPath.parentPath;
            if (grand.isCallExpression() || grand.isNewExpression()) {
              if (grand.node.callee === parent) {
                obj = grand.get("arguments")[path.key];
              }
            }
          }
          var id = null;
          var placement = null;
          if (obj) {
            var _ref = (0, _utils.resolveSource)(obj);
            id = _ref.id;
            placement = _ref.placement;
          }
          for (var _iterator = _createForOfIteratorHelperLoose(path.get("properties")), _step; !(_step = _iterator()).done;) {
            var prop = _step.value;
            if (prop.isObjectProperty()) {
              var key = (0, _utils.resolveKey)(prop.get("key"));
              if (key) property(id, key, placement, prop);
            }
          }
        },
        BinaryExpression: function BinaryExpression(path) {
          if (path.node.operator !== "in") return;
          var source = (0, _utils.resolveSource)(path.get("right"));
          var key = (0, _utils.resolveKey)(path.get("left"), true);
          if (!key) return;
          callProvider({
            kind: "in",
            object: source.id,
            key: key,
            placement: source.placement
          }, path);
        }
      };
    };
    usage$2["default"] = _default;
    return usage$2;
  }

var entry$2 = {};

var hasRequiredEntry$1;
  function requireEntry$1() {
    if (hasRequiredEntry$1) return entry$2;
    hasRequiredEntry$1 = 1;
    entry$2.__esModule = true;
    entry$2["default"] = void 0;
    var _utils = requireUtils$3();
    var _default = function _default(callProvider) {
      return {
        ImportDeclaration: function ImportDeclaration(path) {
          var source = (0, _utils.getImportSource)(path);
          if (!source) return;
          callProvider({
            kind: "import",
            source: source
          }, path);
        },
        Program: function Program(path) {
          path.get("body").forEach(function (bodyPath) {
            var source = (0, _utils.getRequireSource)(bodyPath);
            if (!source) return;
            callProvider({
              kind: "import",
              source: source
            }, bodyPath);
          });
        }
      };
    };
    entry$2["default"] = _default;
    return entry$2;
  }

var hasRequiredVisitors$1;
  function requireVisitors$1() {
    if (hasRequiredVisitors$1) return visitors$1;
    hasRequiredVisitors$1 = 1;
    visitors$1.__esModule = true;
    visitors$1.usage = visitors$1.entry = void 0;
    var _usage = _interopRequireDefault(requireUsage$1());
    visitors$1.usage = _usage["default"];
    var _entry = _interopRequireDefault(requireEntry$1());
    visitors$1.entry = _entry["default"];
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    return visitors$1;
  }

var dependencies$1 = {};

var hasRequiredDependencies$1;
  function requireDependencies$1() {
    if (hasRequiredDependencies$1) return dependencies$1;
    hasRequiredDependencies$1 = 1;
    dependencies$1.__esModule = true;
    dependencies$1.has = has;
    dependencies$1.laterLogMissing = laterLogMissing;
    dependencies$1.logMissing = logMissing;
    dependencies$1.resolve = resolve;
    function resolve(dirname, moduleName, absoluteImports) {
      if (absoluteImports === false) return moduleName;
      throw new Error("\"absoluteImports\" is not supported in bundles prepared for the browser.");
    }
    function has(basedir, name) {
      return true;
    }
    function logMissing(missingDeps) {}
    function laterLogMissing(missingDeps) {}
    return dependencies$1;
  }

var metaResolver$1 = {};

var hasRequiredMetaResolver$1;
  function requireMetaResolver$1() {
    if (hasRequiredMetaResolver$1) return metaResolver$1;
    hasRequiredMetaResolver$1 = 1;
    metaResolver$1.__esModule = true;
    metaResolver$1["default"] = createMetaResolver;
    var _utils = requireUtils$3();
    var PossibleGlobalObjects = new Set(["global", "globalThis", "self", "window"]);
    function createMetaResolver(polyfills) {
      var staticP = polyfills["static"],
        instanceP = polyfills.instance,
        globalP = polyfills.global;
      return function (meta) {
        if (meta.kind === "global" && globalP && (0, _utils.has)(globalP, meta.name)) {
          return {
            kind: "global",
            desc: globalP[meta.name],
            name: meta.name
          };
        }
        if (meta.kind === "property" || meta.kind === "in") {
          var placement = meta.placement,
            object = meta.object,
            key = meta.key;
          if (object && placement === "static") {
            if (globalP && PossibleGlobalObjects.has(object) && (0, _utils.has)(globalP, key)) {
              return {
                kind: "global",
                desc: globalP[key],
                name: key
              };
            }
            if (staticP && (0, _utils.has)(staticP, object) && (0, _utils.has)(staticP[object], key)) {
              return {
                kind: "static",
                desc: staticP[object][key],
                name: object + "$" + key
              };
            }
          }
          if (instanceP && (0, _utils.has)(instanceP, key)) {
            return {
              kind: "instance",
              desc: instanceP[key],
              name: "" + key
            };
          }
        }
      };
    }
    return metaResolver$1;
  }

var hasRequiredLib$6;
  function requireLib$6() {
    if (hasRequiredLib$6) return lib$5;
    hasRequiredLib$6 = 1;
    lib$5.__esModule = true;
    lib$5["default"] = definePolyfillProvider;
    var _helperPluginUtils = require$$0$6;
    var _helperCompilationTargets = _interopRequireWildcard(require$$1$2);
    var _utils = requireUtils$3();
    var _importsInjector = _interopRequireDefault(requireImportsInjector$1());
    var _debugUtils = requireDebugUtils$1();
    var _normalizeOptions = requireNormalizeOptions$1();
    var v = _interopRequireWildcard(requireVisitors$1());
    var deps = _interopRequireWildcard(requireDependencies$1());
    var _metaResolver = _interopRequireDefault(requireMetaResolver$1());
    var _excluded = ["method", "targets", "ignoreBrowserslistConfig", "configPath", "debug", "shouldInjectPolyfill", "absoluteImports"];
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    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;
    }
    var getTargets = _helperCompilationTargets["default"]["default"] || _helperCompilationTargets["default"];
    function resolveOptions(options, babelApi) {
      var method = options.method,
        targetsOption = options.targets,
        ignoreBrowserslistConfig = options.ignoreBrowserslistConfig,
        configPath = options.configPath,
        debug = options.debug,
        shouldInjectPolyfill = options.shouldInjectPolyfill,
        absoluteImports = options.absoluteImports,
        providerOptions = _objectWithoutPropertiesLoose(options, _excluded);
      if (isEmpty(options)) {
        throw new Error("This plugin requires options, for example:\n    {\n      \"plugins\": [\n        [\"<plugin name>\", { method: \"usage-pure\" }]\n      ]\n    }\n\nSee more options at https://github.com/babel/babel-polyfills/blob/main/docs/usage.md");
      }
      var methodName;
      if (method === "usage-global") methodName = "usageGlobal";else if (method === "entry-global") methodName = "entryGlobal";else if (method === "usage-pure") methodName = "usagePure";else if (typeof method !== "string") {
        throw new Error(".method must be a string");
      } else {
        throw new Error(".method must be one of \"entry-global\", \"usage-global\"" + (" or \"usage-pure\" (received " + JSON.stringify(method) + ")"));
      }
      if (typeof shouldInjectPolyfill === "function") {
        if (options.include || options.exclude) {
          throw new Error(".include and .exclude are not supported when using the" + " .shouldInjectPolyfill function.");
        }
      } else if (shouldInjectPolyfill != null) {
        throw new Error(".shouldInjectPolyfill must be a function, or undefined" + (" (received " + JSON.stringify(shouldInjectPolyfill) + ")"));
      }
      if (absoluteImports != null && typeof absoluteImports !== "boolean" && typeof absoluteImports !== "string") {
        throw new Error(".absoluteImports must be a boolean, a string, or undefined" + (" (received " + JSON.stringify(absoluteImports) + ")"));
      }
      var targets;
      if (targetsOption || configPath || ignoreBrowserslistConfig) {
        var targetsObj = typeof targetsOption === "string" || Array.isArray(targetsOption) ? {
          browsers: targetsOption
        } : targetsOption;
        targets = getTargets(targetsObj, {
          ignoreBrowserslistConfig: ignoreBrowserslistConfig,
          configPath: configPath
        });
      } else {
        targets = babelApi.targets();
      }
      return {
        method: method,
        methodName: methodName,
        targets: targets,
        absoluteImports: absoluteImports != null ? absoluteImports : false,
        shouldInjectPolyfill: shouldInjectPolyfill,
        debug: !!debug,
        providerOptions: providerOptions
      };
    }
    function instantiateProvider(factory, options, missingDependencies, dirname, debugLog, babelApi) {
      var _resolveOptions = resolveOptions(options, babelApi),
        method = _resolveOptions.method,
        methodName = _resolveOptions.methodName,
        targets = _resolveOptions.targets,
        _debug = _resolveOptions.debug,
        _shouldInjectPolyfill = _resolveOptions.shouldInjectPolyfill,
        providerOptions = _resolveOptions.providerOptions,
        absoluteImports = _resolveOptions.absoluteImports;
      var include, exclude;
      var polyfillsSupport;
      var polyfillsNames;
      var filterPolyfills;
      var getUtils = (0, _utils.createUtilsGetter)(new _importsInjector["default"](function (moduleName) {
        return deps.resolve(dirname, moduleName, absoluteImports);
      }, function (name) {
        var _polyfillsNames$get, _polyfillsNames;
        return (_polyfillsNames$get = (_polyfillsNames = polyfillsNames) == null ? void 0 : _polyfillsNames.get(name)) != null ? _polyfillsNames$get : Infinity;
      }));
      var depsCache = new Map();
      var api = {
        babel: babelApi,
        getUtils: getUtils,
        method: options.method,
        targets: targets,
        createMetaResolver: _metaResolver["default"],
        shouldInjectPolyfill: function shouldInjectPolyfill(name) {
          if (polyfillsNames === undefined) {
            throw new Error("Internal error in the " + factory.name + " provider: " + "shouldInjectPolyfill() can't be called during initialization.");
          }
          if (!polyfillsNames.has(name)) {
            console.warn("Internal error in the " + providerName + " provider: " + ("unknown polyfill \"" + name + "\"."));
          }
          if (filterPolyfills && !filterPolyfills(name)) return false;
          var shouldInject = (0, _helperCompilationTargets.isRequired)(name, targets, {
            compatData: polyfillsSupport,
            includes: include,
            excludes: exclude
          });
          if (_shouldInjectPolyfill) {
            shouldInject = _shouldInjectPolyfill(name, shouldInject);
            if (typeof shouldInject !== "boolean") {
              throw new Error(".shouldInjectPolyfill must return a boolean.");
            }
          }
          return shouldInject;
        },
        debug: function debug(name) {
          var _debugLog, _debugLog$polyfillsSu;
          debugLog().found = true;
          if (!_debug || !name) return;
          if (debugLog().polyfills.has(providerName)) return;
          debugLog().polyfills.add(name);
          (_debugLog$polyfillsSu = (_debugLog = debugLog()).polyfillsSupport) != null ? _debugLog$polyfillsSu : _debugLog.polyfillsSupport = polyfillsSupport;
        },
        assertDependency: function assertDependency(name, version) {
          if (version === void 0) {
            version = "*";
          }
          if (missingDependencies === false) return;
          if (absoluteImports) {
            return;
          }
          var dep = version === "*" ? name : name + "@^" + version;
          var found = missingDependencies.all ? false : mapGetOr(depsCache, name + " :: " + dirname, function () {
            return deps.has(dirname, name);
          });
          if (!found) {
            debugLog().missingDeps.add(dep);
          }
        }
      };
      var provider = factory(api, providerOptions, dirname);
      var providerName = provider.name || factory.name;
      if (typeof provider[methodName] !== "function") {
        throw new Error("The \"" + providerName + "\" provider doesn't support the \"" + method + "\" polyfilling method.");
      }
      if (Array.isArray(provider.polyfills)) {
        polyfillsNames = new Map(provider.polyfills.map(function (name, index) {
          return [name, index];
        }));
        filterPolyfills = provider.filterPolyfills;
      } else if (provider.polyfills) {
        polyfillsNames = new Map(Object.keys(provider.polyfills).map(function (name, index) {
          return [name, index];
        }));
        polyfillsSupport = provider.polyfills;
        filterPolyfills = provider.filterPolyfills;
      } else {
        polyfillsNames = new Map();
      }
      var _ref2 = (0, _normalizeOptions.validateIncludeExclude)(providerName, polyfillsNames, providerOptions.include || [], providerOptions.exclude || []);
      include = _ref2.include;
      exclude = _ref2.exclude;
      var callProvider;
      if (methodName === "usageGlobal") {
        callProvider = function callProvider(payload, path) {
          var _ref;
          var utils = getUtils(path);
          return (_ref = provider[methodName](payload, utils, path)) != null ? _ref : false;
        };
      } else {
        callProvider = function callProvider(payload, path) {
          var utils = getUtils(path);
          provider[methodName](payload, utils, path);
          return false;
        };
      }
      return {
        debug: _debug,
        method: method,
        targets: targets,
        provider: provider,
        providerName: providerName,
        callProvider: callProvider
      };
    }
    function definePolyfillProvider(factory) {
      return (0, _helperPluginUtils.declare)(function (babelApi, options, dirname) {
        babelApi.assertVersion("^7.0.0 || ^8.0.0-alpha.0");
        var traverse = babelApi.traverse;
        var debugLog;
        var missingDependencies = (0, _normalizeOptions.applyMissingDependenciesDefaults)(options, babelApi);
        var _instantiateProvider = instantiateProvider(factory, options, missingDependencies, dirname, function () {
            return debugLog;
          }, babelApi),
          debug = _instantiateProvider.debug,
          method = _instantiateProvider.method,
          targets = _instantiateProvider.targets,
          provider = _instantiateProvider.provider,
          providerName = _instantiateProvider.providerName,
          callProvider = _instantiateProvider.callProvider;
        var createVisitor = method === "entry-global" ? v.entry : v.usage;
        var visitor = provider.visitor ? traverse.visitors.merge([createVisitor(callProvider), provider.visitor]) : createVisitor(callProvider);
        if (debug && debug !== _debugUtils.presetEnvSilentDebugHeader) {
          console.log(providerName + ": `DEBUG` option");
          console.log("\nUsing targets: " + (0, _debugUtils.stringifyTargetsMultiline)(targets));
          console.log("\nUsing polyfills with `" + method + "` method:");
        }
        var runtimeName = provider.runtimeName;
        return {
          name: "inject-polyfills",
          visitor: visitor,
          pre: function pre(file) {
            var _provider$pre;
            if (runtimeName) {
              if (file.get("runtimeHelpersModuleName") && file.get("runtimeHelpersModuleName") !== runtimeName) {
                console.warn("Two different polyfill providers" + (" (" + file.get("runtimeHelpersModuleProvider")) + (" and " + providerName + ") are trying to define two") + " conflicting @babel/runtime alternatives:" + (" " + file.get("runtimeHelpersModuleName") + " and " + runtimeName + ".") + " The second one will be ignored.");
              } else {
                file.set("runtimeHelpersModuleName", runtimeName);
                file.set("runtimeHelpersModuleProvider", providerName);
              }
            }
            debugLog = {
              polyfills: new Set(),
              polyfillsSupport: undefined,
              found: false,
              providers: new Set(),
              missingDeps: new Set()
            };
            (_provider$pre = provider.pre) == null ? void 0 : _provider$pre.apply(this, arguments);
          },
          post: function post() {
            var _provider$post;
            (_provider$post = provider.post) == null ? void 0 : _provider$post.apply(this, arguments);
            if (missingDependencies !== false) {
              if (missingDependencies.log === "per-file") {
                deps.logMissing(debugLog.missingDeps);
              } else {
                deps.laterLogMissing(debugLog.missingDeps);
              }
            }
            if (!debug) return;
            if (this.filename) console.log("\n[" + this.filename + "]");
            if (debugLog.polyfills.size === 0) {
              console.log(method === "entry-global" ? debugLog.found ? "Based on your targets, the " + providerName + " polyfill did not add any polyfill." : "The entry point for the " + providerName + " polyfill has not been found." : "Based on your code and targets, the " + providerName + " polyfill did not add any polyfill.");
              return;
            }
            if (method === "entry-global") {
              console.log("The " + providerName + " polyfill entry has been replaced with " + "the following polyfills:");
            } else {
              console.log("The " + providerName + " polyfill added the following polyfills:");
            }
            for (var _iterator = _createForOfIteratorHelperLoose(debugLog.polyfills), _step; !(_step = _iterator()).done;) {
              var name = _step.value;
              var _debugLog$polyfillsSu2;
              if ((_debugLog$polyfillsSu2 = debugLog.polyfillsSupport) != null && _debugLog$polyfillsSu2[name]) {
                var filteredTargets = (0, _helperCompilationTargets.getInclusionReasons)(name, targets, debugLog.polyfillsSupport);
                var formattedTargets = JSON.stringify(filteredTargets).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');
                console.log("  " + name + " " + formattedTargets);
              } else {
                console.log("  " + name);
              }
            }
          }
        };
      });
    }
    function mapGetOr(map, key, getDefault) {
      var val = map.get(key);
      if (val === undefined) {
        val = getDefault();
        map.set(key, val);
      }
      return val;
    }
    function isEmpty(obj) {
      return Object.keys(obj).length === 0;
    }
    return lib$5;
  }

var hasRequiredLib$5;
  function requireLib$5() {
    if (hasRequiredLib$5) return lib$6;
    hasRequiredLib$5 = 1;
    lib$6.__esModule = true;
    lib$6["default"] = void 0;
    var _corejs2BuiltIns = _interopRequireDefault(requireCorejs2BuiltIns());
    var _builtInDefinitions = requireBuiltInDefinitions$2();
    var _addPlatformSpecificPolyfills = _interopRequireDefault(requireAddPlatformSpecificPolyfills$1());
    var _helpers = requireHelpers$1();
    var _helperDefinePolyfillProvider = _interopRequireDefault(requireLib$6());
    var _babel = _interopRequireWildcard(require$$5);
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    var _ref = _babel["default"] || _babel,
      t = _ref.types;
    var BABEL_RUNTIME = "@babel/runtime-corejs2";
    var presetEnvCompat = "#__secret_key__@babel/preset-env__compatibility";
    var runtimeCompat = "#__secret_key__@babel/runtime__compatibility";
    var has = Function.call.bind(Object.hasOwnProperty);
    var _default = (0, _helperDefinePolyfillProvider["default"])(function (api, _ref2) {
      var _ref2$presetEnvCompat = _ref2[presetEnvCompat],
        _ref2$presetEnvCompat2 = _ref2$presetEnvCompat === void 0 ? {} : _ref2$presetEnvCompat,
        _ref2$presetEnvCompat3 = _ref2$presetEnvCompat2.entryInjectRegenerator,
        entryInjectRegenerator = _ref2$presetEnvCompat3 === void 0 ? false : _ref2$presetEnvCompat3,
        _ref2$presetEnvCompat4 = _ref2$presetEnvCompat2.noRuntimeName,
        noRuntimeName = _ref2$presetEnvCompat4 === void 0 ? false : _ref2$presetEnvCompat4,
        _ref2$runtimeCompat = _ref2[runtimeCompat],
        _ref2$runtimeCompat2 = _ref2$runtimeCompat === void 0 ? {} : _ref2$runtimeCompat,
        _ref2$runtimeCompat2$ = _ref2$runtimeCompat2.useBabelRuntime,
        useBabelRuntime = _ref2$runtimeCompat2$ === void 0 ? false : _ref2$runtimeCompat2$,
        _ref2$runtimeCompat2$2 = _ref2$runtimeCompat2.runtimeVersion,
        runtimeVersion = _ref2$runtimeCompat2$2 === void 0 ? "" : _ref2$runtimeCompat2$2,
        _ref2$runtimeCompat2$3 = _ref2$runtimeCompat2.ext,
        ext = _ref2$runtimeCompat2$3 === void 0 ? ".js" : _ref2$runtimeCompat2$3;
      var resolve = api.createMetaResolver({
        global: _builtInDefinitions.BuiltIns,
        "static": _builtInDefinitions.StaticProperties,
        instance: _builtInDefinitions.InstanceProperties
      });
      var debug = api.debug,
        shouldInjectPolyfill = api.shouldInjectPolyfill,
        method = api.method;
      var polyfills = (0, _addPlatformSpecificPolyfills["default"])(api.targets, method, _corejs2BuiltIns["default"]);
      var coreJSBase = useBabelRuntime ? BABEL_RUNTIME + "/core-js" : method === "usage-pure" ? "core-js/library/fn" : "core-js/modules";
      function inject(name, utils) {
        if (typeof name === "string") {
          if (has(polyfills, name) && shouldInjectPolyfill(name)) {
            debug(name);
            utils.injectGlobalImport(coreJSBase + "/" + name + ".js");
          }
          return;
        }
        name.forEach(function (name) {
          return inject(name, utils);
        });
      }
      function maybeInjectPure(desc, hint, utils) {
        var pure = desc.pure,
          meta = desc.meta,
          name = desc.name;
        if (!pure || !shouldInjectPolyfill(name)) return;
        if (runtimeVersion && meta && meta.minRuntimeVersion && !(0, _helpers.hasMinVersion)(meta && meta.minRuntimeVersion, runtimeVersion)) {
          return;
        }
        if (useBabelRuntime && pure === "symbol/index") pure = "symbol";
        return utils.injectDefaultImport(coreJSBase + "/" + pure + ext, hint);
      }
      return {
        name: "corejs2",
        runtimeName: noRuntimeName ? null : BABEL_RUNTIME,
        polyfills: polyfills,
        entryGlobal: function entryGlobal(meta, utils, path) {
          if (meta.kind === "import" && meta.source === "core-js") {
            debug(null);
            inject(Object.keys(polyfills), utils);
            if (entryInjectRegenerator) {
              utils.injectGlobalImport("regenerator-runtime/runtime.js");
            }
            path.remove();
          }
        },
        usageGlobal: function usageGlobal(meta, utils) {
          var resolved = resolve(meta);
          if (!resolved) return;
          var deps = resolved.desc.global;
          if (resolved.kind !== "global" && "object" in meta && meta.object && meta.placement === "prototype") {
            var low = meta.object.toLowerCase();
            deps = deps.filter(function (m) {
              return m.includes(low);
            });
          }
          inject(deps, utils);
        },
        usagePure: function usagePure(meta, utils, path) {
          if (meta.kind === "in") {
            if (meta.key === "Symbol.iterator") {
              path.replaceWith(t.callExpression(utils.injectDefaultImport(coreJSBase + "/is-iterable" + ext, "isIterable"), [path.node.right]));
            }
            return;
          }
          if (path.parentPath.isUnaryExpression({
            operator: "delete"
          })) return;
          if (meta.kind === "property") {
            if (!path.isMemberExpression()) return;
            if (!path.isReferenced()) return;
            if (meta.key === "Symbol.iterator" && shouldInjectPolyfill("es6.symbol") && path.parentPath.isCallExpression({
              callee: path.node
            }) && path.parentPath.node.arguments.length === 0) {
              path.parentPath.replaceWith(t.callExpression(utils.injectDefaultImport(coreJSBase + "/get-iterator" + ext, "getIterator"), [path.node.object]));
              path.skip();
              return;
            }
          }
          var resolved = resolve(meta);
          if (!resolved) return;
          var id = maybeInjectPure(resolved.desc, resolved.name, utils);
          if (id) path.replaceWith(id);
        },
        visitor: method === "usage-global" && {
          YieldExpression: function YieldExpression(path) {
            if (path.node.delegate) {
              inject("web.dom.iterable", api.getUtils(path));
            }
          },
          "ForOfStatement|ArrayPattern": function ForOfStatementArrayPattern(path) {
            _builtInDefinitions.CommonIterators.forEach(function (name) {
              return inject(name, api.getUtils(path));
            });
          }
        }
      };
    });
    lib$6["default"] = _default;
    return lib$6;
  }

var babelPluginPolyfillCorejs2$1;
  var hasRequiredBabelPluginPolyfillCorejs2$1;
  function requireBabelPluginPolyfillCorejs2$1() {
    if (hasRequiredBabelPluginPolyfillCorejs2$1) return babelPluginPolyfillCorejs2$1;
    hasRequiredBabelPluginPolyfillCorejs2$1 = 1;
    function bool(value) {
      if (value == null) return false;
      return value && value !== "false" && value !== "0";
    }
    babelPluginPolyfillCorejs2$1 = bool(browser$1$1.env["BABEL_8_BREAKING"]) ? null : requireLib$5();
    return babelPluginPolyfillCorejs2$1;
  }

var lib$4 = {};

var require$$0$4 = {
  	"es.symbol": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "15",
  	electron: "0.37",
  	firefox: "51",
  	"firefox-android": "51",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.symbol.description": {
  	android: "70",
  	bun: "0.1.1",
  	chrome: "70",
  	"chrome-android": "70",
  	deno: "1.0",
  	edge: "79",
  	electron: "5.0",
  	firefox: "63",
  	"firefox-android": "63",
  	ios: "12.2",
  	node: "11.0",
  	oculus: "6.0",
  	opera: "57",
  	"opera-android": "49",
  	opera_mobile: "49",
  	quest: "6.0",
  	safari: "12.1",
  	samsung: "10.0"
  },
  	"es.symbol.async-iterator": {
  	android: "63",
  	bun: "0.1.1",
  	chrome: "63",
  	"chrome-android": "63",
  	deno: "1.0",
  	edge: "79",
  	electron: "3.0",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "12.0",
  	node: "10.0",
  	oculus: "5.0",
  	opera: "50",
  	"opera-android": "46",
  	opera_mobile: "46",
  	quest: "5.0",
  	safari: "12.0",
  	samsung: "8.0"
  },
  	"es.symbol.has-instance": {
  	android: "50",
  	bun: "0.1.1",
  	chrome: "50",
  	"chrome-android": "50",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.1",
  	firefox: "49",
  	"firefox-android": "49",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "37",
  	"opera-android": "37",
  	opera_mobile: "37",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.symbol.is-concat-spreadable": {
  	android: "48",
  	bun: "0.1.1",
  	chrome: "48",
  	"chrome-android": "48",
  	deno: "1.0",
  	edge: "15",
  	electron: "0.37",
  	firefox: "48",
  	"firefox-android": "48",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "35",
  	"opera-android": "35",
  	opera_mobile: "35",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.symbol.iterator": {
  	android: "41",
  	bun: "0.1.1",
  	chrome: "41",
  	"chrome-android": "41",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.21",
  	firefox: "36",
  	"firefox-android": "36",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "28",
  	"opera-android": "28",
  	opera_mobile: "28",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "3.4"
  },
  	"es.symbol.match": {
  	android: "50",
  	bun: "0.1.1",
  	chrome: "50",
  	"chrome-android": "50",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.1",
  	firefox: "40",
  	"firefox-android": "40",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "37",
  	"opera-android": "37",
  	opera_mobile: "37",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.symbol.match-all": {
  	android: "73",
  	bun: "0.1.1",
  	chrome: "73",
  	"chrome-android": "73",
  	deno: "1.0",
  	edge: "79",
  	electron: "5.0",
  	firefox: "67",
  	"firefox-android": "67",
  	hermes: "0.6",
  	ios: "13.0",
  	node: "12.0",
  	oculus: "6.0",
  	opera: "60",
  	"opera-android": "52",
  	opera_mobile: "52",
  	quest: "6.0",
  	"react-native": "0.69",
  	safari: "13",
  	samsung: "11.0"
  },
  	"es.symbol.replace": {
  	android: "50",
  	bun: "0.1.1",
  	chrome: "50",
  	"chrome-android": "50",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.1",
  	firefox: "49",
  	"firefox-android": "49",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "37",
  	"opera-android": "37",
  	opera_mobile: "37",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.symbol.search": {
  	android: "50",
  	bun: "0.1.1",
  	chrome: "50",
  	"chrome-android": "50",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.1",
  	firefox: "49",
  	"firefox-android": "49",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "37",
  	"opera-android": "37",
  	opera_mobile: "37",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.symbol.species": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "13",
  	electron: "1.2",
  	firefox: "41",
  	"firefox-android": "41",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.symbol.split": {
  	android: "50",
  	bun: "0.1.1",
  	chrome: "50",
  	"chrome-android": "50",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.1",
  	firefox: "49",
  	"firefox-android": "49",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "37",
  	"opera-android": "37",
  	opera_mobile: "37",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.symbol.to-primitive": {
  	android: "47",
  	bun: "0.1.1",
  	chrome: "47",
  	"chrome-android": "47",
  	deno: "1.0",
  	edge: "15",
  	electron: "0.36",
  	firefox: "44",
  	"firefox-android": "44",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "34",
  	"opera-android": "34",
  	opera_mobile: "34",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.symbol.to-string-tag": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "15",
  	electron: "0.37",
  	firefox: "51",
  	"firefox-android": "51",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.symbol.unscopables": {
  	android: "41",
  	bun: "0.1.1",
  	chrome: "41",
  	"chrome-android": "41",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.21",
  	firefox: "48",
  	"firefox-android": "48",
  	ios: "9.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "28",
  	"opera-android": "28",
  	opera_mobile: "28",
  	quest: "3.0",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "3.4"
  },
  	"es.error.cause": {
  	android: "94",
  	bun: "0.1.1",
  	chrome: "94",
  	"chrome-android": "94",
  	deno: "1.14",
  	edge: "94",
  	electron: "15.0",
  	firefox: "91",
  	"firefox-android": "91",
  	hermes: "0.8",
  	ios: "15.0",
  	node: "16.11",
  	oculus: "18.0",
  	opera: "80",
  	"opera-android": "66",
  	opera_mobile: "66",
  	quest: "18.0",
  	"react-native": "0.69",
  	safari: "15.0",
  	samsung: "17.0"
  },
  	"es.error.to-string": {
  	android: "4.4.3",
  	bun: "0.1.1",
  	chrome: "33",
  	"chrome-android": "33",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "11",
  	"firefox-android": "11",
  	hermes: "0.1",
  	ie: "9",
  	ios: "9.0",
  	node: "0.11.13",
  	oculus: "3.0",
  	opera: "20",
  	"opera-android": "20",
  	opera_mobile: "20",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.14",
  	safari: "8.0",
  	samsung: "2.0"
  },
  	"es.aggregate-error": {
  	android: "85",
  	bun: "0.1.1",
  	chrome: "85",
  	"chrome-android": "85",
  	deno: "1.2",
  	edge: "85",
  	electron: "10.0",
  	firefox: "79",
  	"firefox-android": "79",
  	hermes: "0.13",
  	ios: "14.0",
  	node: "15.0",
  	oculus: "12.0",
  	opera: "71",
  	"opera-android": "60",
  	opera_mobile: "60",
  	quest: "12.0",
  	"react-native": "0.72",
  	safari: "14.0",
  	samsung: "14.0"
  },
  	"es.aggregate-error.cause": {
  	android: "94",
  	bun: "0.1.1",
  	chrome: "94",
  	"chrome-android": "94",
  	deno: "1.14",
  	edge: "94",
  	electron: "15.0",
  	firefox: "91",
  	"firefox-android": "91",
  	hermes: "0.13",
  	ios: "15.0",
  	node: "16.11",
  	oculus: "18.0",
  	opera: "80",
  	"opera-android": "66",
  	opera_mobile: "66",
  	quest: "18.0",
  	"react-native": "0.72",
  	safari: "15.0",
  	samsung: "17.0"
  },
  	"es.array.at": {
  	android: "92",
  	bun: "0.1.1",
  	chrome: "92",
  	"chrome-android": "92",
  	deno: "1.12",
  	edge: "92",
  	electron: "14.0",
  	firefox: "90",
  	"firefox-android": "90",
  	hermes: "0.13",
  	ios: "15.4",
  	node: "16.6",
  	oculus: "17.0",
  	opera: "78",
  	"opera-android": "65",
  	opera_mobile: "65",
  	quest: "17.0",
  	"react-native": "0.71",
  	rhino: "1.7.15",
  	safari: "15.4",
  	samsung: "16.0"
  },
  	"es.array.concat": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.2",
  	firefox: "48",
  	"firefox-android": "48",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.array.copy-within": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.31",
  	firefox: "48",
  	"firefox-android": "48",
  	ios: "9.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	safari: "9.0",
  	samsung: "5.0"
  },
  	"es.array.every": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "26",
  	"chrome-android": "26",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "8.0",
  	node: "0.11.0",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "1.5"
  },
  	"es.array.fill": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.31",
  	firefox: "48",
  	"firefox-android": "48",
  	ios: "9.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	safari: "9.0",
  	samsung: "5.0"
  },
  	"es.array.filter": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.2",
  	firefox: "48",
  	"firefox-android": "48",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.array.find": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "48",
  	"firefox-android": "48",
  	ios: "9.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	safari: "9.0",
  	samsung: "5.0"
  },
  	"es.array.find-index": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "48",
  	"firefox-android": "48",
  	ios: "9.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	safari: "9.0",
  	samsung: "5.0"
  },
  	"es.array.find-last": {
  	android: "97",
  	bun: "0.1.1",
  	chrome: "97",
  	"chrome-android": "97",
  	deno: "1.16",
  	edge: "97",
  	electron: "17.0",
  	firefox: "104",
  	"firefox-android": "104",
  	hermes: "0.11",
  	ios: "15.4",
  	node: "18.0",
  	oculus: "20.0",
  	opera: "83",
  	"opera-android": "68",
  	opera_mobile: "68",
  	quest: "20.0",
  	"react-native": "0.69",
  	safari: "15.4",
  	samsung: "18.0"
  },
  	"es.array.find-last-index": {
  	android: "97",
  	bun: "0.1.1",
  	chrome: "97",
  	"chrome-android": "97",
  	deno: "1.16",
  	edge: "97",
  	electron: "17.0",
  	firefox: "104",
  	"firefox-android": "104",
  	hermes: "0.11",
  	ios: "15.4",
  	node: "18.0",
  	oculus: "20.0",
  	opera: "83",
  	"opera-android": "68",
  	opera_mobile: "68",
  	quest: "20.0",
  	"react-native": "0.69",
  	safari: "15.4",
  	samsung: "18.0"
  },
  	"es.array.flat": {
  	android: "69",
  	bun: "0.1.1",
  	chrome: "69",
  	"chrome-android": "69",
  	deno: "1.0",
  	edge: "79",
  	electron: "4.0",
  	firefox: "62",
  	"firefox-android": "62",
  	hermes: "0.4",
  	ios: "12.0",
  	node: "11.0",
  	oculus: "6.0",
  	opera: "56",
  	"opera-android": "48",
  	opera_mobile: "48",
  	quest: "6.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "12.0",
  	samsung: "10.0"
  },
  	"es.array.flat-map": {
  	android: "69",
  	bun: "0.1.1",
  	chrome: "69",
  	"chrome-android": "69",
  	deno: "1.0",
  	edge: "79",
  	electron: "4.0",
  	firefox: "62",
  	"firefox-android": "62",
  	hermes: "0.4",
  	ios: "12.0",
  	node: "11.0",
  	oculus: "6.0",
  	opera: "56",
  	"opera-android": "48",
  	opera_mobile: "48",
  	quest: "6.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "12.0",
  	samsung: "10.0"
  },
  	"es.array.for-each": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "26",
  	"chrome-android": "26",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "8.0",
  	node: "0.11.0",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "1.5"
  },
  	"es.array.from": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.2",
  	firefox: "53",
  	"firefox-android": "53",
  	hermes: "0.13",
  	ios: "9.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.73",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "5.0"
  },
  	"es.array.includes": {
  	android: "53",
  	bun: "0.1.1",
  	chrome: "53",
  	"chrome-android": "53",
  	deno: "1.0",
  	edge: "14",
  	electron: "1.4",
  	firefox: "102",
  	"firefox-android": "102",
  	ios: "10.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "40",
  	"opera-android": "40",
  	opera_mobile: "40",
  	quest: "3.0",
  	safari: "10.0",
  	samsung: "6.0"
  },
  	"es.array.index-of": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "12",
  	electron: "1.2",
  	firefox: "47",
  	"firefox-android": "47",
  	hermes: "0.1",
  	ie: "9",
  	ios: "8.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "5.0"
  },
  	"es.array.is-array": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "3.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "4.0",
  	samsung: "1.0"
  },
  	"es.array.iterator": {
  	android: "66",
  	bun: "0.1.1",
  	chrome: "66",
  	"chrome-android": "66",
  	deno: "1.0",
  	edge: "15",
  	electron: "3.0",
  	firefox: "60",
  	"firefox-android": "60",
  	ios: "10.0",
  	node: "10.0",
  	oculus: "5.0",
  	opera: "53",
  	"opera-android": "47",
  	opera_mobile: "47",
  	quest: "5.0",
  	safari: "10.0",
  	samsung: "9.0"
  },
  	"es.array.join": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "26",
  	"chrome-android": "26",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.0",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "1.5"
  },
  	"es.array.last-index-of": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "12",
  	electron: "1.2",
  	firefox: "47",
  	"firefox-android": "47",
  	hermes: "0.1",
  	ie: "9",
  	ios: "8.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "5.0"
  },
  	"es.array.map": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "13",
  	electron: "1.2",
  	firefox: "50",
  	"firefox-android": "50",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.array.of": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "5.0"
  },
  	"es.array.push": {
  	android: "122",
  	bun: "0.1.1",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.41.3",
  	edge: "122",
  	electron: "29.0",
  	firefox: "55",
  	"firefox-android": "55",
  	hermes: "0.2",
  	ios: "16.0",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	"react-native": "0.69",
  	safari: "16.0",
  	samsung: "26.0"
  },
  	"es.array.reduce": {
  	android: "83",
  	bun: "0.1.1",
  	chrome: "83",
  	"chrome-android": "83",
  	deno: "1.0",
  	edge: "12",
  	electron: "9.0",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "8.0",
  	node: "6.0",
  	oculus: "10.0",
  	opera: "69",
  	"opera-android": "59",
  	opera_mobile: "59",
  	quest: "10.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "13.0"
  },
  	"es.array.reduce-right": {
  	android: "83",
  	bun: "0.1.1",
  	chrome: "83",
  	"chrome-android": "83",
  	deno: "1.0",
  	edge: "12",
  	electron: "9.0",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "8.0",
  	node: "6.0",
  	oculus: "10.0",
  	opera: "69",
  	"opera-android": "59",
  	opera_mobile: "59",
  	quest: "10.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "13.0"
  },
  	"es.array.reverse": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "1",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "1",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "5.5",
  	ios: "12.2",
  	node: "0.0.3",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "12.0.2",
  	samsung: "1.0"
  },
  	"es.array.slice": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "13",
  	electron: "1.2",
  	firefox: "48",
  	"firefox-android": "48",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.array.some": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "26",
  	"chrome-android": "26",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "8.0",
  	node: "0.11.0",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "1.5"
  },
  	"es.array.sort": {
  	android: "70",
  	bun: "0.1.1",
  	chrome: "70",
  	"chrome-android": "70",
  	deno: "1.0",
  	edge: "79",
  	electron: "5.0",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.10",
  	ios: "12.0",
  	node: "11.0",
  	oculus: "6.0",
  	opera: "57",
  	"opera-android": "49",
  	opera_mobile: "49",
  	quest: "6.0",
  	"react-native": "0.69",
  	safari: "12.0",
  	samsung: "10.0"
  },
  	"es.array.species": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "13",
  	electron: "1.2",
  	firefox: "48",
  	"firefox-android": "48",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	rhino: "1.7.15",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.array.splice": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "13",
  	electron: "1.2",
  	firefox: "49",
  	"firefox-android": "49",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.array.to-reversed": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	hermes: "0.13",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	"react-native": "0.74",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"es.array.to-sorted": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"es.array.to-spliced": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	hermes: "0.13",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	"react-native": "0.74",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"es.array.unscopables.flat": {
  	android: "73",
  	bun: "0.1.1",
  	chrome: "73",
  	"chrome-android": "73",
  	deno: "1.0",
  	edge: "79",
  	electron: "5.0",
  	firefox: "67",
  	"firefox-android": "67",
  	ios: "13.0",
  	node: "12.0",
  	oculus: "6.0",
  	opera: "60",
  	"opera-android": "52",
  	opera_mobile: "52",
  	quest: "6.0",
  	safari: "13",
  	samsung: "11.0"
  },
  	"es.array.unscopables.flat-map": {
  	android: "73",
  	bun: "0.1.1",
  	chrome: "73",
  	"chrome-android": "73",
  	deno: "1.0",
  	edge: "79",
  	electron: "5.0",
  	firefox: "67",
  	"firefox-android": "67",
  	ios: "13.0",
  	node: "12.0",
  	oculus: "6.0",
  	opera: "60",
  	"opera-android": "52",
  	opera_mobile: "52",
  	quest: "6.0",
  	safari: "13",
  	samsung: "11.0"
  },
  	"es.array.unshift": {
  	android: "71",
  	bun: "0.1.1",
  	chrome: "71",
  	"chrome-android": "71",
  	deno: "1.0",
  	edge: "12",
  	electron: "5.0",
  	firefox: "23",
  	"firefox-android": "23",
  	hermes: "0.1",
  	ie: "9",
  	ios: "16.0",
  	node: "12.0",
  	oculus: "6.0",
  	opera: "58",
  	"opera-android": "50",
  	opera_mobile: "50",
  	quest: "6.0",
  	"react-native": "0.69",
  	safari: "16.0",
  	samsung: "10.0"
  },
  	"es.array.with": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	hermes: "0.13",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	"react-native": "0.74",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"es.array-buffer.constructor": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "28",
  	"chrome-android": "28",
  	deno: "1.0",
  	edge: "14",
  	electron: "0.20",
  	firefox: "44",
  	"firefox-android": "44",
  	hermes: "0.1",
  	ios: "12.0",
  	node: "0.11.1",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "12.0",
  	samsung: "1.5"
  },
  	"es.array-buffer.is-view": {
  	android: "4.4.3",
  	bun: "0.1.1",
  	chrome: "32",
  	"chrome-android": "32",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "29",
  	"firefox-android": "29",
  	hermes: "0.1",
  	ie: "11",
  	ios: "8.0",
  	node: "0.11.9",
  	oculus: "3.0",
  	opera: "19",
  	"opera-android": "19",
  	opera_mobile: "19",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "7.1",
  	samsung: "2.0"
  },
  	"es.array-buffer.slice": {
  	android: "4.4.3",
  	bun: "0.1.1",
  	chrome: "31",
  	"chrome-android": "31",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "46",
  	"firefox-android": "46",
  	hermes: "0.1",
  	ie: "11",
  	ios: "12.2",
  	node: "0.11.8",
  	oculus: "3.0",
  	opera: "18",
  	"opera-android": "18",
  	opera_mobile: "18",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "12.1",
  	samsung: "2.0"
  },
  	"es.data-view": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "26",
  	"chrome-android": "26",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "15",
  	"firefox-android": "15",
  	hermes: "0.1",
  	ie: "10",
  	ios: "8.0",
  	node: "0.11.0",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "1.5"
  },
  	"es.array-buffer.detached": {
  	android: "114",
  	bun: "1.0.19",
  	chrome: "114",
  	"chrome-android": "114",
  	deno: "1.33",
  	edge: "114",
  	electron: "25.0",
  	firefox: "122",
  	"firefox-android": "122",
  	ios: "17.4",
  	node: "21.0",
  	oculus: "28.0",
  	opera: "100",
  	"opera-android": "76",
  	opera_mobile: "76",
  	quest: "28.0",
  	safari: "17.4",
  	samsung: "23.0"
  },
  	"es.array-buffer.transfer": {
  	android: "114",
  	bun: "1.0.19",
  	chrome: "114",
  	"chrome-android": "114",
  	deno: "1.33",
  	edge: "114",
  	electron: "25.0",
  	firefox: "122",
  	"firefox-android": "122",
  	ios: "17.4",
  	node: "21.0",
  	oculus: "28.0",
  	opera: "100",
  	"opera-android": "76",
  	opera_mobile: "76",
  	quest: "28.0",
  	safari: "17.4",
  	samsung: "23.0"
  },
  	"es.array-buffer.transfer-to-fixed-length": {
  	android: "114",
  	bun: "1.0.19",
  	chrome: "114",
  	"chrome-android": "114",
  	deno: "1.33",
  	edge: "114",
  	electron: "25.0",
  	firefox: "122",
  	"firefox-android": "122",
  	ios: "17.4",
  	node: "21.0",
  	oculus: "28.0",
  	opera: "100",
  	"opera-android": "76",
  	opera_mobile: "76",
  	quest: "28.0",
  	safari: "17.4",
  	samsung: "23.0"
  },
  	"es.date.get-year": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "1",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "1",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "1.0",
  	node: "0.0.3",
  	oculus: "3.0",
  	opera: "3",
  	"opera-android": "3",
  	opera_mobile: "3",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "1",
  	samsung: "1.0"
  },
  	"es.date.now": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "3.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "4.0",
  	samsung: "1.0"
  },
  	"es.date.set-year": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "1",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "1",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "3",
  	ios: "1.0",
  	node: "0.0.3",
  	oculus: "3.0",
  	opera: "3",
  	"opera-android": "3",
  	opera_mobile: "3",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "1",
  	samsung: "1.0"
  },
  	"es.date.to-gmt-string": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "1",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "1",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "3",
  	ios: "1.0",
  	node: "0.0.3",
  	oculus: "3.0",
  	opera: "3",
  	"opera-android": "3",
  	opera_mobile: "3",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "1",
  	samsung: "1.0"
  },
  	"es.date.to-iso-string": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "26",
  	"chrome-android": "26",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "7",
  	"firefox-android": "7",
  	hermes: "0.1",
  	ie: "9",
  	ios: "8.0",
  	node: "0.11.0",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "1.5"
  },
  	"es.date.to-json": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "26",
  	"chrome-android": "26",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "10.0",
  	node: "0.11.0",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "1.5"
  },
  	"es.date.to-primitive": {
  	android: "47",
  	bun: "0.1.1",
  	chrome: "47",
  	"chrome-android": "47",
  	deno: "1.0",
  	edge: "15",
  	electron: "0.36",
  	firefox: "44",
  	"firefox-android": "44",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "34",
  	"opera-android": "34",
  	opera_mobile: "34",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.date.to-string": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "2.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "3.1",
  	samsung: "1.0"
  },
  	"es.escape": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "1",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "1",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "3",
  	ios: "1.0",
  	node: "0.0.3",
  	oculus: "3.0",
  	opera: "3",
  	"opera-android": "3",
  	opera_mobile: "3",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "1",
  	samsung: "1.0"
  },
  	"es.function.bind": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "7",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "5.0",
  	node: "0.1.101",
  	oculus: "3.0",
  	opera: "12",
  	"opera-android": "12",
  	opera_mobile: "12",
  	phantom: "2.0",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "5.1",
  	samsung: "1.0"
  },
  	"es.function.has-instance": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.2",
  	firefox: "50",
  	"firefox-android": "50",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.function.name": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ios: "3.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "4.0",
  	samsung: "1.0"
  },
  	"es.global-this": {
  	android: "71",
  	bun: "0.1.1",
  	chrome: "71",
  	"chrome-android": "71",
  	deno: "1.0",
  	edge: "79",
  	electron: "5.0",
  	firefox: "65",
  	"firefox-android": "65",
  	hermes: "0.2",
  	ios: "12.2",
  	node: "12.0",
  	oculus: "6.0",
  	opera: "58",
  	"opera-android": "50",
  	opera_mobile: "50",
  	quest: "6.0",
  	"react-native": "0.69",
  	rhino: "1.7.14",
  	safari: "12.1",
  	samsung: "10.0"
  },
  	"es.json.stringify": {
  	android: "72",
  	bun: "0.1.1",
  	chrome: "72",
  	"chrome-android": "72",
  	deno: "1.0",
  	edge: "79",
  	electron: "5.0",
  	firefox: "64",
  	"firefox-android": "64",
  	hermes: "0.13",
  	ios: "12.2",
  	node: "12.0",
  	oculus: "6.0",
  	opera: "59",
  	"opera-android": "51",
  	opera_mobile: "51",
  	quest: "6.0",
  	"react-native": "0.72",
  	safari: "12.1",
  	samsung: "11.0"
  },
  	"es.json.to-string-tag": {
  	android: "50",
  	bun: "0.1.1",
  	chrome: "50",
  	"chrome-android": "50",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.1",
  	firefox: "51",
  	"firefox-android": "51",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "37",
  	"opera-android": "37",
  	opera_mobile: "37",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.map": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.2",
  	firefox: "53",
  	"firefox-android": "53",
  	hermes: "0.13",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.73",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.map.group-by": {
  	android: "117",
  	bun: "1.1.2",
  	chrome: "117",
  	"chrome-android": "117",
  	deno: "1.37",
  	edge: "117",
  	electron: "27.0",
  	firefox: "119",
  	"firefox-android": "119",
  	ios: "18.0",
  	node: "21.0",
  	oculus: "30.0",
  	opera: "103",
  	"opera-android": "78",
  	opera_mobile: "78",
  	quest: "30.0",
  	safari: "18.0",
  	samsung: "24.0"
  },
  	"es.math.acosh": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "13",
  	electron: "1.4",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "7.1",
  	samsung: "6.0"
  },
  	"es.math.asinh": {
  	android: "38",
  	bun: "0.1.1",
  	chrome: "38",
  	"chrome-android": "38",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "25",
  	"opera-android": "25",
  	opera_mobile: "25",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.0"
  },
  	"es.math.atanh": {
  	android: "38",
  	bun: "0.1.1",
  	chrome: "38",
  	"chrome-android": "38",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "25",
  	"opera-android": "25",
  	opera_mobile: "25",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.0"
  },
  	"es.math.cbrt": {
  	android: "38",
  	bun: "0.1.1",
  	chrome: "38",
  	"chrome-android": "38",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "25",
  	"opera-android": "25",
  	opera_mobile: "25",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.0"
  },
  	"es.math.clz32": {
  	android: "38",
  	bun: "0.1.1",
  	chrome: "38",
  	"chrome-android": "38",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "31",
  	"firefox-android": "31",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "25",
  	"opera-android": "25",
  	opera_mobile: "25",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "3.0"
  },
  	"es.math.cosh": {
  	android: "39",
  	bun: "0.1.1",
  	chrome: "39",
  	"chrome-android": "39",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "26",
  	"opera-android": "26",
  	opera_mobile: "26",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.4"
  },
  	"es.math.expm1": {
  	android: "39",
  	bun: "0.1.1",
  	chrome: "39",
  	"chrome-android": "39",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.20",
  	firefox: "46",
  	"firefox-android": "46",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "26",
  	"opera-android": "26",
  	opera_mobile: "26",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.4"
  },
  	"es.math.fround": {
  	android: "38",
  	bun: "0.1.1",
  	chrome: "38",
  	"chrome-android": "38",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "26",
  	"firefox-android": "26",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "25",
  	"opera-android": "25",
  	opera_mobile: "25",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.0"
  },
  	"es.math.hypot": {
  	android: "78",
  	bun: "0.1.1",
  	chrome: "78",
  	"chrome-android": "78",
  	deno: "1.0",
  	edge: "12",
  	electron: "7.0",
  	firefox: "27",
  	"firefox-android": "27",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "12.16",
  	oculus: "8.0",
  	opera: "65",
  	"opera-android": "56",
  	opera_mobile: "56",
  	quest: "8.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "12.0"
  },
  	"es.math.imul": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "28",
  	"chrome-android": "28",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.20",
  	firefox: "20",
  	"firefox-android": "20",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.11.1",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "1.5"
  },
  	"es.math.log10": {
  	android: "38",
  	bun: "0.1.1",
  	chrome: "38",
  	"chrome-android": "38",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "25",
  	"opera-android": "25",
  	opera_mobile: "25",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.0"
  },
  	"es.math.log1p": {
  	android: "38",
  	bun: "0.1.1",
  	chrome: "38",
  	"chrome-android": "38",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "25",
  	"opera-android": "25",
  	opera_mobile: "25",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.0"
  },
  	"es.math.log2": {
  	android: "38",
  	bun: "0.1.1",
  	chrome: "38",
  	"chrome-android": "38",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "25",
  	"opera-android": "25",
  	opera_mobile: "25",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.0"
  },
  	"es.math.sign": {
  	android: "38",
  	bun: "0.1.1",
  	chrome: "38",
  	"chrome-android": "38",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "25",
  	"opera-android": "25",
  	opera_mobile: "25",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "3.0"
  },
  	"es.math.sinh": {
  	android: "39",
  	bun: "0.1.1",
  	chrome: "39",
  	"chrome-android": "39",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "26",
  	"opera-android": "26",
  	opera_mobile: "26",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.4"
  },
  	"es.math.tanh": {
  	android: "38",
  	bun: "0.1.1",
  	chrome: "38",
  	"chrome-android": "38",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "25",
  	"opera-android": "25",
  	opera_mobile: "25",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.0"
  },
  	"es.math.to-string-tag": {
  	android: "50",
  	bun: "0.1.1",
  	chrome: "50",
  	"chrome-android": "50",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.1",
  	firefox: "51",
  	"firefox-android": "51",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "37",
  	"opera-android": "37",
  	opera_mobile: "37",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.math.trunc": {
  	android: "38",
  	bun: "0.1.1",
  	chrome: "38",
  	"chrome-android": "38",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "25",
  	"opera-android": "25",
  	opera_mobile: "25",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.0"
  },
  	"es.number.constructor": {
  	android: "41",
  	bun: "0.1.1",
  	chrome: "41",
  	"chrome-android": "41",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.21",
  	firefox: "46",
  	"firefox-android": "46",
  	hermes: "0.5",
  	ios: "9.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "28",
  	"opera-android": "28",
  	opera_mobile: "28",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "3.4"
  },
  	"es.number.epsilon": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "34",
  	"chrome-android": "34",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "25",
  	"firefox-android": "25",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.11.13",
  	oculus: "3.0",
  	opera: "21",
  	"opera-android": "21",
  	opera_mobile: "21",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.14",
  	safari: "9.0",
  	samsung: "2.0"
  },
  	"es.number.is-finite": {
  	android: "4.1",
  	bun: "0.1.1",
  	chrome: "19",
  	"chrome-android": "25",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "16",
  	"firefox-android": "16",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.7.3",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "1.5"
  },
  	"es.number.is-integer": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "34",
  	"chrome-android": "34",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "16",
  	"firefox-android": "16",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.11.13",
  	oculus: "3.0",
  	opera: "21",
  	"opera-android": "21",
  	opera_mobile: "21",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "2.0"
  },
  	"es.number.is-nan": {
  	android: "4.1",
  	bun: "0.1.1",
  	chrome: "19",
  	"chrome-android": "25",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "15",
  	"firefox-android": "15",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.7.3",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "1.5"
  },
  	"es.number.is-safe-integer": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "34",
  	"chrome-android": "34",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "32",
  	"firefox-android": "32",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.11.13",
  	oculus: "3.0",
  	opera: "21",
  	"opera-android": "21",
  	opera_mobile: "21",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "2.0"
  },
  	"es.number.max-safe-integer": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "34",
  	"chrome-android": "34",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "31",
  	"firefox-android": "31",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.11.13",
  	oculus: "3.0",
  	opera: "21",
  	"opera-android": "21",
  	opera_mobile: "21",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "2.0"
  },
  	"es.number.min-safe-integer": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "34",
  	"chrome-android": "34",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "31",
  	"firefox-android": "31",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.11.13",
  	oculus: "3.0",
  	opera: "21",
  	"opera-android": "21",
  	opera_mobile: "21",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "2.0"
  },
  	"es.number.parse-float": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "35",
  	"chrome-android": "35",
  	deno: "1.0",
  	edge: "79",
  	electron: "0.20",
  	firefox: "39",
  	"firefox-android": "39",
  	hermes: "0.1",
  	ios: "11.0",
  	node: "0.11.13",
  	oculus: "3.0",
  	opera: "22",
  	"opera-android": "22",
  	opera_mobile: "22",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.14",
  	safari: "11.0",
  	samsung: "3.0"
  },
  	"es.number.parse-int": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "35",
  	"chrome-android": "35",
  	deno: "1.0",
  	edge: "79",
  	electron: "0.20",
  	firefox: "39",
  	"firefox-android": "39",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.11.13",
  	oculus: "3.0",
  	opera: "22",
  	"opera-android": "22",
  	opera_mobile: "22",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.14",
  	safari: "9.0",
  	samsung: "3.0"
  },
  	"es.number.to-exponential": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "18",
  	electron: "1.2",
  	firefox: "87",
  	"firefox-android": "87",
  	hermes: "0.1",
  	ios: "11.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.14",
  	safari: "11",
  	samsung: "5.0"
  },
  	"es.number.to-fixed": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "26",
  	"chrome-android": "26",
  	deno: "1.0",
  	edge: "79",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.0",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "1.5"
  },
  	"es.number.to-precision": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "26",
  	"chrome-android": "26",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "8",
  	ios: "8.0",
  	node: "0.11.0",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "1.5"
  },
  	"es.object.assign": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "79",
  	electron: "0.37",
  	firefox: "36",
  	"firefox-android": "36",
  	hermes: "0.4",
  	ios: "9.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "9.0",
  	samsung: "5.0"
  },
  	"es.object.create": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "3.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "12",
  	"opera-android": "12",
  	opera_mobile: "12",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "4.0",
  	samsung: "1.0"
  },
  	"es.object.define-getter": {
  	android: "62",
  	bun: "0.1.1",
  	chrome: "62",
  	"chrome-android": "62",
  	deno: "1.0",
  	edge: "16",
  	electron: "3.0",
  	firefox: "48",
  	"firefox-android": "48",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "8.10",
  	oculus: "5.0",
  	opera: "49",
  	"opera-android": "46",
  	opera_mobile: "46",
  	quest: "5.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "8.0"
  },
  	"es.object.define-properties": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "37",
  	"chrome-android": "37",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "5.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "12",
  	"opera-android": "12",
  	opera_mobile: "12",
  	phantom: "2.0",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "5.1",
  	samsung: "3.0"
  },
  	"es.object.define-property": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "37",
  	"chrome-android": "37",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "4",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "5.0",
  	node: "0.11.15",
  	oculus: "3.0",
  	opera: "12",
  	"opera-android": "12",
  	opera_mobile: "12",
  	phantom: "2.0",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "5.1",
  	samsung: "3.0"
  },
  	"es.object.define-setter": {
  	android: "62",
  	bun: "0.1.1",
  	chrome: "62",
  	"chrome-android": "62",
  	deno: "1.0",
  	edge: "16",
  	electron: "3.0",
  	firefox: "48",
  	"firefox-android": "48",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "8.10",
  	oculus: "5.0",
  	opera: "49",
  	"opera-android": "46",
  	opera_mobile: "46",
  	quest: "5.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "8.0"
  },
  	"es.object.entries": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "14",
  	electron: "1.4",
  	firefox: "47",
  	"firefox-android": "47",
  	hermes: "0.1",
  	ios: "10.3",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.14",
  	safari: "10.1",
  	samsung: "6.0"
  },
  	"es.object.freeze": {
  	android: "44",
  	bun: "0.1.1",
  	chrome: "44",
  	"chrome-android": "44",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.30",
  	firefox: "35",
  	"firefox-android": "35",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "3.0",
  	oculus: "3.0",
  	opera: "31",
  	"opera-android": "31",
  	opera_mobile: "31",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "4.0"
  },
  	"es.object.from-entries": {
  	android: "73",
  	bun: "0.1.1",
  	chrome: "73",
  	"chrome-android": "73",
  	deno: "1.0",
  	edge: "79",
  	electron: "5.0",
  	firefox: "63",
  	"firefox-android": "63",
  	hermes: "0.4",
  	ios: "12.2",
  	node: "12.0",
  	oculus: "6.0",
  	opera: "60",
  	"opera-android": "52",
  	opera_mobile: "52",
  	quest: "6.0",
  	"react-native": "0.69",
  	rhino: "1.7.14",
  	safari: "12.1",
  	samsung: "11.0"
  },
  	"es.object.get-own-property-descriptor": {
  	android: "44",
  	bun: "0.1.1",
  	chrome: "44",
  	"chrome-android": "44",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.30",
  	firefox: "35",
  	"firefox-android": "35",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "3.0",
  	oculus: "3.0",
  	opera: "31",
  	"opera-android": "31",
  	opera_mobile: "31",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "4.0"
  },
  	"es.object.get-own-property-descriptors": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "50",
  	"firefox-android": "50",
  	hermes: "0.6",
  	ios: "10.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "10.0",
  	samsung: "6.0"
  },
  	"es.object.get-own-property-names": {
  	android: "40",
  	bun: "0.1.1",
  	chrome: "40",
  	"chrome-android": "40",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.21",
  	firefox: "34",
  	"firefox-android": "34",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "27",
  	"opera-android": "27",
  	opera_mobile: "27",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "3.4"
  },
  	"es.object.get-prototype-of": {
  	android: "44",
  	bun: "0.1.1",
  	chrome: "44",
  	"chrome-android": "44",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.30",
  	firefox: "35",
  	"firefox-android": "35",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "3.0",
  	oculus: "3.0",
  	opera: "31",
  	"opera-android": "31",
  	opera_mobile: "31",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "4.0"
  },
  	"es.object.group-by": {
  	android: "117",
  	bun: "1.1.2",
  	chrome: "117",
  	"chrome-android": "117",
  	deno: "1.37",
  	edge: "117",
  	electron: "27.0",
  	firefox: "119",
  	"firefox-android": "119",
  	ios: "18.0",
  	node: "21.0",
  	oculus: "30.0",
  	opera: "103",
  	"opera-android": "78",
  	opera_mobile: "78",
  	quest: "30.0",
  	safari: "18.0",
  	samsung: "24.0"
  },
  	"es.object.has-own": {
  	android: "93",
  	bun: "0.1.1",
  	chrome: "93",
  	"chrome-android": "93",
  	deno: "1.13",
  	edge: "93",
  	electron: "14.0",
  	firefox: "92",
  	"firefox-android": "92",
  	hermes: "0.10",
  	ios: "15.4",
  	node: "16.9",
  	oculus: "17.0",
  	opera: "79",
  	"opera-android": "66",
  	opera_mobile: "66",
  	quest: "17.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "15.4",
  	samsung: "17.0"
  },
  	"es.object.is": {
  	android: "4.1",
  	bun: "0.1.1",
  	chrome: "19",
  	"chrome-android": "25",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "22",
  	"firefox-android": "22",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "0.7.3",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "1.5"
  },
  	"es.object.is-extensible": {
  	android: "44",
  	bun: "0.1.1",
  	chrome: "44",
  	"chrome-android": "44",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.30",
  	firefox: "35",
  	"firefox-android": "35",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "3.0",
  	oculus: "3.0",
  	opera: "31",
  	"opera-android": "31",
  	opera_mobile: "31",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "4.0"
  },
  	"es.object.is-frozen": {
  	android: "44",
  	bun: "0.1.1",
  	chrome: "44",
  	"chrome-android": "44",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.30",
  	firefox: "35",
  	"firefox-android": "35",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "3.0",
  	oculus: "3.0",
  	opera: "31",
  	"opera-android": "31",
  	opera_mobile: "31",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "4.0"
  },
  	"es.object.is-sealed": {
  	android: "44",
  	bun: "0.1.1",
  	chrome: "44",
  	"chrome-android": "44",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.30",
  	firefox: "35",
  	"firefox-android": "35",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "3.0",
  	oculus: "3.0",
  	opera: "31",
  	"opera-android": "31",
  	opera_mobile: "31",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "4.0"
  },
  	"es.object.keys": {
  	android: "40",
  	bun: "0.1.1",
  	chrome: "40",
  	"chrome-android": "40",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.21",
  	firefox: "35",
  	"firefox-android": "35",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "27",
  	"opera-android": "27",
  	opera_mobile: "27",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "3.4"
  },
  	"es.object.lookup-getter": {
  	android: "62",
  	bun: "0.1.1",
  	chrome: "62",
  	"chrome-android": "62",
  	deno: "1.0",
  	edge: "16",
  	electron: "3.0",
  	firefox: "48",
  	"firefox-android": "48",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "8.10",
  	oculus: "5.0",
  	opera: "49",
  	"opera-android": "46",
  	opera_mobile: "46",
  	quest: "5.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "8.0"
  },
  	"es.object.lookup-setter": {
  	android: "62",
  	bun: "0.1.1",
  	chrome: "62",
  	"chrome-android": "62",
  	deno: "1.0",
  	edge: "16",
  	electron: "3.0",
  	firefox: "48",
  	"firefox-android": "48",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "8.10",
  	oculus: "5.0",
  	opera: "49",
  	"opera-android": "46",
  	opera_mobile: "46",
  	quest: "5.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "8.0"
  },
  	"es.object.prevent-extensions": {
  	android: "44",
  	bun: "0.1.1",
  	chrome: "44",
  	"chrome-android": "44",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.30",
  	firefox: "35",
  	"firefox-android": "35",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "3.0",
  	oculus: "3.0",
  	opera: "31",
  	"opera-android": "31",
  	opera_mobile: "31",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "4.0"
  },
  	"es.object.proto": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "11",
  	ios: "2.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "3.1",
  	samsung: "1.0"
  },
  	"es.object.seal": {
  	android: "44",
  	bun: "0.1.1",
  	chrome: "44",
  	"chrome-android": "44",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.30",
  	firefox: "35",
  	"firefox-android": "35",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "3.0",
  	oculus: "3.0",
  	opera: "31",
  	"opera-android": "31",
  	opera_mobile: "31",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "4.0"
  },
  	"es.object.set-prototype-of": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "34",
  	"chrome-android": "34",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "31",
  	"firefox-android": "31",
  	hermes: "0.1",
  	ie: "11",
  	ios: "9.0",
  	node: "0.11.13",
  	oculus: "3.0",
  	opera: "21",
  	"opera-android": "21",
  	opera_mobile: "21",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "2.0"
  },
  	"es.object.to-string": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "15",
  	electron: "0.37",
  	firefox: "51",
  	"firefox-android": "51",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.object.values": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "14",
  	electron: "1.4",
  	firefox: "47",
  	"firefox-android": "47",
  	hermes: "0.1",
  	ios: "10.3",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.14",
  	safari: "10.1",
  	samsung: "6.0"
  },
  	"es.parse-float": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "35",
  	"chrome-android": "35",
  	deno: "1.0",
  	edge: "74",
  	electron: "0.20",
  	firefox: "8",
  	"firefox-android": "8",
  	hermes: "0.1",
  	ie: "8",
  	ios: "8.0",
  	node: "0.11.13",
  	oculus: "3.0",
  	opera: "22",
  	"opera-android": "22",
  	opera_mobile: "22",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.0"
  },
  	"es.parse-int": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "35",
  	"chrome-android": "35",
  	deno: "1.0",
  	edge: "74",
  	electron: "0.20",
  	firefox: "21",
  	"firefox-android": "21",
  	hermes: "0.1",
  	ie: "9",
  	ios: "8.0",
  	node: "0.11.13",
  	oculus: "3.0",
  	opera: "22",
  	"opera-android": "22",
  	opera_mobile: "22",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "7.1",
  	samsung: "3.0"
  },
  	"es.promise": {
  	android: "67",
  	bun: "0.1.1",
  	chrome: "67",
  	"chrome-android": "67",
  	deno: "1.24",
  	edge: "79",
  	electron: "4.0",
  	firefox: "69",
  	"firefox-android": "69",
  	ios: "11.0",
  	node: "10.4",
  	oculus: "6.0",
  	opera: "54",
  	"opera-android": "48",
  	opera_mobile: "48",
  	quest: "6.0",
  	rhino: "1.7.14",
  	safari: "11.0",
  	samsung: "9.0"
  },
  	"es.promise.all-settled": {
  	android: "76",
  	bun: "0.1.1",
  	chrome: "76",
  	"chrome-android": "76",
  	deno: "1.24",
  	edge: "79",
  	electron: "6.0",
  	firefox: "71",
  	"firefox-android": "71",
  	ios: "13.0",
  	node: "12.9",
  	oculus: "7.0",
  	opera: "63",
  	"opera-android": "54",
  	opera_mobile: "54",
  	quest: "7.0",
  	rhino: "1.7.15",
  	safari: "13",
  	samsung: "12.0"
  },
  	"es.promise.any": {
  	android: "85",
  	bun: "0.1.1",
  	chrome: "85",
  	"chrome-android": "85",
  	deno: "1.24",
  	edge: "85",
  	electron: "10.0",
  	firefox: "79",
  	"firefox-android": "79",
  	ios: "14.0",
  	node: "15.0",
  	oculus: "12.0",
  	opera: "71",
  	"opera-android": "60",
  	opera_mobile: "60",
  	quest: "12.0",
  	safari: "14.0",
  	samsung: "14.0"
  },
  	"es.promise.finally": {
  	android: "67",
  	bun: "0.1.1",
  	chrome: "67",
  	"chrome-android": "67",
  	deno: "1.24",
  	edge: "79",
  	electron: "4.0",
  	firefox: "69",
  	"firefox-android": "69",
  	ios: "13.2.3",
  	node: "10.4",
  	oculus: "6.0",
  	opera: "54",
  	"opera-android": "48",
  	opera_mobile: "48",
  	quest: "6.0",
  	rhino: "1.7.14",
  	safari: "13.0.3",
  	samsung: "9.0"
  },
  	"es.promise.with-resolvers": {
  	android: "119",
  	bun: "0.7.1",
  	chrome: "119",
  	"chrome-android": "119",
  	deno: "1.38",
  	edge: "119",
  	electron: "28.0",
  	firefox: "121",
  	"firefox-android": "121",
  	ios: "17.4",
  	node: "22.0",
  	oculus: "31.0",
  	opera: "105",
  	"opera-android": "79",
  	opera_mobile: "79",
  	quest: "31.0",
  	safari: "17.4",
  	samsung: "25.0"
  },
  	"es.reflect.apply": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "15",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.construct": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "15",
  	electron: "0.37",
  	firefox: "44",
  	"firefox-android": "44",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.define-property": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.delete-property": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.get": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.get-own-property-descriptor": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.get-prototype-of": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.has": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.is-extensible": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.own-keys": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.prevent-extensions": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.set": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "79",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.set-prototype-of": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.37",
  	firefox: "42",
  	"firefox-android": "42",
  	hermes: "0.7",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.reflect.to-string-tag": {
  	android: "86",
  	bun: "0.1.1",
  	chrome: "86",
  	"chrome-android": "86",
  	deno: "1.3",
  	edge: "86",
  	electron: "11.0",
  	firefox: "82",
  	"firefox-android": "82",
  	hermes: "0.7",
  	ios: "14.0",
  	node: "15.0",
  	oculus: "12.0",
  	opera: "72",
  	"opera-android": "61",
  	opera_mobile: "61",
  	quest: "12.0",
  	"react-native": "0.69",
  	safari: "14.0",
  	samsung: "14.0"
  },
  	"es.regexp.constructor": {
  	android: "64",
  	bun: "0.1.1",
  	chrome: "64",
  	"chrome-android": "64",
  	deno: "1.0",
  	edge: "79",
  	electron: "3.0",
  	firefox: "78",
  	"firefox-android": "78",
  	ios: "11.3",
  	node: "10.0",
  	oculus: "5.0",
  	opera: "51",
  	"opera-android": "47",
  	opera_mobile: "47",
  	quest: "5.0",
  	safari: "11.1",
  	samsung: "9.0"
  },
  	"es.regexp.dot-all": {
  	android: "62",
  	bun: "0.1.1",
  	chrome: "62",
  	"chrome-android": "62",
  	deno: "1.0",
  	edge: "79",
  	electron: "3.0",
  	firefox: "78",
  	"firefox-android": "78",
  	hermes: "0.4",
  	ios: "11.3",
  	node: "8.10",
  	oculus: "5.0",
  	opera: "49",
  	"opera-android": "46",
  	opera_mobile: "46",
  	quest: "5.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "11.1",
  	samsung: "8.0"
  },
  	"es.regexp.exec": {
  	android: "64",
  	bun: "0.1.1",
  	chrome: "64",
  	"chrome-android": "64",
  	deno: "1.0",
  	edge: "79",
  	electron: "3.0",
  	firefox: "78",
  	"firefox-android": "78",
  	hermes: "0.13",
  	ios: "11.3",
  	node: "10.0",
  	oculus: "5.0",
  	opera: "51",
  	"opera-android": "47",
  	opera_mobile: "47",
  	quest: "5.0",
  	"react-native": "0.71",
  	safari: "11.1",
  	samsung: "9.0"
  },
  	"es.regexp.flags": {
  	android: "111",
  	bun: "0.1.1",
  	chrome: "111",
  	"chrome-android": "111",
  	deno: "1.32",
  	edge: "111",
  	electron: "24.0",
  	firefox: "78",
  	"firefox-android": "78",
  	hermes: "0.4",
  	ios: "11.3",
  	node: "20.0",
  	oculus: "27.0",
  	opera: "97",
  	"opera-android": "75",
  	opera_mobile: "75",
  	quest: "27.0",
  	"react-native": "0.69",
  	safari: "11.1",
  	samsung: "22.0"
  },
  	"es.regexp.sticky": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.37",
  	firefox: "3",
  	"firefox-android": "4",
  	hermes: "0.3",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.regexp.test": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.2",
  	firefox: "46",
  	"firefox-android": "46",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.regexp.to-string": {
  	android: "50",
  	bun: "0.1.1",
  	chrome: "50",
  	"chrome-android": "50",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.1",
  	firefox: "46",
  	"firefox-android": "46",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "37",
  	"opera-android": "37",
  	opera_mobile: "37",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.set": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.2",
  	firefox: "53",
  	"firefox-android": "53",
  	hermes: "0.13",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.73",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.set.difference.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"es.set.intersection.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"es.set.is-disjoint-from.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"es.set.is-subset-of.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"es.set.is-superset-of.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"es.set.symmetric-difference.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"es.set.union.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"es.string.at-alternative": {
  	android: "92",
  	bun: "0.1.1",
  	chrome: "92",
  	"chrome-android": "92",
  	deno: "1.12",
  	edge: "92",
  	electron: "14.0",
  	firefox: "90",
  	"firefox-android": "90",
  	hermes: "0.13",
  	ios: "15.4",
  	node: "16.6",
  	oculus: "17.0",
  	opera: "78",
  	"opera-android": "65",
  	opera_mobile: "65",
  	quest: "17.0",
  	"react-native": "0.71",
  	rhino: "1.7.15",
  	safari: "15.4",
  	samsung: "16.0"
  },
  	"es.string.code-point-at": {
  	android: "41",
  	bun: "0.1.1",
  	chrome: "41",
  	"chrome-android": "41",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.21",
  	firefox: "29",
  	"firefox-android": "29",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "28",
  	"opera-android": "28",
  	opera_mobile: "28",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "3.4"
  },
  	"es.string.ends-with": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.2",
  	firefox: "40",
  	"firefox-android": "40",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.string.from-code-point": {
  	android: "41",
  	bun: "0.1.1",
  	chrome: "41",
  	"chrome-android": "41",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.21",
  	firefox: "29",
  	"firefox-android": "29",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "28",
  	"opera-android": "28",
  	opera_mobile: "28",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "3.4"
  },
  	"es.string.includes": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.2",
  	firefox: "40",
  	"firefox-android": "40",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.string.is-well-formed": {
  	android: "111",
  	bun: "0.4.0",
  	chrome: "111",
  	"chrome-android": "111",
  	deno: "1.32",
  	edge: "111",
  	electron: "24.0",
  	firefox: "119",
  	"firefox-android": "119",
  	ios: "16.4",
  	node: "20.0",
  	oculus: "27.0",
  	opera: "97",
  	"opera-android": "75",
  	opera_mobile: "75",
  	quest: "27.0",
  	safari: "16.4",
  	samsung: "22.0"
  },
  	"es.string.iterator": {
  	android: "41",
  	bun: "0.1.1",
  	chrome: "41",
  	"chrome-android": "41",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.21",
  	firefox: "36",
  	"firefox-android": "36",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "28",
  	"opera-android": "28",
  	opera_mobile: "28",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "3.4"
  },
  	"es.string.match": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.2",
  	firefox: "49",
  	"firefox-android": "49",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.string.match-all": {
  	android: "80",
  	bun: "0.1.1",
  	chrome: "80",
  	"chrome-android": "80",
  	deno: "1.0",
  	edge: "80",
  	electron: "8.0",
  	firefox: "73",
  	"firefox-android": "73",
  	hermes: "0.6",
  	ios: "13.4",
  	node: "14.0",
  	oculus: "9.0",
  	opera: "67",
  	"opera-android": "57",
  	opera_mobile: "57",
  	quest: "9.0",
  	"react-native": "0.69",
  	safari: "13.1",
  	samsung: "13.0"
  },
  	"es.string.pad-end": {
  	android: "57",
  	bun: "0.1.1",
  	chrome: "57",
  	"chrome-android": "57",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.7",
  	firefox: "48",
  	"firefox-android": "48",
  	hermes: "0.1",
  	ios: "11.0",
  	node: "8.0",
  	oculus: "3.0",
  	opera: "44",
  	"opera-android": "43",
  	opera_mobile: "43",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "11.0",
  	samsung: "7.0"
  },
  	"es.string.pad-start": {
  	android: "57",
  	bun: "0.1.1",
  	chrome: "57",
  	"chrome-android": "57",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.7",
  	firefox: "48",
  	"firefox-android": "48",
  	hermes: "0.1",
  	ios: "11.0",
  	node: "8.0",
  	oculus: "3.0",
  	opera: "44",
  	"opera-android": "43",
  	opera_mobile: "43",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "11.0",
  	samsung: "7.0"
  },
  	"es.string.raw": {
  	android: "41",
  	bun: "0.1.1",
  	chrome: "41",
  	"chrome-android": "41",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.21",
  	firefox: "34",
  	"firefox-android": "34",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "28",
  	"opera-android": "28",
  	opera_mobile: "28",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.14",
  	safari: "9.0",
  	samsung: "3.4"
  },
  	"es.string.repeat": {
  	android: "41",
  	bun: "0.1.1",
  	chrome: "41",
  	"chrome-android": "41",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.21",
  	firefox: "24",
  	"firefox-android": "24",
  	hermes: "0.1",
  	ios: "9.0",
  	node: "1.0",
  	oculus: "3.0",
  	opera: "28",
  	"opera-android": "28",
  	opera_mobile: "28",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "9.0",
  	samsung: "3.4"
  },
  	"es.string.replace": {
  	android: "64",
  	bun: "0.1.1",
  	chrome: "64",
  	"chrome-android": "64",
  	deno: "1.0",
  	edge: "79",
  	electron: "3.0",
  	firefox: "78",
  	"firefox-android": "78",
  	hermes: "0.13",
  	ios: "14.0",
  	node: "10.0",
  	oculus: "5.0",
  	opera: "51",
  	"opera-android": "47",
  	opera_mobile: "47",
  	quest: "5.0",
  	"react-native": "0.71",
  	safari: "14.0",
  	samsung: "9.0"
  },
  	"es.string.replace-all": {
  	android: "85",
  	bun: "0.1.1",
  	chrome: "85",
  	"chrome-android": "85",
  	deno: "1.2",
  	edge: "85",
  	electron: "10.0",
  	firefox: "77",
  	"firefox-android": "77",
  	hermes: "0.7",
  	ios: "13.4",
  	node: "15.0",
  	oculus: "12.0",
  	opera: "71",
  	"opera-android": "60",
  	opera_mobile: "60",
  	quest: "12.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "13.1",
  	samsung: "14.0"
  },
  	"es.string.search": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.2",
  	firefox: "49",
  	"firefox-android": "49",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.string.split": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.4",
  	firefox: "49",
  	"firefox-android": "49",
  	ios: "10.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "10.0",
  	samsung: "6.0"
  },
  	"es.string.starts-with": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.2",
  	firefox: "40",
  	"firefox-android": "40",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.string.substr": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "1",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "1",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "9",
  	ios: "1.0",
  	node: "0.0.3",
  	oculus: "3.0",
  	opera: "4",
  	"opera-android": "4",
  	opera_mobile: "4",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "1",
  	samsung: "1.0"
  },
  	"es.string.to-well-formed": {
  	android: "111",
  	bun: "0.5.7",
  	chrome: "111",
  	"chrome-android": "111",
  	deno: "1.32",
  	edge: "111",
  	electron: "24.0",
  	firefox: "119",
  	"firefox-android": "119",
  	ios: "16.4",
  	node: "20.0",
  	oculus: "27.0",
  	opera: "97",
  	"opera-android": "75",
  	opera_mobile: "75",
  	quest: "27.0",
  	safari: "16.4",
  	samsung: "22.0"
  },
  	"es.string.trim": {
  	android: "59",
  	bun: "0.1.1",
  	chrome: "59",
  	"chrome-android": "59",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.8",
  	firefox: "52",
  	"firefox-android": "52",
  	hermes: "0.1",
  	ios: "12.2",
  	node: "8.3",
  	oculus: "4.0",
  	opera: "46",
  	"opera-android": "43",
  	opera_mobile: "43",
  	quest: "4.0",
  	"react-native": "0.69",
  	safari: "12.1",
  	samsung: "7.0"
  },
  	"es.string.trim-end": {
  	android: "66",
  	bun: "0.1.1",
  	chrome: "66",
  	"chrome-android": "66",
  	deno: "1.0",
  	edge: "79",
  	electron: "3.0",
  	firefox: "61",
  	"firefox-android": "61",
  	hermes: "0.3",
  	ios: "12.2",
  	node: "10.0",
  	oculus: "5.0",
  	opera: "53",
  	"opera-android": "47",
  	opera_mobile: "47",
  	quest: "5.0",
  	"react-native": "0.69",
  	safari: "12.1",
  	samsung: "9.0"
  },
  	"es.string.trim-start": {
  	android: "66",
  	bun: "0.1.1",
  	chrome: "66",
  	"chrome-android": "66",
  	deno: "1.0",
  	edge: "79",
  	electron: "3.0",
  	firefox: "61",
  	"firefox-android": "61",
  	hermes: "0.3",
  	ios: "12.0",
  	node: "10.0",
  	oculus: "5.0",
  	opera: "53",
  	"opera-android": "47",
  	opera_mobile: "47",
  	quest: "5.0",
  	"react-native": "0.69",
  	safari: "12.0",
  	samsung: "9.0"
  },
  	"es.string.anchor": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "17",
  	"firefox-android": "17",
  	ios: "6.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	phantom: "2.0",
  	quest: "3.0",
  	rhino: "1.7.14",
  	safari: "6.0",
  	samsung: "1.0"
  },
  	"es.string.big": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	ios: "2.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	rhino: "1.7.13",
  	safari: "3.1",
  	samsung: "1.0"
  },
  	"es.string.blink": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	ios: "2.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	rhino: "1.7.13",
  	safari: "3.1",
  	samsung: "1.0"
  },
  	"es.string.bold": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	ios: "2.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	rhino: "1.7.13",
  	safari: "3.1",
  	samsung: "1.0"
  },
  	"es.string.fixed": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	ios: "2.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	rhino: "1.7.13",
  	safari: "3.1",
  	samsung: "1.0"
  },
  	"es.string.fontcolor": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "17",
  	"firefox-android": "17",
  	ios: "6.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	phantom: "2.0",
  	quest: "3.0",
  	rhino: "1.7.14",
  	safari: "6.0",
  	samsung: "1.0"
  },
  	"es.string.fontsize": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "17",
  	"firefox-android": "17",
  	ios: "6.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	phantom: "2.0",
  	quest: "3.0",
  	rhino: "1.7.14",
  	safari: "6.0",
  	samsung: "1.0"
  },
  	"es.string.italics": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	ios: "2.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	rhino: "1.7.13",
  	safari: "3.1",
  	samsung: "1.0"
  },
  	"es.string.link": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "17",
  	"firefox-android": "17",
  	ios: "6.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	phantom: "2.0",
  	quest: "3.0",
  	rhino: "1.7.14",
  	safari: "6.0",
  	samsung: "1.0"
  },
  	"es.string.small": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	ios: "2.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	rhino: "1.7.13",
  	safari: "3.1",
  	samsung: "1.0"
  },
  	"es.string.strike": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	ios: "2.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	rhino: "1.7.13",
  	safari: "3.1",
  	samsung: "1.0"
  },
  	"es.string.sub": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	ios: "2.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	rhino: "1.7.13",
  	safari: "3.1",
  	samsung: "1.0"
  },
  	"es.string.sup": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "5",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "2",
  	"firefox-android": "4",
  	ios: "2.0",
  	node: "0.1.27",
  	oculus: "3.0",
  	opera: "10.50",
  	"opera-android": "10.50",
  	opera_mobile: "10.50",
  	phantom: "1.9",
  	quest: "3.0",
  	rhino: "1.7.13",
  	safari: "3.1",
  	samsung: "1.0"
  },
  	"es.typed-array.float32-array": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "14.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "14.0",
  	samsung: "6.0"
  },
  	"es.typed-array.float64-array": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "14.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "14.0",
  	samsung: "6.0"
  },
  	"es.typed-array.int8-array": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "14.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "14.0",
  	samsung: "6.0"
  },
  	"es.typed-array.int16-array": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "14.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "14.0",
  	samsung: "6.0"
  },
  	"es.typed-array.int32-array": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "14.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "14.0",
  	samsung: "6.0"
  },
  	"es.typed-array.uint8-array": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "14.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "14.0",
  	samsung: "6.0"
  },
  	"es.typed-array.uint8-clamped-array": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "14.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "14.0",
  	samsung: "6.0"
  },
  	"es.typed-array.uint16-array": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "14.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "14.0",
  	samsung: "6.0"
  },
  	"es.typed-array.uint32-array": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "14.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "14.0",
  	samsung: "6.0"
  },
  	"es.typed-array.at": {
  	android: "92",
  	bun: "0.1.1",
  	chrome: "92",
  	"chrome-android": "92",
  	deno: "1.12",
  	edge: "92",
  	electron: "14.0",
  	firefox: "90",
  	"firefox-android": "90",
  	hermes: "0.13",
  	ios: "15.4",
  	node: "16.6",
  	oculus: "17.0",
  	opera: "78",
  	"opera-android": "65",
  	opera_mobile: "65",
  	quest: "17.0",
  	"react-native": "0.71",
  	rhino: "1.7.15",
  	safari: "15.4",
  	samsung: "16.0"
  },
  	"es.typed-array.copy-within": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "34",
  	"firefox-android": "34",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.every": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "37",
  	"firefox-android": "37",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.fill": {
  	android: "58",
  	bun: "0.1.1",
  	chrome: "58",
  	"chrome-android": "58",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.7",
  	firefox: "55",
  	"firefox-android": "55",
  	hermes: "0.1",
  	ios: "14.5",
  	node: "8.0",
  	oculus: "4.0",
  	opera: "45",
  	"opera-android": "43",
  	opera_mobile: "43",
  	quest: "4.0",
  	"react-native": "0.69",
  	safari: "14.1",
  	samsung: "7.0"
  },
  	"es.typed-array.filter": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "38",
  	"firefox-android": "38",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.find": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "37",
  	"firefox-android": "37",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.find-index": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "37",
  	"firefox-android": "37",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.find-last": {
  	android: "97",
  	bun: "0.1.1",
  	chrome: "97",
  	"chrome-android": "97",
  	deno: "1.16",
  	edge: "97",
  	electron: "17.0",
  	firefox: "104",
  	"firefox-android": "104",
  	hermes: "0.11",
  	ios: "15.4",
  	node: "18.0",
  	oculus: "20.0",
  	opera: "83",
  	"opera-android": "68",
  	opera_mobile: "68",
  	quest: "20.0",
  	"react-native": "0.69",
  	safari: "15.4",
  	samsung: "18.0"
  },
  	"es.typed-array.find-last-index": {
  	android: "97",
  	bun: "0.1.1",
  	chrome: "97",
  	"chrome-android": "97",
  	deno: "1.16",
  	edge: "97",
  	electron: "17.0",
  	firefox: "104",
  	"firefox-android": "104",
  	hermes: "0.11",
  	ios: "15.4",
  	node: "18.0",
  	oculus: "20.0",
  	opera: "83",
  	"opera-android": "68",
  	opera_mobile: "68",
  	quest: "20.0",
  	"react-native": "0.69",
  	safari: "15.4",
  	samsung: "18.0"
  },
  	"es.typed-array.for-each": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "38",
  	"firefox-android": "38",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.from": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "14.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "14.0",
  	samsung: "6.0"
  },
  	"es.typed-array.includes": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.0",
  	edge: "14",
  	electron: "0.37",
  	firefox: "43",
  	"firefox-android": "43",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.index-of": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "37",
  	"firefox-android": "37",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.iterator": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "13",
  	electron: "1.2",
  	firefox: "37",
  	"firefox-android": "37",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.join": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "37",
  	"firefox-android": "37",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.last-index-of": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "37",
  	"firefox-android": "37",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.map": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "38",
  	"firefox-android": "38",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.of": {
  	android: "54",
  	bun: "0.1.1",
  	chrome: "54",
  	"chrome-android": "54",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.4",
  	firefox: "55",
  	"firefox-android": "55",
  	ios: "14.0",
  	node: "7.0",
  	oculus: "3.0",
  	opera: "41",
  	"opera-android": "41",
  	opera_mobile: "41",
  	quest: "3.0",
  	safari: "14.0",
  	samsung: "6.0"
  },
  	"es.typed-array.reduce": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "37",
  	"firefox-android": "37",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.reduce-right": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "37",
  	"firefox-android": "37",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.reverse": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "37",
  	"firefox-android": "37",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.set": {
  	android: "95",
  	bun: "0.1.1",
  	chrome: "95",
  	"chrome-android": "95",
  	deno: "1.15",
  	edge: "95",
  	electron: "16.0",
  	firefox: "54",
  	"firefox-android": "54",
  	hermes: "0.1",
  	ios: "14.5",
  	node: "17.0",
  	oculus: "18.0",
  	opera: "81",
  	"opera-android": "67",
  	opera_mobile: "67",
  	quest: "18.0",
  	"react-native": "0.69",
  	safari: "14.1",
  	samsung: "17.0"
  },
  	"es.typed-array.slice": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "38",
  	"firefox-android": "38",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.some": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.31",
  	firefox: "37",
  	"firefox-android": "37",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.sort": {
  	android: "74",
  	bun: "0.1.1",
  	chrome: "74",
  	"chrome-android": "74",
  	deno: "1.0",
  	edge: "79",
  	electron: "6.0",
  	firefox: "67",
  	"firefox-android": "67",
  	hermes: "0.10",
  	ios: "14.5",
  	node: "12.0",
  	oculus: "6.0",
  	opera: "61",
  	"opera-android": "53",
  	opera_mobile: "53",
  	quest: "6.0",
  	"react-native": "0.69",
  	safari: "14.1",
  	samsung: "11.0"
  },
  	"es.typed-array.subarray": {
  	android: "4.4",
  	bun: "0.1.1",
  	chrome: "26",
  	"chrome-android": "26",
  	deno: "1.0",
  	edge: "13",
  	electron: "0.20",
  	firefox: "15",
  	"firefox-android": "15",
  	hermes: "0.1",
  	ios: "8.0",
  	node: "0.11.0",
  	oculus: "3.0",
  	opera: "15",
  	"opera-android": "15",
  	opera_mobile: "15",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "7.1",
  	samsung: "1.5"
  },
  	"es.typed-array.to-locale-string": {
  	android: "45",
  	bun: "0.1.1",
  	chrome: "45",
  	"chrome-android": "45",
  	deno: "1.0",
  	edge: "79",
  	electron: "0.31",
  	firefox: "51",
  	"firefox-android": "51",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "4.0",
  	oculus: "3.0",
  	opera: "32",
  	"opera-android": "32",
  	opera_mobile: "32",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.to-reversed": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"es.typed-array.to-sorted": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"es.typed-array.to-string": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "13",
  	electron: "1.2",
  	firefox: "51",
  	"firefox-android": "51",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.69",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.typed-array.with": {
  	android: "110",
  	bun: "0.1.9",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "16.4",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	safari: "16.4",
  	samsung: "21.0"
  },
  	"es.unescape": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "1",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "1",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "3",
  	ios: "1.0",
  	node: "0.0.3",
  	oculus: "3.0",
  	opera: "3",
  	"opera-android": "3",
  	opera_mobile: "3",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "1",
  	samsung: "1.0"
  },
  	"es.weak-map": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "79",
  	electron: "1.2",
  	firefox: "53",
  	"firefox-android": "53",
  	hermes: "0.13",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.73",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"es.weak-set": {
  	android: "51",
  	bun: "0.1.1",
  	chrome: "51",
  	"chrome-android": "51",
  	deno: "1.0",
  	edge: "15",
  	electron: "1.2",
  	firefox: "53",
  	"firefox-android": "53",
  	hermes: "0.13",
  	ios: "10.0",
  	node: "6.5",
  	oculus: "3.0",
  	opera: "38",
  	"opera-android": "38",
  	opera_mobile: "38",
  	quest: "3.0",
  	"react-native": "0.73",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "5.0"
  },
  	"esnext.aggregate-error": {
  	android: "85",
  	bun: "0.1.1",
  	chrome: "85",
  	"chrome-android": "85",
  	deno: "1.2",
  	edge: "85",
  	electron: "10.0",
  	firefox: "79",
  	"firefox-android": "79",
  	hermes: "0.13",
  	ios: "14.0",
  	node: "15.0",
  	oculus: "12.0",
  	opera: "71",
  	"opera-android": "60",
  	opera_mobile: "60",
  	quest: "12.0",
  	"react-native": "0.72",
  	safari: "14.0",
  	samsung: "14.0"
  },
  	"esnext.suppressed-error.constructor": {
  },
  	"esnext.array.from-async": {
  	android: "121",
  	bun: "1.1.2",
  	chrome: "121",
  	"chrome-android": "121",
  	deno: "1.38",
  	edge: "121",
  	electron: "29.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "107",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	safari: "18.0",
  	samsung: "25.0"
  },
  	"esnext.array.at": {
  	android: "92",
  	bun: "0.1.1",
  	chrome: "92",
  	"chrome-android": "92",
  	deno: "1.12",
  	edge: "92",
  	electron: "14.0",
  	firefox: "90",
  	"firefox-android": "90",
  	hermes: "0.13",
  	ios: "15.4",
  	node: "16.6",
  	oculus: "17.0",
  	opera: "78",
  	"opera-android": "65",
  	opera_mobile: "65",
  	quest: "17.0",
  	"react-native": "0.71",
  	rhino: "1.7.15",
  	safari: "15.4",
  	samsung: "16.0"
  },
  	"esnext.array.filter-out": {
  },
  	"esnext.array.filter-reject": {
  },
  	"esnext.array.find-last": {
  	android: "97",
  	bun: "0.1.1",
  	chrome: "97",
  	"chrome-android": "97",
  	deno: "1.16",
  	edge: "97",
  	electron: "17.0",
  	firefox: "104",
  	"firefox-android": "104",
  	hermes: "0.11",
  	ios: "15.4",
  	node: "18.0",
  	oculus: "20.0",
  	opera: "83",
  	"opera-android": "68",
  	opera_mobile: "68",
  	quest: "20.0",
  	"react-native": "0.69",
  	safari: "15.4",
  	samsung: "18.0"
  },
  	"esnext.array.find-last-index": {
  	android: "97",
  	bun: "0.1.1",
  	chrome: "97",
  	"chrome-android": "97",
  	deno: "1.16",
  	edge: "97",
  	electron: "17.0",
  	firefox: "104",
  	"firefox-android": "104",
  	hermes: "0.11",
  	ios: "15.4",
  	node: "18.0",
  	oculus: "20.0",
  	opera: "83",
  	"opera-android": "68",
  	opera_mobile: "68",
  	quest: "20.0",
  	"react-native": "0.69",
  	safari: "15.4",
  	samsung: "18.0"
  },
  	"esnext.array.group": {
  },
  	"esnext.array.group-by": {
  },
  	"esnext.array.group-by-to-map": {
  },
  	"esnext.array.group-to-map": {
  },
  	"esnext.array.is-template-object": {
  },
  	"esnext.array.last-index": {
  },
  	"esnext.array.last-item": {
  },
  	"esnext.array.to-reversed": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	hermes: "0.13",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	"react-native": "0.74",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"esnext.array.to-sorted": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"esnext.array.to-spliced": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	hermes: "0.13",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	"react-native": "0.74",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"esnext.array.unique-by": {
  },
  	"esnext.array.with": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	hermes: "0.13",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	"react-native": "0.74",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"esnext.array-buffer.detached": {
  	android: "114",
  	bun: "1.0.19",
  	chrome: "114",
  	"chrome-android": "114",
  	deno: "1.33",
  	edge: "114",
  	electron: "25.0",
  	firefox: "122",
  	"firefox-android": "122",
  	ios: "17.4",
  	node: "21.0",
  	oculus: "28.0",
  	opera: "100",
  	"opera-android": "76",
  	opera_mobile: "76",
  	quest: "28.0",
  	safari: "17.4",
  	samsung: "23.0"
  },
  	"esnext.array-buffer.transfer": {
  	android: "114",
  	bun: "1.0.19",
  	chrome: "114",
  	"chrome-android": "114",
  	deno: "1.33",
  	edge: "114",
  	electron: "25.0",
  	firefox: "122",
  	"firefox-android": "122",
  	ios: "17.4",
  	node: "21.0",
  	oculus: "28.0",
  	opera: "100",
  	"opera-android": "76",
  	opera_mobile: "76",
  	quest: "28.0",
  	safari: "17.4",
  	samsung: "23.0"
  },
  	"esnext.array-buffer.transfer-to-fixed-length": {
  	android: "114",
  	bun: "1.0.19",
  	chrome: "114",
  	"chrome-android": "114",
  	deno: "1.33",
  	edge: "114",
  	electron: "25.0",
  	firefox: "122",
  	"firefox-android": "122",
  	ios: "17.4",
  	node: "21.0",
  	oculus: "28.0",
  	opera: "100",
  	"opera-android": "76",
  	opera_mobile: "76",
  	quest: "28.0",
  	safari: "17.4",
  	samsung: "23.0"
  },
  	"esnext.async-disposable-stack.constructor": {
  },
  	"esnext.async-iterator.constructor": {
  },
  	"esnext.async-iterator.as-indexed-pairs": {
  },
  	"esnext.async-iterator.async-dispose": {
  },
  	"esnext.async-iterator.drop": {
  },
  	"esnext.async-iterator.every": {
  },
  	"esnext.async-iterator.filter": {
  },
  	"esnext.async-iterator.find": {
  },
  	"esnext.async-iterator.flat-map": {
  },
  	"esnext.async-iterator.for-each": {
  },
  	"esnext.async-iterator.from": {
  },
  	"esnext.async-iterator.indexed": {
  },
  	"esnext.async-iterator.map": {
  },
  	"esnext.async-iterator.reduce": {
  },
  	"esnext.async-iterator.some": {
  },
  	"esnext.async-iterator.take": {
  },
  	"esnext.async-iterator.to-array": {
  },
  	"esnext.bigint.range": {
  },
  	"esnext.composite-key": {
  },
  	"esnext.composite-symbol": {
  },
  	"esnext.data-view.get-float16": {
  	bun: "1.1.23",
  	deno: "1.43",
  	firefox: "129",
  	"firefox-android": "129"
  },
  	"esnext.data-view.get-uint8-clamped": {
  },
  	"esnext.data-view.set-float16": {
  	bun: "1.1.23",
  	deno: "1.43",
  	firefox: "129",
  	"firefox-android": "129"
  },
  	"esnext.data-view.set-uint8-clamped": {
  },
  	"esnext.disposable-stack.constructor": {
  },
  	"esnext.function.demethodize": {
  },
  	"esnext.function.is-callable": {
  },
  	"esnext.function.is-constructor": {
  },
  	"esnext.function.metadata": {
  },
  	"esnext.function.un-this": {
  },
  	"esnext.global-this": {
  	android: "71",
  	bun: "0.1.1",
  	chrome: "71",
  	"chrome-android": "71",
  	deno: "1.0",
  	edge: "79",
  	electron: "5.0",
  	firefox: "65",
  	"firefox-android": "65",
  	hermes: "0.2",
  	ios: "12.2",
  	node: "12.0",
  	oculus: "6.0",
  	opera: "58",
  	"opera-android": "50",
  	opera_mobile: "50",
  	quest: "6.0",
  	"react-native": "0.69",
  	rhino: "1.7.14",
  	safari: "12.1",
  	samsung: "10.0"
  },
  	"esnext.iterator.constructor": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.as-indexed-pairs": {
  },
  	"esnext.iterator.dispose": {
  },
  	"esnext.iterator.drop": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.every": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.filter": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.find": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.flat-map": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.for-each": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.from": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.indexed": {
  },
  	"esnext.iterator.map": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.range": {
  },
  	"esnext.iterator.reduce": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.some": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.take": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.to-array": {
  	android: "122",
  	chrome: "122",
  	"chrome-android": "122",
  	deno: "1.37",
  	edge: "122",
  	electron: "29.0",
  	firefox: "131",
  	"firefox-android": "131",
  	node: "22.0",
  	oculus: "32.0",
  	opera: "108",
  	"opera-android": "81",
  	opera_mobile: "81",
  	quest: "32.0",
  	samsung: "26.0"
  },
  	"esnext.iterator.to-async": {
  },
  	"esnext.json.is-raw-json": {
  	android: "114",
  	chrome: "114",
  	"chrome-android": "114",
  	deno: "1.33",
  	edge: "114",
  	electron: "25.0",
  	node: "21.0",
  	oculus: "28.0",
  	opera: "100",
  	"opera-android": "76",
  	opera_mobile: "76",
  	quest: "28.0",
  	samsung: "23.0"
  },
  	"esnext.json.parse": {
  	android: "114",
  	chrome: "114",
  	"chrome-android": "114",
  	deno: "1.33",
  	edge: "114",
  	electron: "25.0",
  	node: "21.0",
  	oculus: "28.0",
  	opera: "100",
  	"opera-android": "76",
  	opera_mobile: "76",
  	quest: "28.0",
  	samsung: "23.0"
  },
  	"esnext.json.raw-json": {
  	android: "114",
  	chrome: "114",
  	"chrome-android": "114",
  	deno: "1.33",
  	edge: "114",
  	electron: "25.0",
  	node: "21.0",
  	oculus: "28.0",
  	opera: "100",
  	"opera-android": "76",
  	opera_mobile: "76",
  	quest: "28.0",
  	samsung: "23.0"
  },
  	"esnext.map.delete-all": {
  },
  	"esnext.map.emplace": {
  },
  	"esnext.map.every": {
  },
  	"esnext.map.filter": {
  },
  	"esnext.map.find": {
  },
  	"esnext.map.find-key": {
  },
  	"esnext.map.from": {
  },
  	"esnext.map.group-by": {
  	android: "117",
  	bun: "1.1.2",
  	chrome: "117",
  	"chrome-android": "117",
  	deno: "1.37",
  	edge: "117",
  	electron: "27.0",
  	firefox: "119",
  	"firefox-android": "119",
  	ios: "18.0",
  	node: "21.0",
  	oculus: "30.0",
  	opera: "103",
  	"opera-android": "78",
  	opera_mobile: "78",
  	quest: "30.0",
  	safari: "18.0",
  	samsung: "24.0"
  },
  	"esnext.map.includes": {
  },
  	"esnext.map.key-by": {
  },
  	"esnext.map.key-of": {
  },
  	"esnext.map.map-keys": {
  },
  	"esnext.map.map-values": {
  },
  	"esnext.map.merge": {
  },
  	"esnext.map.of": {
  },
  	"esnext.map.reduce": {
  },
  	"esnext.map.some": {
  },
  	"esnext.map.update": {
  },
  	"esnext.map.update-or-insert": {
  },
  	"esnext.map.upsert": {
  },
  	"esnext.math.clamp": {
  },
  	"esnext.math.deg-per-rad": {
  },
  	"esnext.math.degrees": {
  },
  	"esnext.math.fscale": {
  },
  	"esnext.math.f16round": {
  	bun: "1.1.23",
  	deno: "1.43",
  	firefox: "129",
  	"firefox-android": "129"
  },
  	"esnext.math.iaddh": {
  },
  	"esnext.math.imulh": {
  },
  	"esnext.math.isubh": {
  },
  	"esnext.math.rad-per-deg": {
  },
  	"esnext.math.radians": {
  },
  	"esnext.math.scale": {
  },
  	"esnext.math.seeded-prng": {
  },
  	"esnext.math.signbit": {
  },
  	"esnext.math.sum-precise": {
  },
  	"esnext.math.umulh": {
  },
  	"esnext.number.from-string": {
  },
  	"esnext.number.range": {
  },
  	"esnext.object.has-own": {
  	android: "93",
  	bun: "0.1.1",
  	chrome: "93",
  	"chrome-android": "93",
  	deno: "1.13",
  	edge: "93",
  	electron: "14.0",
  	firefox: "92",
  	"firefox-android": "92",
  	hermes: "0.10",
  	ios: "15.4",
  	node: "16.9",
  	oculus: "17.0",
  	opera: "79",
  	"opera-android": "66",
  	opera_mobile: "66",
  	quest: "17.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "15.4",
  	samsung: "17.0"
  },
  	"esnext.object.iterate-entries": {
  },
  	"esnext.object.iterate-keys": {
  },
  	"esnext.object.iterate-values": {
  },
  	"esnext.object.group-by": {
  	android: "117",
  	bun: "1.1.2",
  	chrome: "117",
  	"chrome-android": "117",
  	deno: "1.37",
  	edge: "117",
  	electron: "27.0",
  	firefox: "119",
  	"firefox-android": "119",
  	ios: "18.0",
  	node: "21.0",
  	oculus: "30.0",
  	opera: "103",
  	"opera-android": "78",
  	opera_mobile: "78",
  	quest: "30.0",
  	safari: "18.0",
  	samsung: "24.0"
  },
  	"esnext.observable": {
  },
  	"esnext.promise.all-settled": {
  	android: "76",
  	bun: "0.1.1",
  	chrome: "76",
  	"chrome-android": "76",
  	deno: "1.24",
  	edge: "79",
  	electron: "6.0",
  	firefox: "71",
  	"firefox-android": "71",
  	ios: "13.0",
  	node: "12.9",
  	oculus: "7.0",
  	opera: "63",
  	"opera-android": "54",
  	opera_mobile: "54",
  	quest: "7.0",
  	rhino: "1.7.15",
  	safari: "13",
  	samsung: "12.0"
  },
  	"esnext.promise.any": {
  	android: "85",
  	bun: "0.1.1",
  	chrome: "85",
  	"chrome-android": "85",
  	deno: "1.24",
  	edge: "85",
  	electron: "10.0",
  	firefox: "79",
  	"firefox-android": "79",
  	ios: "14.0",
  	node: "15.0",
  	oculus: "12.0",
  	opera: "71",
  	"opera-android": "60",
  	opera_mobile: "60",
  	quest: "12.0",
  	safari: "14.0",
  	samsung: "14.0"
  },
  	"esnext.promise.try": {
  	android: "128",
  	bun: "1.1.22",
  	chrome: "128",
  	"chrome-android": "128",
  	edge: "128",
  	electron: "32.0",
  	opera: "114"
  },
  	"esnext.promise.with-resolvers": {
  	android: "119",
  	bun: "0.7.1",
  	chrome: "119",
  	"chrome-android": "119",
  	deno: "1.38",
  	edge: "119",
  	electron: "28.0",
  	firefox: "121",
  	"firefox-android": "121",
  	ios: "17.4",
  	node: "22.0",
  	oculus: "31.0",
  	opera: "105",
  	"opera-android": "79",
  	opera_mobile: "79",
  	quest: "31.0",
  	safari: "17.4",
  	samsung: "25.0"
  },
  	"esnext.reflect.define-metadata": {
  },
  	"esnext.reflect.delete-metadata": {
  },
  	"esnext.reflect.get-metadata": {
  },
  	"esnext.reflect.get-metadata-keys": {
  },
  	"esnext.reflect.get-own-metadata": {
  },
  	"esnext.reflect.get-own-metadata-keys": {
  },
  	"esnext.reflect.has-metadata": {
  },
  	"esnext.reflect.has-own-metadata": {
  },
  	"esnext.reflect.metadata": {
  },
  	"esnext.regexp.escape": {
  	bun: "1.1.22"
  },
  	"esnext.set.add-all": {
  },
  	"esnext.set.delete-all": {
  },
  	"esnext.set.difference.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"esnext.set.difference": {
  },
  	"esnext.set.every": {
  },
  	"esnext.set.filter": {
  },
  	"esnext.set.find": {
  },
  	"esnext.set.from": {
  },
  	"esnext.set.intersection.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"esnext.set.intersection": {
  },
  	"esnext.set.is-disjoint-from.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"esnext.set.is-disjoint-from": {
  },
  	"esnext.set.is-subset-of.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"esnext.set.is-subset-of": {
  },
  	"esnext.set.is-superset-of.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"esnext.set.is-superset-of": {
  },
  	"esnext.set.join": {
  },
  	"esnext.set.map": {
  },
  	"esnext.set.of": {
  },
  	"esnext.set.reduce": {
  },
  	"esnext.set.some": {
  },
  	"esnext.set.symmetric-difference.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"esnext.set.symmetric-difference": {
  },
  	"esnext.set.union.v2": {
  	android: "123",
  	bun: "1.1.1",
  	chrome: "123",
  	"chrome-android": "123",
  	deno: "1.41.3",
  	edge: "123",
  	electron: "30.0",
  	firefox: "127",
  	"firefox-android": "127",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "33.0",
  	opera: "109",
  	"opera-android": "82",
  	opera_mobile: "82",
  	quest: "33.0",
  	safari: "18.0",
  	samsung: "27.0"
  },
  	"esnext.set.union": {
  },
  	"esnext.string.at": {
  },
  	"esnext.string.cooked": {
  },
  	"esnext.string.code-points": {
  },
  	"esnext.string.dedent": {
  },
  	"esnext.string.is-well-formed": {
  	android: "111",
  	bun: "0.4.0",
  	chrome: "111",
  	"chrome-android": "111",
  	deno: "1.32",
  	edge: "111",
  	electron: "24.0",
  	firefox: "119",
  	"firefox-android": "119",
  	ios: "16.4",
  	node: "20.0",
  	oculus: "27.0",
  	opera: "97",
  	"opera-android": "75",
  	opera_mobile: "75",
  	quest: "27.0",
  	safari: "16.4",
  	samsung: "22.0"
  },
  	"esnext.string.match-all": {
  	android: "80",
  	bun: "0.1.1",
  	chrome: "80",
  	"chrome-android": "80",
  	deno: "1.0",
  	edge: "80",
  	electron: "8.0",
  	firefox: "73",
  	"firefox-android": "73",
  	hermes: "0.6",
  	ios: "13.4",
  	node: "14.0",
  	oculus: "9.0",
  	opera: "67",
  	"opera-android": "57",
  	opera_mobile: "57",
  	quest: "9.0",
  	"react-native": "0.69",
  	safari: "13.1",
  	samsung: "13.0"
  },
  	"esnext.string.replace-all": {
  	android: "85",
  	bun: "0.1.1",
  	chrome: "85",
  	"chrome-android": "85",
  	deno: "1.2",
  	edge: "85",
  	electron: "10.0",
  	firefox: "77",
  	"firefox-android": "77",
  	hermes: "0.7",
  	ios: "13.4",
  	node: "15.0",
  	oculus: "12.0",
  	opera: "71",
  	"opera-android": "60",
  	opera_mobile: "60",
  	quest: "12.0",
  	"react-native": "0.69",
  	rhino: "1.7.15",
  	safari: "13.1",
  	samsung: "14.0"
  },
  	"esnext.string.to-well-formed": {
  	android: "111",
  	bun: "0.5.7",
  	chrome: "111",
  	"chrome-android": "111",
  	deno: "1.32",
  	edge: "111",
  	electron: "24.0",
  	firefox: "119",
  	"firefox-android": "119",
  	ios: "16.4",
  	node: "20.0",
  	oculus: "27.0",
  	opera: "97",
  	"opera-android": "75",
  	opera_mobile: "75",
  	quest: "27.0",
  	safari: "16.4",
  	samsung: "22.0"
  },
  	"esnext.symbol.async-dispose": {
  	android: "127",
  	bun: "1.0.23",
  	chrome: "127",
  	"chrome-android": "127",
  	deno: "1.38",
  	edge: "127",
  	electron: "32.0",
  	node: "20.5.0",
  	opera: "113",
  	"opera-android": "84",
  	opera_mobile: "84"
  },
  	"esnext.symbol.custom-matcher": {
  },
  	"esnext.symbol.dispose": {
  	android: "125",
  	bun: "1.0.23",
  	chrome: "125",
  	"chrome-android": "125",
  	deno: "1.38",
  	edge: "125",
  	electron: "31.0",
  	node: "20.5.0",
  	oculus: "34.0",
  	opera: "111",
  	"opera-android": "83",
  	opera_mobile: "83",
  	quest: "34.0",
  	samsung: "27.0"
  },
  	"esnext.symbol.is-registered-symbol": {
  },
  	"esnext.symbol.is-registered": {
  },
  	"esnext.symbol.is-well-known-symbol": {
  },
  	"esnext.symbol.is-well-known": {
  },
  	"esnext.symbol.matcher": {
  },
  	"esnext.symbol.metadata": {
  	deno: "1.40.4"
  },
  	"esnext.symbol.metadata-key": {
  },
  	"esnext.symbol.observable": {
  },
  	"esnext.symbol.pattern-match": {
  },
  	"esnext.symbol.replace-all": {
  },
  	"esnext.typed-array.from-async": {
  },
  	"esnext.typed-array.at": {
  	android: "92",
  	bun: "0.1.1",
  	chrome: "92",
  	"chrome-android": "92",
  	deno: "1.12",
  	edge: "92",
  	electron: "14.0",
  	firefox: "90",
  	"firefox-android": "90",
  	hermes: "0.13",
  	ios: "15.4",
  	node: "16.6",
  	oculus: "17.0",
  	opera: "78",
  	"opera-android": "65",
  	opera_mobile: "65",
  	quest: "17.0",
  	"react-native": "0.71",
  	rhino: "1.7.15",
  	safari: "15.4",
  	samsung: "16.0"
  },
  	"esnext.typed-array.filter-out": {
  },
  	"esnext.typed-array.filter-reject": {
  },
  	"esnext.typed-array.find-last": {
  	android: "97",
  	bun: "0.1.1",
  	chrome: "97",
  	"chrome-android": "97",
  	deno: "1.16",
  	edge: "97",
  	electron: "17.0",
  	firefox: "104",
  	"firefox-android": "104",
  	hermes: "0.11",
  	ios: "15.4",
  	node: "18.0",
  	oculus: "20.0",
  	opera: "83",
  	"opera-android": "68",
  	opera_mobile: "68",
  	quest: "20.0",
  	"react-native": "0.69",
  	safari: "15.4",
  	samsung: "18.0"
  },
  	"esnext.typed-array.find-last-index": {
  	android: "97",
  	bun: "0.1.1",
  	chrome: "97",
  	"chrome-android": "97",
  	deno: "1.16",
  	edge: "97",
  	electron: "17.0",
  	firefox: "104",
  	"firefox-android": "104",
  	hermes: "0.11",
  	ios: "15.4",
  	node: "18.0",
  	oculus: "20.0",
  	opera: "83",
  	"opera-android": "68",
  	opera_mobile: "68",
  	quest: "20.0",
  	"react-native": "0.69",
  	safari: "15.4",
  	samsung: "18.0"
  },
  	"esnext.typed-array.group-by": {
  },
  	"esnext.typed-array.to-reversed": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"esnext.typed-array.to-sorted": {
  	android: "110",
  	bun: "0.1.1",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "16.0",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	safari: "16.0",
  	samsung: "21.0"
  },
  	"esnext.typed-array.to-spliced": {
  },
  	"esnext.typed-array.unique-by": {
  },
  	"esnext.typed-array.with": {
  	android: "110",
  	bun: "0.1.9",
  	chrome: "110",
  	"chrome-android": "110",
  	deno: "1.27",
  	edge: "110",
  	electron: "23.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "16.4",
  	node: "20.0",
  	oculus: "26.0",
  	opera: "96",
  	"opera-android": "74",
  	opera_mobile: "74",
  	quest: "26.0",
  	safari: "16.4",
  	samsung: "21.0"
  },
  	"esnext.uint8-array.from-base64": {
  	bun: "1.1.22"
  },
  	"esnext.uint8-array.from-hex": {
  	bun: "1.1.22"
  },
  	"esnext.uint8-array.set-from-base64": {
  	bun: "1.1.22"
  },
  	"esnext.uint8-array.set-from-hex": {
  	bun: "1.1.22"
  },
  	"esnext.uint8-array.to-base64": {
  	bun: "1.1.22"
  },
  	"esnext.uint8-array.to-hex": {
  	bun: "1.1.22"
  },
  	"esnext.weak-map.delete-all": {
  },
  	"esnext.weak-map.from": {
  },
  	"esnext.weak-map.of": {
  },
  	"esnext.weak-map.emplace": {
  },
  	"esnext.weak-map.upsert": {
  },
  	"esnext.weak-set.add-all": {
  },
  	"esnext.weak-set.delete-all": {
  },
  	"esnext.weak-set.from": {
  },
  	"esnext.weak-set.of": {
  },
  	"web.atob": {
  	android: "37",
  	bun: "0.1.1",
  	chrome: "34",
  	"chrome-android": "34",
  	deno: "1.0",
  	edge: "16",
  	electron: "0.20",
  	firefox: "27",
  	"firefox-android": "27",
  	hermes: "0.13",
  	ios: "10.3",
  	node: "18.0",
  	oculus: "3.0",
  	opera: "10.5",
  	"opera-android": "10.5",
  	opera_mobile: "10.5",
  	quest: "3.0",
  	"react-native": "0.74",
  	safari: "10.1",
  	samsung: "2.0"
  },
  	"web.btoa": {
  	android: "3.0",
  	bun: "0.1.1",
  	chrome: "4",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "16",
  	electron: "0.20",
  	firefox: "27",
  	"firefox-android": "27",
  	ios: "1.0",
  	node: "17.5",
  	oculus: "3.0",
  	opera: "10.5",
  	"opera-android": "10.5",
  	opera_mobile: "10.5",
  	phantom: "1.9",
  	quest: "3.0",
  	safari: "3.0",
  	samsung: "1.0"
  },
  	"web.dom-collections.for-each": {
  	android: "58",
  	bun: "0.1.1",
  	chrome: "58",
  	"chrome-android": "58",
  	deno: "1.0",
  	edge: "16",
  	electron: "1.7",
  	firefox: "50",
  	"firefox-android": "50",
  	hermes: "0.1",
  	ios: "10.0",
  	node: "0.0.1",
  	oculus: "4.0",
  	opera: "45",
  	"opera-android": "43",
  	opera_mobile: "43",
  	quest: "4.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "10.0",
  	samsung: "7.0"
  },
  	"web.dom-collections.iterator": {
  	android: "66",
  	bun: "0.1.1",
  	chrome: "66",
  	"chrome-android": "66",
  	deno: "1.0",
  	edge: "79",
  	electron: "3.0",
  	firefox: "60",
  	"firefox-android": "60",
  	hermes: "0.1",
  	ios: "13.4",
  	node: "0.0.1",
  	oculus: "5.0",
  	opera: "53",
  	"opera-android": "47",
  	opera_mobile: "47",
  	quest: "5.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "13.1",
  	samsung: "9.0"
  },
  	"web.dom-exception.constructor": {
  	android: "46",
  	bun: "0.1.1",
  	chrome: "46",
  	"chrome-android": "46",
  	deno: "1.7",
  	edge: "79",
  	electron: "0.36",
  	firefox: "37",
  	"firefox-android": "37",
  	ios: "11.3",
  	node: "17.0",
  	oculus: "3.0",
  	opera: "33",
  	"opera-android": "33",
  	opera_mobile: "33",
  	quest: "3.0",
  	safari: "11.1",
  	samsung: "5.0"
  },
  	"web.dom-exception.stack": {
  	deno: "1.15",
  	firefox: "37",
  	"firefox-android": "37",
  	node: "17.0"
  },
  	"web.dom-exception.to-string-tag": {
  	android: "49",
  	bun: "0.1.1",
  	chrome: "49",
  	"chrome-android": "49",
  	deno: "1.7",
  	edge: "79",
  	electron: "0.37",
  	firefox: "51",
  	"firefox-android": "51",
  	ios: "11.3",
  	node: "17.0",
  	oculus: "3.0",
  	opera: "36",
  	"opera-android": "36",
  	opera_mobile: "36",
  	quest: "3.0",
  	safari: "11.1",
  	samsung: "5.0"
  },
  	"web.immediate": {
  	bun: "0.4.0",
  	ie: "10",
  	node: "0.9.1"
  },
  	"web.queue-microtask": {
  	android: "71",
  	chrome: "71",
  	"chrome-android": "71",
  	deno: "1.0",
  	edge: "79",
  	electron: "5.0",
  	firefox: "69",
  	"firefox-android": "69",
  	ios: "12.2",
  	node: "12.0",
  	oculus: "6.0",
  	opera: "58",
  	"opera-android": "50",
  	opera_mobile: "50",
  	quest: "6.0",
  	safari: "12.1",
  	samsung: "10.0"
  },
  	"web.self": {
  	android: "86",
  	bun: "1.0.22",
  	chrome: "86",
  	"chrome-android": "86",
  	edge: "86",
  	electron: "11.0",
  	firefox: "31",
  	"firefox-android": "31",
  	ios: "10.0",
  	oculus: "12.0",
  	opera: "72",
  	"opera-android": "61",
  	opera_mobile: "61",
  	quest: "12.0",
  	safari: "10",
  	samsung: "14.0"
  },
  	"web.structured-clone": {
  },
  	"web.timers": {
  	android: "1.5",
  	bun: "0.4.0",
  	chrome: "1",
  	"chrome-android": "18",
  	deno: "1.0",
  	edge: "12",
  	electron: "0.20",
  	firefox: "1",
  	"firefox-android": "4",
  	hermes: "0.1",
  	ie: "10",
  	ios: "1.0",
  	node: "0.0.1",
  	oculus: "3.0",
  	opera: "7",
  	"opera-android": "7",
  	opera_mobile: "7",
  	phantom: "1.9",
  	quest: "3.0",
  	"react-native": "0.69",
  	rhino: "1.7.13",
  	safari: "1.0",
  	samsung: "1.0"
  },
  	"web.url": {
  	android: "67",
  	bun: "0.1.1",
  	chrome: "67",
  	"chrome-android": "67",
  	deno: "1.0",
  	edge: "79",
  	electron: "4.0",
  	firefox: "57",
  	"firefox-android": "57",
  	ios: "14.0",
  	node: "10.0",
  	oculus: "6.0",
  	opera: "54",
  	"opera-android": "48",
  	opera_mobile: "48",
  	quest: "6.0",
  	safari: "14.0",
  	samsung: "9.0"
  },
  	"web.url.can-parse": {
  	android: "120",
  	bun: "1.1.0",
  	chrome: "120",
  	"chrome-android": "120",
  	deno: "1.33.2",
  	edge: "120",
  	electron: "28.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "17.0",
  	node: "20.1",
  	oculus: "31.0",
  	opera: "106",
  	"opera-android": "80",
  	opera_mobile: "80",
  	quest: "31.0",
  	safari: "17.0",
  	samsung: "25.0"
  },
  	"web.url.parse": {
  	android: "126",
  	bun: "1.1.4",
  	chrome: "126",
  	"chrome-android": "126",
  	deno: "1.43",
  	edge: "126",
  	electron: "31.0",
  	firefox: "126",
  	"firefox-android": "126",
  	ios: "18.0",
  	node: "22.0",
  	oculus: "34.0",
  	opera: "112",
  	"opera-android": "83",
  	opera_mobile: "83",
  	quest: "34.0",
  	safari: "18.0"
  },
  	"web.url.to-json": {
  	android: "71",
  	bun: "0.1.1",
  	chrome: "71",
  	"chrome-android": "71",
  	deno: "1.0",
  	edge: "79",
  	electron: "5.0",
  	firefox: "57",
  	"firefox-android": "57",
  	ios: "14.0",
  	node: "10.0",
  	oculus: "6.0",
  	opera: "58",
  	"opera-android": "50",
  	opera_mobile: "50",
  	quest: "6.0",
  	safari: "14.0",
  	samsung: "10.0"
  },
  	"web.url-search-params": {
  	android: "67",
  	bun: "0.1.1",
  	chrome: "67",
  	"chrome-android": "67",
  	deno: "1.0",
  	edge: "79",
  	electron: "4.0",
  	firefox: "57",
  	"firefox-android": "57",
  	ios: "14.0",
  	node: "10.0",
  	oculus: "6.0",
  	opera: "54",
  	"opera-android": "48",
  	opera_mobile: "48",
  	quest: "6.0",
  	safari: "14.0",
  	samsung: "9.0"
  },
  	"web.url-search-params.delete": {
  	android: "118",
  	bun: "1.0.31",
  	chrome: "118",
  	"chrome-android": "118",
  	deno: "1.35",
  	edge: "118",
  	electron: "27.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "17.0",
  	node: "20.2",
  	oculus: "30.0",
  	opera: "104",
  	"opera-android": "79",
  	opera_mobile: "79",
  	quest: "30.0",
  	safari: "17.0",
  	samsung: "25.0"
  },
  	"web.url-search-params.has": {
  	android: "118",
  	bun: "1.0.31",
  	chrome: "118",
  	"chrome-android": "118",
  	deno: "1.35",
  	edge: "118",
  	electron: "27.0",
  	firefox: "115",
  	"firefox-android": "115",
  	ios: "17.0",
  	node: "20.2",
  	oculus: "30.0",
  	opera: "104",
  	"opera-android": "79",
  	opera_mobile: "79",
  	quest: "30.0",
  	safari: "17.0",
  	samsung: "25.0"
  },
  	"web.url-search-params.size": {
  	android: "113",
  	bun: "1.0.2",
  	chrome: "113",
  	"chrome-android": "113",
  	deno: "1.32",
  	edge: "113",
  	electron: "25.0",
  	firefox: "112",
  	"firefox-android": "112",
  	ios: "17.0",
  	node: "19.8",
  	oculus: "28.0",
  	opera: "99",
  	"opera-android": "76",
  	opera_mobile: "76",
  	quest: "28.0",
  	safari: "17.0",
  	samsung: "23.0"
  }
  };

var data$1;
  var hasRequiredData;
  function requireData() {
    if (hasRequiredData) return data$1;
    hasRequiredData = 1;
    data$1 = require$$0$4;
    return data$1;
  }

var shippedProposals = {};

var hasRequiredShippedProposals;
  function requireShippedProposals() {
    if (hasRequiredShippedProposals) return shippedProposals;
    hasRequiredShippedProposals = 1;
    shippedProposals.__esModule = true;
    shippedProposals["default"] = void 0;
    var _default = new Set(["esnext.suppressed-error.constructor", "esnext.array.from-async", "esnext.array.group", "esnext.array.group-to-map", "esnext.data-view.get-float16", "esnext.data-view.set-float16", "esnext.iterator.constructor", "esnext.iterator.drop", "esnext.iterator.every", "esnext.iterator.filter", "esnext.iterator.find", "esnext.iterator.flat-map", "esnext.iterator.for-each", "esnext.iterator.from", "esnext.iterator.map", "esnext.iterator.reduce", "esnext.iterator.some", "esnext.iterator.take", "esnext.iterator.to-array", "esnext.json.is-raw-json", "esnext.json.parse", "esnext.json.raw-json", "esnext.math.f16round", "esnext.promise.try", "esnext.symbol.async-dispose", "esnext.symbol.dispose", "esnext.symbol.metadata"]);
    shippedProposals["default"] = _default;
    return shippedProposals;
  }

var require$$1$1 = {
  	"3.0": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.date.now",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string",
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name",
  	"es.json.to-string-tag",
  	"es.map",
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc",
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-fixed",
  	"es.number.to-precision",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.parse-float",
  	"es.parse-int",
  	"es.promise",
  	"es.promise.finally",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.regexp.constructor",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.to-string",
  	"es.set",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-string",
  	"es.weak-map",
  	"es.weak-set",
  	"esnext.aggregate-error",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.composite-key",
  	"esnext.composite-symbol",
  	"esnext.global-this",
  	"esnext.map.delete-all",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.umulh",
  	"esnext.number.from-string",
  	"esnext.observable",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.reflect.define-metadata",
  	"esnext.reflect.delete-metadata",
  	"esnext.reflect.get-metadata",
  	"esnext.reflect.get-metadata-keys",
  	"esnext.reflect.get-own-metadata",
  	"esnext.reflect.get-own-metadata-keys",
  	"esnext.reflect.has-metadata",
  	"esnext.reflect.has-own-metadata",
  	"esnext.reflect.metadata",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union",
  	"esnext.string.at",
  	"esnext.string.code-points",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.symbol.dispose",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator",
  	"web.immediate",
  	"web.queue-microtask",
  	"web.timers",
  	"web.url",
  	"web.url.to-json",
  	"web.url-search-params"
  ],
  	"3.1": [
  	"es.string.match-all",
  	"es.symbol.match-all",
  	"esnext.symbol.replace-all"
  ],
  	"3.2": [
  	"es.promise.all-settled",
  	"esnext.array.is-template-object",
  	"esnext.map.update-or-insert",
  	"esnext.symbol.async-dispose"
  ],
  	"3.3": [
  	"es.global-this",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.map",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.map.upsert",
  	"esnext.weak-map.upsert"
  ],
  	"3.4": [
  	"es.json.stringify"
  ],
  	"3.5": [
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values"
  ],
  	"3.6": [
  	"es.regexp.sticky",
  	"es.regexp.test"
  ],
  	"3.7": [
  	"es.aggregate-error",
  	"es.promise.any",
  	"es.reflect.to-string-tag",
  	"es.string.replace-all",
  	"esnext.map.emplace",
  	"esnext.weak-map.emplace"
  ],
  	"3.8": [
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.unique-by",
  	"esnext.bigint.range",
  	"esnext.number.range",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out"
  ],
  	"3.9": [
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.unique-by"
  ],
  	"3.11": [
  	"esnext.object.has-own"
  ],
  	"3.12": [
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata"
  ],
  	"3.15": [
  	"es.date.get-year",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.escape",
  	"es.regexp.dot-all",
  	"es.string.substr",
  	"es.unescape"
  ],
  	"3.16": [
  	"esnext.array.filter-reject",
  	"esnext.array.group-by",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.group-by"
  ],
  	"3.17": [
  	"es.array.at",
  	"es.object.has-own",
  	"es.string.at-alternative",
  	"es.typed-array.at"
  ],
  	"3.18": [
  	"esnext.array.from-async",
  	"esnext.typed-array.from-async"
  ],
  	"3.20": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.aggregate-error.cause",
  	"es.number.to-exponential",
  	"esnext.array.group-by-to-map",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.with",
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor",
  	"esnext.function.un-this",
  	"esnext.iterator.to-async",
  	"esnext.string.cooked",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.structured-clone"
  ],
  	"3.21": [
  	"web.atob",
  	"web.btoa"
  ],
  	"3.23": [
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.push",
  	"es.array.unshift",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-to-map",
  	"esnext.symbol.metadata-key"
  ],
  	"3.24": [
  	"esnext.async-iterator.indexed",
  	"esnext.iterator.indexed"
  ],
  	"3.25": [
  	"es.object.proto"
  ],
  	"3.26": [
  	"esnext.string.is-well-formed",
  	"esnext.string.to-well-formed",
  	"web.self"
  ],
  	"3.27": [
  	"esnext.suppressed-error.constructor",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.disposable-stack.constructor",
  	"esnext.iterator.dispose",
  	"esnext.set.difference.v2",
  	"esnext.set.intersection.v2",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.union.v2",
  	"esnext.string.dedent"
  ],
  	"3.28": [
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.with",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.function.demethodize",
  	"esnext.iterator.range",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known"
  ],
  	"3.29": [
  	"web.url-search-params.size"
  ],
  	"3.30": [
  	"web.url.can-parse"
  ],
  	"3.31": [
  	"es.string.is-well-formed",
  	"es.string.to-well-formed",
  	"esnext.function.metadata",
  	"esnext.object.group-by",
  	"esnext.promise.with-resolvers",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-well-known-symbol",
  	"web.url-search-params.delete",
  	"web.url-search-params.has"
  ],
  	"3.32": [
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped",
  	"esnext.math.f16round"
  ],
  	"3.33": [
  	"esnext.regexp.escape"
  ],
  	"3.34": [
  	"es.map.group-by",
  	"es.object.group-by",
  	"es.promise.with-resolvers",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"3.36": [
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length"
  ],
  	"3.37": [
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"esnext.math.sum-precise",
  	"esnext.symbol.custom-matcher",
  	"web.url.parse"
  ],
  	"3.38": [
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex"
  ]
  };

var require$$2 = [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.error.cause",
  	"es.error.to-string",
  	"es.aggregate-error",
  	"es.aggregate-error.cause",
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string",
  	"es.escape",
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name",
  	"es.global-this",
  	"es.json.stringify",
  	"es.json.to-string-tag",
  	"es.map",
  	"es.map.group-by",
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc",
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.parse-float",
  	"es.parse-int",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag",
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"es.unescape",
  	"es.weak-map",
  	"es.weak-set",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.bigint.range",
  	"esnext.composite-key",
  	"esnext.composite-symbol",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.demethodize",
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor",
  	"esnext.function.metadata",
  	"esnext.function.un-this",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.f16round",
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.sum-precise",
  	"esnext.math.umulh",
  	"esnext.number.from-string",
  	"esnext.number.range",
  	"esnext.object.has-own",
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values",
  	"esnext.object.group-by",
  	"esnext.observable",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.reflect.define-metadata",
  	"esnext.reflect.delete-metadata",
  	"esnext.reflect.get-metadata",
  	"esnext.reflect.get-metadata-keys",
  	"esnext.reflect.get-own-metadata",
  	"esnext.reflect.get-own-metadata-keys",
  	"esnext.reflect.has-metadata",
  	"esnext.reflect.has-own-metadata",
  	"esnext.reflect.metadata",
  	"esnext.regexp.escape",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"esnext.string.at",
  	"esnext.string.cooked",
  	"esnext.string.code-points",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.custom-matcher",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.symbol.replace-all",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of",
  	"web.atob",
  	"web.btoa",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.immediate",
  	"web.queue-microtask",
  	"web.self",
  	"web.structured-clone",
  	"web.timers",
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ];

var getModulesListForTargetVersion$1;
  var hasRequiredGetModulesListForTargetVersion;
  function requireGetModulesListForTargetVersion() {
    if (hasRequiredGetModulesListForTargetVersion) return getModulesListForTargetVersion$1;
    hasRequiredGetModulesListForTargetVersion = 1;
    getModulesListForTargetVersion$1 = getModulesListForTargetVersion$2;
    return getModulesListForTargetVersion$1;
  }

var builtInDefinitions$1 = {};

var hasRequiredBuiltInDefinitions$1;
  function requireBuiltInDefinitions$1() {
    var _InstanceProperties;
    if (hasRequiredBuiltInDefinitions$1) return builtInDefinitions$1;
    hasRequiredBuiltInDefinitions$1 = 1;
    builtInDefinitions$1.__esModule = true;
    builtInDefinitions$1.StaticProperties = builtInDefinitions$1.PromiseDependenciesWithIterators = builtInDefinitions$1.PromiseDependencies = builtInDefinitions$1.InstanceProperties = builtInDefinitions$1.DecoratorMetadataDependencies = builtInDefinitions$1.CommonIterators = builtInDefinitions$1.BuiltIns = void 0;
    var _data = _interopRequireDefault(requireData());
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    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);
    }
    var polyfillsOrder = {};
    Object.keys(_data["default"]).forEach(function (name, index) {
      polyfillsOrder[name] = index;
    });
    var define = function define(pure, global, name, exclude) {
      if (name === void 0) {
        name = global[0];
      }
      return {
        name: name,
        pure: pure,
        global: global.sort(function (a, b) {
          return polyfillsOrder[a] - polyfillsOrder[b];
        }),
        exclude: exclude
      };
    };
    var typed = function typed() {
      for (var _len = arguments.length, modules = new Array(_len), _key = 0; _key < _len; _key++) {
        modules[_key] = arguments[_key];
      }
      return define(null, [].concat(modules, TypedArrayDependencies));
    };
    var ArrayNatureIterators = ["es.array.iterator", "web.dom-collections.iterator"];
    var CommonIterators = ["es.string.iterator"].concat(ArrayNatureIterators);
    builtInDefinitions$1.CommonIterators = CommonIterators;
    var ArrayNatureIteratorsWithTag = ["es.object.to-string"].concat(ArrayNatureIterators);
    var CommonIteratorsWithTag = ["es.object.to-string"].concat(_toConsumableArray(CommonIterators));
    var ErrorDependencies = ["es.error.cause", "es.error.to-string"];
    var SuppressedErrorDependencies = ["esnext.suppressed-error.constructor"].concat(ErrorDependencies);
    var ArrayBufferDependencies = ["es.array-buffer.constructor", "es.array-buffer.slice", "es.data-view", "es.array-buffer.detached", "es.array-buffer.transfer", "es.array-buffer.transfer-to-fixed-length", "es.object.to-string"];
    var TypedArrayDependencies = ["es.typed-array.at", "es.typed-array.copy-within", "es.typed-array.every", "es.typed-array.fill", "es.typed-array.filter", "es.typed-array.find", "es.typed-array.find-index", "es.typed-array.find-last", "es.typed-array.find-last-index", "es.typed-array.for-each", "es.typed-array.includes", "es.typed-array.index-of", "es.typed-array.iterator", "es.typed-array.join", "es.typed-array.last-index-of", "es.typed-array.map", "es.typed-array.reduce", "es.typed-array.reduce-right", "es.typed-array.reverse", "es.typed-array.set", "es.typed-array.slice", "es.typed-array.some", "es.typed-array.sort", "es.typed-array.subarray", "es.typed-array.to-locale-string", "es.typed-array.to-reversed", "es.typed-array.to-sorted", "es.typed-array.to-string", "es.typed-array.with", "es.object.to-string", "es.array.iterator", "esnext.typed-array.filter-reject", "esnext.typed-array.group-by", "esnext.typed-array.to-spliced", "esnext.typed-array.unique-by"].concat(ArrayBufferDependencies);
    var PromiseDependencies = ["es.promise", "es.object.to-string"];
    builtInDefinitions$1.PromiseDependencies = PromiseDependencies;
    var PromiseDependenciesWithIterators = [].concat(PromiseDependencies, _toConsumableArray(CommonIterators));
    builtInDefinitions$1.PromiseDependenciesWithIterators = PromiseDependenciesWithIterators;
    var SymbolDependencies = ["es.symbol", "es.symbol.description", "es.object.to-string"];
    var MapDependencies = ["es.map", "esnext.map.delete-all", "esnext.map.emplace", "esnext.map.every", "esnext.map.filter", "esnext.map.find", "esnext.map.find-key", "esnext.map.includes", "esnext.map.key-of", "esnext.map.map-keys", "esnext.map.map-values", "esnext.map.merge", "esnext.map.reduce", "esnext.map.some", "esnext.map.update"].concat(_toConsumableArray(CommonIteratorsWithTag));
    var SetDependencies = ["es.set", "es.set.difference.v2", "es.set.intersection.v2", "es.set.is-disjoint-from.v2", "es.set.is-subset-of.v2", "es.set.is-superset-of.v2", "es.set.symmetric-difference.v2", "es.set.union.v2", "esnext.set.add-all", "esnext.set.delete-all", "esnext.set.difference", "esnext.set.every", "esnext.set.filter", "esnext.set.find", "esnext.set.intersection", "esnext.set.is-disjoint-from", "esnext.set.is-subset-of", "esnext.set.is-superset-of", "esnext.set.join", "esnext.set.map", "esnext.set.reduce", "esnext.set.some", "esnext.set.symmetric-difference", "esnext.set.union"].concat(_toConsumableArray(CommonIteratorsWithTag));
    var WeakMapDependencies = ["es.weak-map", "esnext.weak-map.delete-all", "esnext.weak-map.emplace"].concat(_toConsumableArray(CommonIteratorsWithTag));
    var WeakSetDependencies = ["es.weak-set", "esnext.weak-set.add-all", "esnext.weak-set.delete-all"].concat(_toConsumableArray(CommonIteratorsWithTag));
    var DOMExceptionDependencies = ["web.dom-exception.constructor", "web.dom-exception.stack", "web.dom-exception.to-string-tag", "es.error.to-string"];
    var URLSearchParamsDependencies = ["web.url-search-params", "web.url-search-params.delete", "web.url-search-params.has", "web.url-search-params.size"].concat(_toConsumableArray(CommonIteratorsWithTag));
    var AsyncIteratorDependencies = ["esnext.async-iterator.constructor"].concat(PromiseDependencies);
    var AsyncIteratorProblemMethods = ["esnext.async-iterator.every", "esnext.async-iterator.filter", "esnext.async-iterator.find", "esnext.async-iterator.flat-map", "esnext.async-iterator.for-each", "esnext.async-iterator.map", "esnext.async-iterator.reduce", "esnext.async-iterator.some"];
    var IteratorDependencies = ["esnext.iterator.constructor", "es.object.to-string"];
    var DecoratorMetadataDependencies = ["esnext.symbol.metadata", "esnext.function.metadata"];
    builtInDefinitions$1.DecoratorMetadataDependencies = DecoratorMetadataDependencies;
    var TypedArrayStaticMethods = function TypedArrayStaticMethods(base) {
      return {
        from: define(null, ["es.typed-array.from", base].concat(TypedArrayDependencies)),
        fromAsync: define(null, ["esnext.typed-array.from-async", base].concat(_toConsumableArray(PromiseDependenciesWithIterators), TypedArrayDependencies)),
        of: define(null, ["es.typed-array.of", base].concat(TypedArrayDependencies))
      };
    };
    var DataViewDependencies = ["es.data-view"].concat(ArrayBufferDependencies);
    var BuiltIns = {
      AsyncDisposableStack: define("async-disposable-stack/index", ["esnext.async-disposable-stack.constructor", "es.object.to-string", "esnext.async-iterator.async-dispose", "esnext.iterator.dispose"].concat(PromiseDependencies, _toConsumableArray(SuppressedErrorDependencies))),
      AsyncIterator: define("async-iterator/index", AsyncIteratorDependencies),
      AggregateError: define("aggregate-error", ["es.aggregate-error"].concat(ErrorDependencies, _toConsumableArray(CommonIteratorsWithTag), ["es.aggregate-error.cause"])),
      ArrayBuffer: define(null, ArrayBufferDependencies),
      DataView: define(null, DataViewDependencies),
      Date: define(null, ["es.date.to-string"]),
      DOMException: define("dom-exception/index", DOMExceptionDependencies),
      DisposableStack: define("disposable-stack/index", ["esnext.disposable-stack.constructor", "es.object.to-string", "esnext.iterator.dispose"].concat(_toConsumableArray(SuppressedErrorDependencies))),
      Error: define(null, ErrorDependencies),
      EvalError: define(null, ErrorDependencies),
      Float32Array: typed("es.typed-array.float32-array"),
      Float64Array: typed("es.typed-array.float64-array"),
      Int8Array: typed("es.typed-array.int8-array"),
      Int16Array: typed("es.typed-array.int16-array"),
      Int32Array: typed("es.typed-array.int32-array"),
      Iterator: define("iterator/index", IteratorDependencies),
      Uint8Array: typed("es.typed-array.uint8-array", "esnext.uint8-array.set-from-base64", "esnext.uint8-array.set-from-hex", "esnext.uint8-array.to-base64", "esnext.uint8-array.to-hex"),
      Uint8ClampedArray: typed("es.typed-array.uint8-clamped-array"),
      Uint16Array: typed("es.typed-array.uint16-array"),
      Uint32Array: typed("es.typed-array.uint32-array"),
      Map: define("map/index", MapDependencies),
      Number: define(null, ["es.number.constructor"]),
      Observable: define("observable/index", ["esnext.observable", "esnext.symbol.observable", "es.object.to-string"].concat(_toConsumableArray(CommonIteratorsWithTag))),
      Promise: define("promise/index", PromiseDependencies),
      RangeError: define(null, ErrorDependencies),
      ReferenceError: define(null, ErrorDependencies),
      Reflect: define(null, ["es.reflect.to-string-tag", "es.object.to-string"]),
      RegExp: define(null, ["es.regexp.constructor", "es.regexp.dot-all", "es.regexp.exec", "es.regexp.sticky", "es.regexp.to-string"]),
      Set: define("set/index", SetDependencies),
      SuppressedError: define("suppressed-error", SuppressedErrorDependencies),
      Symbol: define("symbol/index", SymbolDependencies),
      SyntaxError: define(null, ErrorDependencies),
      TypeError: define(null, ErrorDependencies),
      URIError: define(null, ErrorDependencies),
      URL: define("url/index", ["web.url", "web.url.to-json"].concat(_toConsumableArray(URLSearchParamsDependencies))),
      URLSearchParams: define("url-search-params/index", URLSearchParamsDependencies),
      WeakMap: define("weak-map/index", WeakMapDependencies),
      WeakSet: define("weak-set/index", WeakSetDependencies),
      atob: define("atob", ["web.atob"].concat(DOMExceptionDependencies)),
      btoa: define("btoa", ["web.btoa"].concat(DOMExceptionDependencies)),
      clearImmediate: define("clear-immediate", ["web.immediate"]),
      compositeKey: define("composite-key", ["esnext.composite-key"]),
      compositeSymbol: define("composite-symbol", ["esnext.composite-symbol"]),
      escape: define("escape", ["es.escape"]),
      fetch: define(null, PromiseDependencies),
      globalThis: define("global-this", ["es.global-this"]),
      parseFloat: define("parse-float", ["es.parse-float"]),
      parseInt: define("parse-int", ["es.parse-int"]),
      queueMicrotask: define("queue-microtask", ["web.queue-microtask"]),
      self: define("self", ["web.self"]),
      setImmediate: define("set-immediate", ["web.immediate"]),
      setInterval: define("set-interval", ["web.timers"]),
      setTimeout: define("set-timeout", ["web.timers"]),
      structuredClone: define("structured-clone", ["web.structured-clone"].concat(DOMExceptionDependencies, ["es.array.iterator", "es.object.keys", "es.object.to-string", "es.map", "es.set"])),
      unescape: define("unescape", ["es.unescape"])
    };
    builtInDefinitions$1.BuiltIns = BuiltIns;
    var StaticProperties = {
      AsyncIterator: {
        from: define("async-iterator/from", ["esnext.async-iterator.from"].concat(_toConsumableArray(AsyncIteratorDependencies), AsyncIteratorProblemMethods, _toConsumableArray(CommonIterators)))
      },
      Array: {
        from: define("array/from", ["es.array.from", "es.string.iterator"]),
        fromAsync: define("array/from-async", ["esnext.array.from-async"].concat(_toConsumableArray(PromiseDependenciesWithIterators))),
        isArray: define("array/is-array", ["es.array.is-array"]),
        isTemplateObject: define("array/is-template-object", ["esnext.array.is-template-object"]),
        of: define("array/of", ["es.array.of"])
      },
      ArrayBuffer: {
        isView: define(null, ["es.array-buffer.is-view"])
      },
      BigInt: {
        range: define("bigint/range", ["esnext.bigint.range", "es.object.to-string"])
      },
      Date: {
        now: define("date/now", ["es.date.now"])
      },
      Function: {
        isCallable: define("function/is-callable", ["esnext.function.is-callable"]),
        isConstructor: define("function/is-constructor", ["esnext.function.is-constructor"])
      },
      Iterator: {
        from: define("iterator/from", ["esnext.iterator.from"].concat(IteratorDependencies, _toConsumableArray(CommonIterators))),
        range: define("iterator/range", ["esnext.iterator.range", "es.object.to-string"])
      },
      JSON: {
        isRawJSON: define("json/is-raw-json", ["esnext.json.is-raw-json"]),
        parse: define("json/parse", ["esnext.json.parse", "es.object.keys"]),
        rawJSON: define("json/raw-json", ["esnext.json.raw-json", "es.object.create", "es.object.freeze"]),
        stringify: define("json/stringify", ["es.json.stringify", "es.date.to-json"], "es.symbol")
      },
      Math: {
        DEG_PER_RAD: define("math/deg-per-rad", ["esnext.math.deg-per-rad"]),
        RAD_PER_DEG: define("math/rad-per-deg", ["esnext.math.rad-per-deg"]),
        acosh: define("math/acosh", ["es.math.acosh"]),
        asinh: define("math/asinh", ["es.math.asinh"]),
        atanh: define("math/atanh", ["es.math.atanh"]),
        cbrt: define("math/cbrt", ["es.math.cbrt"]),
        clamp: define("math/clamp", ["esnext.math.clamp"]),
        clz32: define("math/clz32", ["es.math.clz32"]),
        cosh: define("math/cosh", ["es.math.cosh"]),
        degrees: define("math/degrees", ["esnext.math.degrees"]),
        expm1: define("math/expm1", ["es.math.expm1"]),
        fround: define("math/fround", ["es.math.fround"]),
        f16round: define("math/f16round", ["esnext.math.f16round"]),
        fscale: define("math/fscale", ["esnext.math.fscale"]),
        hypot: define("math/hypot", ["es.math.hypot"]),
        iaddh: define("math/iaddh", ["esnext.math.iaddh"]),
        imul: define("math/imul", ["es.math.imul"]),
        imulh: define("math/imulh", ["esnext.math.imulh"]),
        isubh: define("math/isubh", ["esnext.math.isubh"]),
        log10: define("math/log10", ["es.math.log10"]),
        log1p: define("math/log1p", ["es.math.log1p"]),
        log2: define("math/log2", ["es.math.log2"]),
        radians: define("math/radians", ["esnext.math.radians"]),
        scale: define("math/scale", ["esnext.math.scale"]),
        seededPRNG: define("math/seeded-prng", ["esnext.math.seeded-prng"]),
        sign: define("math/sign", ["es.math.sign"]),
        signbit: define("math/signbit", ["esnext.math.signbit"]),
        sinh: define("math/sinh", ["es.math.sinh"]),
        sumPrecise: define("math/sum-precise", ["esnext.math.sum-precise", "es.array.iterator"]),
        tanh: define("math/tanh", ["es.math.tanh"]),
        trunc: define("math/trunc", ["es.math.trunc"]),
        umulh: define("math/umulh", ["esnext.math.umulh"])
      },
      Map: {
        from: define("map/from", ["esnext.map.from"].concat(_toConsumableArray(MapDependencies))),
        groupBy: define("map/group-by", ["es.map.group-by"].concat(_toConsumableArray(MapDependencies))),
        keyBy: define("map/key-by", ["esnext.map.key-by"].concat(_toConsumableArray(MapDependencies))),
        of: define("map/of", ["esnext.map.of"].concat(_toConsumableArray(MapDependencies)))
      },
      Number: {
        EPSILON: define("number/epsilon", ["es.number.epsilon"]),
        MAX_SAFE_INTEGER: define("number/max-safe-integer", ["es.number.max-safe-integer"]),
        MIN_SAFE_INTEGER: define("number/min-safe-integer", ["es.number.min-safe-integer"]),
        fromString: define("number/from-string", ["esnext.number.from-string"]),
        isFinite: define("number/is-finite", ["es.number.is-finite"]),
        isInteger: define("number/is-integer", ["es.number.is-integer"]),
        isNaN: define("number/is-nan", ["es.number.is-nan"]),
        isSafeInteger: define("number/is-safe-integer", ["es.number.is-safe-integer"]),
        parseFloat: define("number/parse-float", ["es.number.parse-float"]),
        parseInt: define("number/parse-int", ["es.number.parse-int"]),
        range: define("number/range", ["esnext.number.range", "es.object.to-string"])
      },
      Object: {
        assign: define("object/assign", ["es.object.assign"]),
        create: define("object/create", ["es.object.create"]),
        defineProperties: define("object/define-properties", ["es.object.define-properties"]),
        defineProperty: define("object/define-property", ["es.object.define-property"]),
        entries: define("object/entries", ["es.object.entries"]),
        freeze: define("object/freeze", ["es.object.freeze"]),
        fromEntries: define("object/from-entries", ["es.object.from-entries", "es.array.iterator"]),
        getOwnPropertyDescriptor: define("object/get-own-property-descriptor", ["es.object.get-own-property-descriptor"]),
        getOwnPropertyDescriptors: define("object/get-own-property-descriptors", ["es.object.get-own-property-descriptors"]),
        getOwnPropertyNames: define("object/get-own-property-names", ["es.object.get-own-property-names"]),
        getOwnPropertySymbols: define("object/get-own-property-symbols", ["es.symbol"]),
        getPrototypeOf: define("object/get-prototype-of", ["es.object.get-prototype-of"]),
        groupBy: define("object/group-by", ["es.object.group-by", "es.object.create"]),
        hasOwn: define("object/has-own", ["es.object.has-own"]),
        is: define("object/is", ["es.object.is"]),
        isExtensible: define("object/is-extensible", ["es.object.is-extensible"]),
        isFrozen: define("object/is-frozen", ["es.object.is-frozen"]),
        isSealed: define("object/is-sealed", ["es.object.is-sealed"]),
        keys: define("object/keys", ["es.object.keys"]),
        preventExtensions: define("object/prevent-extensions", ["es.object.prevent-extensions"]),
        seal: define("object/seal", ["es.object.seal"]),
        setPrototypeOf: define("object/set-prototype-of", ["es.object.set-prototype-of"]),
        values: define("object/values", ["es.object.values"])
      },
      Promise: {
        all: define(null, PromiseDependenciesWithIterators),
        allSettled: define("promise/all-settled", ["es.promise.all-settled"].concat(_toConsumableArray(PromiseDependenciesWithIterators))),
        any: define("promise/any", ["es.promise.any", "es.aggregate-error"].concat(_toConsumableArray(PromiseDependenciesWithIterators))),
        race: define(null, PromiseDependenciesWithIterators),
        "try": define("promise/try", ["esnext.promise.try"].concat(PromiseDependencies)),
        withResolvers: define("promise/with-resolvers", ["es.promise.with-resolvers"].concat(PromiseDependencies))
      },
      Reflect: {
        apply: define("reflect/apply", ["es.reflect.apply"]),
        construct: define("reflect/construct", ["es.reflect.construct"]),
        defineMetadata: define("reflect/define-metadata", ["esnext.reflect.define-metadata"]),
        defineProperty: define("reflect/define-property", ["es.reflect.define-property"]),
        deleteMetadata: define("reflect/delete-metadata", ["esnext.reflect.delete-metadata"]),
        deleteProperty: define("reflect/delete-property", ["es.reflect.delete-property"]),
        get: define("reflect/get", ["es.reflect.get"]),
        getMetadata: define("reflect/get-metadata", ["esnext.reflect.get-metadata"]),
        getMetadataKeys: define("reflect/get-metadata-keys", ["esnext.reflect.get-metadata-keys"]),
        getOwnMetadata: define("reflect/get-own-metadata", ["esnext.reflect.get-own-metadata"]),
        getOwnMetadataKeys: define("reflect/get-own-metadata-keys", ["esnext.reflect.get-own-metadata-keys"]),
        getOwnPropertyDescriptor: define("reflect/get-own-property-descriptor", ["es.reflect.get-own-property-descriptor"]),
        getPrototypeOf: define("reflect/get-prototype-of", ["es.reflect.get-prototype-of"]),
        has: define("reflect/has", ["es.reflect.has"]),
        hasMetadata: define("reflect/has-metadata", ["esnext.reflect.has-metadata"]),
        hasOwnMetadata: define("reflect/has-own-metadata", ["esnext.reflect.has-own-metadata"]),
        isExtensible: define("reflect/is-extensible", ["es.reflect.is-extensible"]),
        metadata: define("reflect/metadata", ["esnext.reflect.metadata"]),
        ownKeys: define("reflect/own-keys", ["es.reflect.own-keys"]),
        preventExtensions: define("reflect/prevent-extensions", ["es.reflect.prevent-extensions"]),
        set: define("reflect/set", ["es.reflect.set"]),
        setPrototypeOf: define("reflect/set-prototype-of", ["es.reflect.set-prototype-of"])
      },
      RegExp: {
        escape: define("regexp/escape", ["esnext.regexp.escape"])
      },
      Set: {
        from: define("set/from", ["esnext.set.from"].concat(_toConsumableArray(SetDependencies))),
        of: define("set/of", ["esnext.set.of"].concat(_toConsumableArray(SetDependencies)))
      },
      String: {
        cooked: define("string/cooked", ["esnext.string.cooked"]),
        dedent: define("string/dedent", ["esnext.string.dedent", "es.string.from-code-point", "es.weak-map"]),
        fromCodePoint: define("string/from-code-point", ["es.string.from-code-point"]),
        raw: define("string/raw", ["es.string.raw"])
      },
      Symbol: {
        asyncDispose: define("symbol/async-dispose", ["esnext.symbol.async-dispose", "esnext.async-iterator.async-dispose"]),
        asyncIterator: define("symbol/async-iterator", ["es.symbol.async-iterator"]),
        customMatcher: define("symbol/custom-matcher", ["esnext.symbol.custom-matcher"]),
        dispose: define("symbol/dispose", ["esnext.symbol.dispose", "esnext.iterator.dispose"]),
        "for": define("symbol/for", [], "es.symbol"),
        hasInstance: define("symbol/has-instance", ["es.symbol.has-instance", "es.function.has-instance"]),
        isConcatSpreadable: define("symbol/is-concat-spreadable", ["es.symbol.is-concat-spreadable", "es.array.concat"]),
        isRegistered: define("symbol/is-registered", ["esnext.symbol.is-registered", "es.symbol"]),
        isRegisteredSymbol: define("symbol/is-registered-symbol", ["esnext.symbol.is-registered-symbol", "es.symbol"]),
        isWellKnown: define("symbol/is-well-known", ["esnext.symbol.is-well-known", "es.symbol"]),
        isWellKnownSymbol: define("symbol/is-well-known-symbol", ["esnext.symbol.is-well-known-symbol", "es.symbol"]),
        iterator: define("symbol/iterator", ["es.symbol.iterator"].concat(_toConsumableArray(CommonIteratorsWithTag))),
        keyFor: define("symbol/key-for", [], "es.symbol"),
        match: define("symbol/match", ["es.symbol.match", "es.string.match"]),
        matcher: define("symbol/matcher", ["esnext.symbol.matcher"]),
        matchAll: define("symbol/match-all", ["es.symbol.match-all", "es.string.match-all"]),
        metadata: define("symbol/metadata", DecoratorMetadataDependencies),
        metadataKey: define("symbol/metadata-key", ["esnext.symbol.metadata-key"]),
        observable: define("symbol/observable", ["esnext.symbol.observable"]),
        patternMatch: define("symbol/pattern-match", ["esnext.symbol.pattern-match"]),
        replace: define("symbol/replace", ["es.symbol.replace", "es.string.replace"]),
        search: define("symbol/search", ["es.symbol.search", "es.string.search"]),
        species: define("symbol/species", ["es.symbol.species", "es.array.species"]),
        split: define("symbol/split", ["es.symbol.split", "es.string.split"]),
        toPrimitive: define("symbol/to-primitive", ["es.symbol.to-primitive", "es.date.to-primitive"]),
        toStringTag: define("symbol/to-string-tag", ["es.symbol.to-string-tag", "es.object.to-string", "es.math.to-string-tag", "es.json.to-string-tag"]),
        unscopables: define("symbol/unscopables", ["es.symbol.unscopables"])
      },
      URL: {
        canParse: define("url/can-parse", ["web.url.can-parse", "web.url"]),
        parse: define("url/parse", ["web.url.parse", "web.url"])
      },
      WeakMap: {
        from: define("weak-map/from", ["esnext.weak-map.from"].concat(_toConsumableArray(WeakMapDependencies))),
        of: define("weak-map/of", ["esnext.weak-map.of"].concat(_toConsumableArray(WeakMapDependencies)))
      },
      WeakSet: {
        from: define("weak-set/from", ["esnext.weak-set.from"].concat(_toConsumableArray(WeakSetDependencies))),
        of: define("weak-set/of", ["esnext.weak-set.of"].concat(_toConsumableArray(WeakSetDependencies)))
      },
      Int8Array: TypedArrayStaticMethods("es.typed-array.int8-array"),
      Uint8Array: _extends({
        fromBase64: define(null, ["esnext.uint8-array.from-base64"].concat(TypedArrayDependencies)),
        fromHex: define(null, ["esnext.uint8-array.from-hex"].concat(TypedArrayDependencies))
      }, TypedArrayStaticMethods("es.typed-array.uint8-array")),
      Uint8ClampedArray: TypedArrayStaticMethods("es.typed-array.uint8-clamped-array"),
      Int16Array: TypedArrayStaticMethods("es.typed-array.int16-array"),
      Uint16Array: TypedArrayStaticMethods("es.typed-array.uint16-array"),
      Int32Array: TypedArrayStaticMethods("es.typed-array.int32-array"),
      Uint32Array: TypedArrayStaticMethods("es.typed-array.uint32-array"),
      Float32Array: TypedArrayStaticMethods("es.typed-array.float32-array"),
      Float64Array: TypedArrayStaticMethods("es.typed-array.float64-array"),
      WebAssembly: {
        CompileError: define(null, ErrorDependencies),
        LinkError: define(null, ErrorDependencies),
        RuntimeError: define(null, ErrorDependencies)
      }
    };
    builtInDefinitions$1.StaticProperties = StaticProperties;
    var InstanceProperties = (_InstanceProperties = {
      asIndexedPairs: define(null, ["esnext.async-iterator.as-indexed-pairs"].concat(_toConsumableArray(AsyncIteratorDependencies), ["esnext.iterator.as-indexed-pairs"], IteratorDependencies)),
      at: define("instance/at", ["esnext.string.at", "es.string.at-alternative", "es.array.at"]),
      anchor: define(null, ["es.string.anchor"]),
      big: define(null, ["es.string.big"]),
      bind: define("instance/bind", ["es.function.bind"]),
      blink: define(null, ["es.string.blink"]),
      bold: define(null, ["es.string.bold"]),
      codePointAt: define("instance/code-point-at", ["es.string.code-point-at"]),
      codePoints: define("instance/code-points", ["esnext.string.code-points"]),
      concat: define("instance/concat", ["es.array.concat"], undefined, ["String"]),
      copyWithin: define("instance/copy-within", ["es.array.copy-within"]),
      demethodize: define("instance/demethodize", ["esnext.function.demethodize"]),
      description: define(null, ["es.symbol", "es.symbol.description"]),
      dotAll: define(null, ["es.regexp.dot-all"]),
      drop: define(null, ["esnext.async-iterator.drop"].concat(_toConsumableArray(AsyncIteratorDependencies), ["esnext.iterator.drop"], IteratorDependencies)),
      emplace: define("instance/emplace", ["esnext.map.emplace", "esnext.weak-map.emplace"]),
      endsWith: define("instance/ends-with", ["es.string.ends-with"]),
      entries: define("instance/entries", ArrayNatureIteratorsWithTag),
      every: define("instance/every", ["es.array.every", "esnext.async-iterator.every", "esnext.iterator.every"].concat(IteratorDependencies)),
      exec: define(null, ["es.regexp.exec"]),
      fill: define("instance/fill", ["es.array.fill"]),
      filter: define("instance/filter", ["es.array.filter", "esnext.async-iterator.filter", "esnext.iterator.filter"].concat(IteratorDependencies)),
      filterReject: define("instance/filterReject", ["esnext.array.filter-reject"]),
      "finally": define(null, ["es.promise.finally"].concat(PromiseDependencies)),
      find: define("instance/find", ["es.array.find", "esnext.async-iterator.find", "esnext.iterator.find"].concat(IteratorDependencies)),
      findIndex: define("instance/find-index", ["es.array.find-index"]),
      findLast: define("instance/find-last", ["es.array.find-last"]),
      findLastIndex: define("instance/find-last-index", ["es.array.find-last-index"]),
      fixed: define(null, ["es.string.fixed"]),
      flags: define("instance/flags", ["es.regexp.flags"]),
      flatMap: define("instance/flat-map", ["es.array.flat-map", "es.array.unscopables.flat-map", "esnext.async-iterator.flat-map", "esnext.iterator.flat-map"].concat(IteratorDependencies)),
      flat: define("instance/flat", ["es.array.flat", "es.array.unscopables.flat"]),
      getFloat16: define(null, ["esnext.data-view.get-float16"].concat(_toConsumableArray(DataViewDependencies))),
      getUint8Clamped: define(null, ["esnext.data-view.get-uint8-clamped"].concat(_toConsumableArray(DataViewDependencies))),
      getYear: define(null, ["es.date.get-year"]),
      group: define("instance/group", ["esnext.array.group"]),
      groupBy: define("instance/group-by", ["esnext.array.group-by"]),
      groupByToMap: define("instance/group-by-to-map", ["esnext.array.group-by-to-map", "es.map", "es.object.to-string"]),
      groupToMap: define("instance/group-to-map", ["esnext.array.group-to-map", "es.map", "es.object.to-string"]),
      fontcolor: define(null, ["es.string.fontcolor"]),
      fontsize: define(null, ["es.string.fontsize"]),
      forEach: define("instance/for-each", ["es.array.for-each", "esnext.async-iterator.for-each", "esnext.iterator.for-each"].concat(IteratorDependencies, ["web.dom-collections.for-each"])),
      includes: define("instance/includes", ["es.array.includes", "es.string.includes"]),
      indexed: define(null, ["esnext.async-iterator.indexed"].concat(_toConsumableArray(AsyncIteratorDependencies), ["esnext.iterator.indexed"], IteratorDependencies)),
      indexOf: define("instance/index-of", ["es.array.index-of"]),
      isWellFormed: define("instance/is-well-formed", ["es.string.is-well-formed"]),
      italic: define(null, ["es.string.italics"]),
      join: define(null, ["es.array.join"]),
      keys: define("instance/keys", ArrayNatureIteratorsWithTag),
      lastIndex: define(null, ["esnext.array.last-index"]),
      lastIndexOf: define("instance/last-index-of", ["es.array.last-index-of"]),
      lastItem: define(null, ["esnext.array.last-item"]),
      link: define(null, ["es.string.link"]),
      map: define("instance/map", ["es.array.map", "esnext.async-iterator.map", "esnext.iterator.map"]),
      match: define(null, ["es.string.match", "es.regexp.exec"]),
      matchAll: define("instance/match-all", ["es.string.match-all", "es.regexp.exec"]),
      name: define(null, ["es.function.name"]),
      padEnd: define("instance/pad-end", ["es.string.pad-end"]),
      padStart: define("instance/pad-start", ["es.string.pad-start"]),
      push: define("instance/push", ["es.array.push"]),
      reduce: define("instance/reduce", ["es.array.reduce", "esnext.async-iterator.reduce", "esnext.iterator.reduce"].concat(IteratorDependencies)),
      reduceRight: define("instance/reduce-right", ["es.array.reduce-right"]),
      repeat: define("instance/repeat", ["es.string.repeat"]),
      replace: define(null, ["es.string.replace", "es.regexp.exec"]),
      replaceAll: define("instance/replace-all", ["es.string.replace-all", "es.string.replace", "es.regexp.exec"]),
      reverse: define("instance/reverse", ["es.array.reverse"]),
      search: define(null, ["es.string.search", "es.regexp.exec"]),
      setFloat16: define(null, ["esnext.data-view.set-float16"].concat(_toConsumableArray(DataViewDependencies))),
      setUint8Clamped: define(null, ["esnext.data-view.set-uint8-clamped"].concat(_toConsumableArray(DataViewDependencies))),
      setYear: define(null, ["es.date.set-year"]),
      slice: define("instance/slice", ["es.array.slice"]),
      small: define(null, ["es.string.small"]),
      some: define("instance/some", ["es.array.some", "esnext.async-iterator.some", "esnext.iterator.some"].concat(IteratorDependencies)),
      sort: define("instance/sort", ["es.array.sort"]),
      splice: define("instance/splice", ["es.array.splice"]),
      split: define(null, ["es.string.split", "es.regexp.exec"]),
      startsWith: define("instance/starts-with", ["es.string.starts-with"]),
      sticky: define(null, ["es.regexp.sticky"]),
      strike: define(null, ["es.string.strike"]),
      sub: define(null, ["es.string.sub"]),
      substr: define(null, ["es.string.substr"]),
      sup: define(null, ["es.string.sup"]),
      take: define(null, ["esnext.async-iterator.take"].concat(_toConsumableArray(AsyncIteratorDependencies), ["esnext.iterator.take"], IteratorDependencies)),
      test: define(null, ["es.regexp.test", "es.regexp.exec"]),
      toArray: define(null, ["esnext.async-iterator.to-array"].concat(_toConsumableArray(AsyncIteratorDependencies), ["esnext.iterator.to-array"], IteratorDependencies)),
      toAsync: define(null, ["esnext.iterator.to-async"].concat(IteratorDependencies, _toConsumableArray(AsyncIteratorDependencies), AsyncIteratorProblemMethods)),
      toExponential: define(null, ["es.number.to-exponential"]),
      toFixed: define(null, ["es.number.to-fixed"]),
      toGMTString: define(null, ["es.date.to-gmt-string"]),
      toISOString: define(null, ["es.date.to-iso-string"]),
      toJSON: define(null, ["es.date.to-json"]),
      toPrecision: define(null, ["es.number.to-precision"]),
      toReversed: define("instance/to-reversed", ["es.array.to-reversed"]),
      toSorted: define("instance/to-sorted", ["es.array.to-sorted", "es.array.sort"]),
      toSpliced: define("instance/to-spliced", ["es.array.to-spliced"]),
      toString: define(null, ["es.object.to-string", "es.error.to-string", "es.date.to-string", "es.regexp.to-string"]),
      toWellFormed: define("instance/to-well-formed", ["es.string.to-well-formed"]),
      trim: define("instance/trim", ["es.string.trim"]),
      trimEnd: define("instance/trim-end", ["es.string.trim-end"]),
      trimLeft: define("instance/trim-left", ["es.string.trim-start"]),
      trimRight: define("instance/trim-right", ["es.string.trim-end"]),
      trimStart: define("instance/trim-start", ["es.string.trim-start"]),
      uniqueBy: define("instance/unique-by", ["esnext.array.unique-by", "es.map"]),
      unshift: define("instance/unshift", ["es.array.unshift"]),
      unThis: define("instance/un-this", ["esnext.function.un-this"]),
      values: define("instance/values", ArrayNatureIteratorsWithTag),
      "with": define("instance/with", ["es.array.with"]),
      __defineGetter__: define(null, ["es.object.define-getter"]),
      __defineSetter__: define(null, ["es.object.define-setter"]),
      __lookupGetter__: define(null, ["es.object.lookup-getter"]),
      __lookupSetter__: define(null, ["es.object.lookup-setter"])
    }, _InstanceProperties["__proto__"] = define(null, ["es.object.proto"]), _InstanceProperties);
    builtInDefinitions$1.InstanceProperties = InstanceProperties;
    return builtInDefinitions$1;
  }

var babelRuntimeCorejs3Paths = {};

var hasRequiredBabelRuntimeCorejs3Paths;
  function requireBabelRuntimeCorejs3Paths() {
    if (hasRequiredBabelRuntimeCorejs3Paths) return babelRuntimeCorejs3Paths;
    hasRequiredBabelRuntimeCorejs3Paths = 1;
    babelRuntimeCorejs3Paths.__esModule = true;
    babelRuntimeCorejs3Paths.stable = babelRuntimeCorejs3Paths.proposals = void 0;
    var stable = new Set(["array", "array/from", "array/is-array", "array/of", "clear-immediate", "date/now", "instance/bind", "instance/code-point-at", "instance/concat", "instance/copy-within", "instance/ends-with", "instance/entries", "instance/every", "instance/fill", "instance/filter", "instance/find", "instance/find-index", "instance/flags", "instance/flat", "instance/flat-map", "instance/for-each", "instance/includes", "instance/index-of", "instance/keys", "instance/last-index-of", "instance/map", "instance/pad-end", "instance/pad-start", "instance/reduce", "instance/reduce-right", "instance/repeat", "instance/reverse", "instance/slice", "instance/some", "instance/sort", "instance/splice", "instance/starts-with", "instance/trim", "instance/trim-end", "instance/trim-left", "instance/trim-right", "instance/trim-start", "instance/values", "json/stringify", "map", "math/acosh", "math/asinh", "math/atanh", "math/cbrt", "math/clz32", "math/cosh", "math/expm1", "math/fround", "math/hypot", "math/imul", "math/log10", "math/log1p", "math/log2", "math/sign", "math/sinh", "math/tanh", "math/trunc", "number/epsilon", "number/is-finite", "number/is-integer", "number/is-nan", "number/is-safe-integer", "number/max-safe-integer", "number/min-safe-integer", "number/parse-float", "number/parse-int", "object/assign", "object/create", "object/define-properties", "object/define-property", "object/entries", "object/freeze", "object/from-entries", "object/get-own-property-descriptor", "object/get-own-property-descriptors", "object/get-own-property-names", "object/get-own-property-symbols", "object/get-prototype-of", "object/is", "object/is-extensible", "object/is-frozen", "object/is-sealed", "object/keys", "object/prevent-extensions", "object/seal", "object/set-prototype-of", "object/values", "parse-float", "parse-int", "promise", "queue-microtask", "reflect/apply", "reflect/construct", "reflect/define-property", "reflect/delete-property", "reflect/get", "reflect/get-own-property-descriptor", "reflect/get-prototype-of", "reflect/has", "reflect/is-extensible", "reflect/own-keys", "reflect/prevent-extensions", "reflect/set", "reflect/set-prototype-of", "set", "set-immediate", "set-interval", "set-timeout", "string/from-code-point", "string/raw", "symbol", "symbol/async-iterator", "symbol/for", "symbol/has-instance", "symbol/is-concat-spreadable", "symbol/iterator", "symbol/key-for", "symbol/match", "symbol/replace", "symbol/search", "symbol/species", "symbol/split", "symbol/to-primitive", "symbol/to-string-tag", "symbol/unscopables", "url", "url-search-params", "weak-map", "weak-set"]);
    babelRuntimeCorejs3Paths.stable = stable;
    var proposals = new Set([].concat(_toConsumableArray(stable), ["aggregate-error", "composite-key", "composite-symbol", "global-this", "instance/at", "instance/code-points", "instance/match-all", "instance/replace-all", "math/clamp", "math/degrees", "math/deg-per-rad", "math/fscale", "math/iaddh", "math/imulh", "math/isubh", "math/rad-per-deg", "math/radians", "math/scale", "math/seeded-prng", "math/signbit", "math/umulh", "number/from-string", "observable", "reflect/define-metadata", "reflect/delete-metadata", "reflect/get-metadata", "reflect/get-metadata-keys", "reflect/get-own-metadata", "reflect/get-own-metadata-keys", "reflect/has-metadata", "reflect/has-own-metadata", "reflect/metadata", "symbol/dispose", "symbol/observable", "symbol/pattern-match"]));
    babelRuntimeCorejs3Paths.proposals = proposals;
    return babelRuntimeCorejs3Paths;
  }

var usageFilters = {};

var hasRequiredUsageFilters;
  function requireUsageFilters() {
    if (hasRequiredUsageFilters) return usageFilters;
    hasRequiredUsageFilters = 1;
    usageFilters.__esModule = true;
    usageFilters["default"] = canSkipPolyfill;
    var _babel = _interopRequireWildcard(require$$5);
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    var _ref = _babel["default"] || _babel,
      t = _ref.types;
    function canSkipPolyfill(desc, path) {
      var node = path.node,
        parent = path.parent;
      switch (desc.name) {
        case "es.string.split":
          {
            if (!t.isCallExpression(parent, {
              callee: node
            })) return false;
            if (parent.arguments.length < 1) return true;
            var splitter = parent.arguments[0];
            return t.isStringLiteral(splitter) || t.isTemplateLiteral(splitter);
          }
      }
    }
    return usageFilters;
  }

var utils$2 = {};

var require$$0$3 = {
  	"core-js": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.error.cause",
  	"es.error.to-string",
  	"es.aggregate-error",
  	"es.aggregate-error.cause",
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string",
  	"es.escape",
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name",
  	"es.global-this",
  	"es.json.stringify",
  	"es.json.to-string-tag",
  	"es.map",
  	"es.map.group-by",
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc",
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.parse-float",
  	"es.parse-int",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag",
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"es.unescape",
  	"es.weak-map",
  	"es.weak-set",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.bigint.range",
  	"esnext.composite-key",
  	"esnext.composite-symbol",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.demethodize",
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor",
  	"esnext.function.metadata",
  	"esnext.function.un-this",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.f16round",
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.sum-precise",
  	"esnext.math.umulh",
  	"esnext.number.from-string",
  	"esnext.number.range",
  	"esnext.object.has-own",
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values",
  	"esnext.object.group-by",
  	"esnext.observable",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.reflect.define-metadata",
  	"esnext.reflect.delete-metadata",
  	"esnext.reflect.get-metadata",
  	"esnext.reflect.get-metadata-keys",
  	"esnext.reflect.get-own-metadata",
  	"esnext.reflect.get-own-metadata-keys",
  	"esnext.reflect.has-metadata",
  	"esnext.reflect.has-own-metadata",
  	"esnext.reflect.metadata",
  	"esnext.regexp.escape",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"esnext.string.at",
  	"esnext.string.cooked",
  	"esnext.string.code-points",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.custom-matcher",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.symbol.replace-all",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of",
  	"web.atob",
  	"web.btoa",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.immediate",
  	"web.queue-microtask",
  	"web.self",
  	"web.structured-clone",
  	"web.timers",
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/actual": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.error.cause",
  	"es.error.to-string",
  	"es.aggregate-error",
  	"es.aggregate-error.cause",
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string",
  	"es.escape",
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name",
  	"es.global-this",
  	"es.json.stringify",
  	"es.json.to-string-tag",
  	"es.map",
  	"es.map.group-by",
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc",
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.parse-float",
  	"es.parse-int",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag",
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"es.unescape",
  	"es.weak-map",
  	"es.weak-set",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.set-float16",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.metadata",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.map",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.group-by",
  	"esnext.math.f16round",
  	"esnext.object.has-own",
  	"esnext.object.group-by",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.regexp.escape",
  	"esnext.set.difference.v2",
  	"esnext.set.intersection.v2",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.union.v2",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.dispose",
  	"esnext.symbol.metadata",
  	"esnext.typed-array.at",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex",
  	"web.atob",
  	"web.btoa",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.immediate",
  	"web.queue-microtask",
  	"web.self",
  	"web.structured-clone",
  	"web.timers",
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/actual/aggregate-error": [
  ],
  	"core-js/actual/array": [
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.array.from-async",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.with"
  ],
  	"core-js/actual/array-buffer": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.object.to-string",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/actual/array-buffer/constructor": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.object.to-string",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/actual/array-buffer/detached": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.array-buffer.detached",
  	"esnext.array-buffer.detached"
  ],
  	"core-js/actual/array-buffer/is-view": [
  	"es.array-buffer.is-view"
  ],
  	"core-js/actual/array-buffer/slice": [
  	"es.array-buffer.slice"
  ],
  	"core-js/actual/array-buffer/transfer": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.transfer",
  	"esnext.array-buffer.transfer"
  ],
  	"core-js/actual/array-buffer/transfer-to-fixed-length": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.transfer-to-fixed-length",
  	"esnext.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/actual/array/at": [
  	"es.array.at"
  ],
  	"core-js/actual/array/concat": [
  	"es.array.concat"
  ],
  	"core-js/actual/array/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/actual/array/entries": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/actual/array/every": [
  	"es.array.every"
  ],
  	"core-js/actual/array/fill": [
  	"es.array.fill"
  ],
  	"core-js/actual/array/filter": [
  	"es.array.filter"
  ],
  	"core-js/actual/array/find": [
  	"es.array.find"
  ],
  	"core-js/actual/array/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/actual/array/find-last": [
  	"es.array.find-last",
  	"esnext.array.find-last"
  ],
  	"core-js/actual/array/find-last-index": [
  	"es.array.find-last-index",
  	"esnext.array.find-last-index"
  ],
  	"core-js/actual/array/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/actual/array/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/actual/array/for-each": [
  	"es.array.for-each"
  ],
  	"core-js/actual/array/from": [
  	"es.array.from",
  	"es.string.iterator"
  ],
  	"core-js/actual/array/from-async": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.array.from-async"
  ],
  	"core-js/actual/array/group": [
  	"esnext.array.group"
  ],
  	"core-js/actual/array/group-by": [
  	"esnext.array.group-by"
  ],
  	"core-js/actual/array/group-by-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-by-to-map"
  ],
  	"core-js/actual/array/group-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-to-map"
  ],
  	"core-js/actual/array/includes": [
  	"es.array.includes"
  ],
  	"core-js/actual/array/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/actual/array/is-array": [
  	"es.array.is-array"
  ],
  	"core-js/actual/array/iterator": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/actual/array/join": [
  	"es.array.join"
  ],
  	"core-js/actual/array/keys": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/actual/array/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/actual/array/map": [
  	"es.array.map"
  ],
  	"core-js/actual/array/of": [
  	"es.array.of"
  ],
  	"core-js/actual/array/push": [
  	"es.array.push"
  ],
  	"core-js/actual/array/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/actual/array/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/actual/array/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/actual/array/slice": [
  	"es.array.slice"
  ],
  	"core-js/actual/array/some": [
  	"es.array.some"
  ],
  	"core-js/actual/array/sort": [
  	"es.array.sort"
  ],
  	"core-js/actual/array/splice": [
  	"es.array.splice"
  ],
  	"core-js/actual/array/to-reversed": [
  	"es.array.to-reversed",
  	"esnext.array.to-reversed"
  ],
  	"core-js/actual/array/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted",
  	"esnext.array.to-sorted"
  ],
  	"core-js/actual/array/to-spliced": [
  	"es.array.to-spliced",
  	"esnext.array.to-spliced"
  ],
  	"core-js/actual/array/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/actual/array/values": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/actual/array/virtual": [
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.with"
  ],
  	"core-js/actual/array/virtual/at": [
  	"es.array.at"
  ],
  	"core-js/actual/array/virtual/concat": [
  	"es.array.concat"
  ],
  	"core-js/actual/array/virtual/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/actual/array/virtual/entries": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/actual/array/virtual/every": [
  	"es.array.every"
  ],
  	"core-js/actual/array/virtual/fill": [
  	"es.array.fill"
  ],
  	"core-js/actual/array/virtual/filter": [
  	"es.array.filter"
  ],
  	"core-js/actual/array/virtual/find": [
  	"es.array.find"
  ],
  	"core-js/actual/array/virtual/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/actual/array/virtual/find-last": [
  	"es.array.find-last",
  	"esnext.array.find-last"
  ],
  	"core-js/actual/array/virtual/find-last-index": [
  	"es.array.find-last-index",
  	"esnext.array.find-last-index"
  ],
  	"core-js/actual/array/virtual/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/actual/array/virtual/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/actual/array/virtual/for-each": [
  	"es.array.for-each"
  ],
  	"core-js/actual/array/virtual/group": [
  	"esnext.array.group"
  ],
  	"core-js/actual/array/virtual/group-by": [
  	"esnext.array.group-by"
  ],
  	"core-js/actual/array/virtual/group-by-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-by-to-map"
  ],
  	"core-js/actual/array/virtual/group-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-to-map"
  ],
  	"core-js/actual/array/virtual/includes": [
  	"es.array.includes"
  ],
  	"core-js/actual/array/virtual/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/actual/array/virtual/iterator": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/actual/array/virtual/join": [
  	"es.array.join"
  ],
  	"core-js/actual/array/virtual/keys": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/actual/array/virtual/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/actual/array/virtual/map": [
  	"es.array.map"
  ],
  	"core-js/actual/array/virtual/push": [
  	"es.array.push"
  ],
  	"core-js/actual/array/virtual/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/actual/array/virtual/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/actual/array/virtual/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/actual/array/virtual/slice": [
  	"es.array.slice"
  ],
  	"core-js/actual/array/virtual/some": [
  	"es.array.some"
  ],
  	"core-js/actual/array/virtual/sort": [
  	"es.array.sort"
  ],
  	"core-js/actual/array/virtual/splice": [
  	"es.array.splice"
  ],
  	"core-js/actual/array/virtual/to-reversed": [
  	"es.array.to-reversed",
  	"esnext.array.to-reversed"
  ],
  	"core-js/actual/array/virtual/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted",
  	"esnext.array.to-sorted"
  ],
  	"core-js/actual/array/virtual/to-spliced": [
  	"es.array.to-spliced",
  	"esnext.array.to-spliced"
  ],
  	"core-js/actual/array/virtual/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/actual/array/virtual/values": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/actual/array/virtual/with": [
  	"es.array.with",
  	"esnext.array.with"
  ],
  	"core-js/actual/array/with": [
  	"es.array.with",
  	"esnext.array.with"
  ],
  	"core-js/actual/async-disposable-stack": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"es.promise",
  	"esnext.suppressed-error.constructor",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.iterator.dispose"
  ],
  	"core-js/actual/async-disposable-stack/constructor": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"es.promise",
  	"esnext.suppressed-error.constructor",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.iterator.dispose"
  ],
  	"core-js/actual/async-iterator": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/async-iterator/async-dispose": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.async-dispose"
  ],
  	"core-js/actual/async-iterator/drop": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.drop"
  ],
  	"core-js/actual/async-iterator/every": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.every"
  ],
  	"core-js/actual/async-iterator/filter": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.filter"
  ],
  	"core-js/actual/async-iterator/find": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.find"
  ],
  	"core-js/actual/async-iterator/flat-map": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.flat-map"
  ],
  	"core-js/actual/async-iterator/for-each": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.for-each"
  ],
  	"core-js/actual/async-iterator/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/async-iterator/map": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.map"
  ],
  	"core-js/actual/async-iterator/reduce": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.reduce"
  ],
  	"core-js/actual/async-iterator/some": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.some"
  ],
  	"core-js/actual/async-iterator/take": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.take"
  ],
  	"core-js/actual/async-iterator/to-array": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.to-array"
  ],
  	"core-js/actual/atob": [
  	"es.error.to-string",
  	"es.object.to-string",
  	"web.atob",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/actual/btoa": [
  	"es.error.to-string",
  	"es.object.to-string",
  	"web.btoa",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/actual/clear-immediate": [
  	"web.immediate"
  ],
  	"core-js/actual/data-view": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.object.to-string",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.set-float16"
  ],
  	"core-js/actual/data-view/get-float16": [
  	"esnext.data-view.get-float16"
  ],
  	"core-js/actual/data-view/set-float16": [
  	"esnext.data-view.set-float16"
  ],
  	"core-js/actual/date": [
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string"
  ],
  	"core-js/actual/date/get-year": [
  	"es.date.get-year"
  ],
  	"core-js/actual/date/now": [
  	"es.date.now"
  ],
  	"core-js/actual/date/set-year": [
  	"es.date.set-year"
  ],
  	"core-js/actual/date/to-gmt-string": [
  	"es.date.to-gmt-string"
  ],
  	"core-js/actual/date/to-iso-string": [
  	"es.date.to-iso-string",
  	"es.date.to-json"
  ],
  	"core-js/actual/date/to-json": [
  	"es.date.to-json"
  ],
  	"core-js/actual/date/to-primitive": [
  	"es.date.to-primitive"
  ],
  	"core-js/actual/date/to-string": [
  	"es.date.to-string"
  ],
  	"core-js/actual/disposable-stack": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"esnext.suppressed-error.constructor",
  	"esnext.disposable-stack.constructor",
  	"esnext.iterator.dispose"
  ],
  	"core-js/actual/disposable-stack/constructor": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"esnext.suppressed-error.constructor",
  	"esnext.disposable-stack.constructor",
  	"esnext.iterator.dispose"
  ],
  	"core-js/actual/dom-collections": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/dom-collections/for-each": [
  	"web.dom-collections.for-each"
  ],
  	"core-js/actual/dom-collections/iterator": [
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/dom-exception": [
  	"es.error.to-string",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/actual/dom-exception/constructor": [
  	"es.error.to-string",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack"
  ],
  	"core-js/actual/dom-exception/to-string-tag": [
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/actual/error": [
  	"es.error.cause",
  	"es.error.to-string"
  ],
  	"core-js/actual/error/constructor": [
  	"es.error.cause"
  ],
  	"core-js/actual/error/to-string": [
  	"es.error.to-string"
  ],
  	"core-js/actual/escape": [
  	"es.escape"
  ],
  	"core-js/actual/function": [
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name",
  	"esnext.function.metadata"
  ],
  	"core-js/actual/function/bind": [
  	"es.function.bind"
  ],
  	"core-js/actual/function/has-instance": [
  	"es.function.has-instance"
  ],
  	"core-js/actual/function/metadata": [
  	"esnext.function.metadata"
  ],
  	"core-js/actual/function/name": [
  	"es.function.name"
  ],
  	"core-js/actual/function/virtual": [
  	"es.function.bind"
  ],
  	"core-js/actual/function/virtual/bind": [
  	"es.function.bind"
  ],
  	"core-js/actual/get-iterator": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/get-iterator-method": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/global-this": [
  	"es.global-this"
  ],
  	"core-js/actual/instance/at": [
  	"es.array.at",
  	"es.string.at-alternative"
  ],
  	"core-js/actual/instance/bind": [
  	"es.function.bind"
  ],
  	"core-js/actual/instance/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/actual/instance/concat": [
  	"es.array.concat"
  ],
  	"core-js/actual/instance/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/actual/instance/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/actual/instance/entries": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/instance/every": [
  	"es.array.every"
  ],
  	"core-js/actual/instance/fill": [
  	"es.array.fill"
  ],
  	"core-js/actual/instance/filter": [
  	"es.array.filter"
  ],
  	"core-js/actual/instance/find": [
  	"es.array.find"
  ],
  	"core-js/actual/instance/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/actual/instance/find-last": [
  	"es.array.find-last",
  	"esnext.array.find-last"
  ],
  	"core-js/actual/instance/find-last-index": [
  	"es.array.find-last-index",
  	"esnext.array.find-last-index"
  ],
  	"core-js/actual/instance/flags": [
  	"es.regexp.flags"
  ],
  	"core-js/actual/instance/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/actual/instance/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/actual/instance/for-each": [
  	"es.array.for-each",
  	"web.dom-collections.for-each"
  ],
  	"core-js/actual/instance/group": [
  	"esnext.array.group"
  ],
  	"core-js/actual/instance/group-by": [
  	"esnext.array.group-by"
  ],
  	"core-js/actual/instance/group-by-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-by-to-map"
  ],
  	"core-js/actual/instance/group-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-to-map"
  ],
  	"core-js/actual/instance/includes": [
  	"es.array.includes",
  	"es.string.includes"
  ],
  	"core-js/actual/instance/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/actual/instance/is-well-formed": [
  	"es.string.is-well-formed"
  ],
  	"core-js/actual/instance/keys": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/instance/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/actual/instance/map": [
  	"es.array.map"
  ],
  	"core-js/actual/instance/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/actual/instance/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/actual/instance/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/actual/instance/push": [
  	"es.array.push"
  ],
  	"core-js/actual/instance/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/actual/instance/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/actual/instance/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/actual/instance/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all"
  ],
  	"core-js/actual/instance/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/actual/instance/slice": [
  	"es.array.slice"
  ],
  	"core-js/actual/instance/some": [
  	"es.array.some"
  ],
  	"core-js/actual/instance/sort": [
  	"es.array.sort"
  ],
  	"core-js/actual/instance/splice": [
  	"es.array.splice"
  ],
  	"core-js/actual/instance/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/actual/instance/to-reversed": [
  	"es.array.to-reversed",
  	"esnext.array.to-reversed"
  ],
  	"core-js/actual/instance/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted",
  	"esnext.array.to-sorted"
  ],
  	"core-js/actual/instance/to-spliced": [
  	"es.array.to-spliced",
  	"esnext.array.to-spliced"
  ],
  	"core-js/actual/instance/to-well-formed": [
  	"es.string.to-well-formed"
  ],
  	"core-js/actual/instance/trim": [
  	"es.string.trim"
  ],
  	"core-js/actual/instance/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/actual/instance/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/actual/instance/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/actual/instance/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/actual/instance/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/actual/instance/values": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/instance/with": [
  	"es.array.with",
  	"esnext.array.with"
  ],
  	"core-js/actual/is-iterable": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/iterator": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.iterator.constructor",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.map",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/iterator/dispose": [
  	"esnext.iterator.dispose"
  ],
  	"core-js/actual/iterator/drop": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.drop"
  ],
  	"core-js/actual/iterator/every": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.every"
  ],
  	"core-js/actual/iterator/filter": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.filter"
  ],
  	"core-js/actual/iterator/find": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.find"
  ],
  	"core-js/actual/iterator/flat-map": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.flat-map"
  ],
  	"core-js/actual/iterator/for-each": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.for-each"
  ],
  	"core-js/actual/iterator/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.iterator.constructor",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.map",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/iterator/map": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.map"
  ],
  	"core-js/actual/iterator/reduce": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.reduce"
  ],
  	"core-js/actual/iterator/some": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.some"
  ],
  	"core-js/actual/iterator/take": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.take"
  ],
  	"core-js/actual/iterator/to-array": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.to-array"
  ],
  	"core-js/actual/iterator/to-async": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.iterator.constructor",
  	"esnext.iterator.to-async"
  ],
  	"core-js/actual/json": [
  	"es.date.to-json",
  	"es.json.stringify",
  	"es.json.to-string-tag",
  	"es.object.create",
  	"es.object.freeze",
  	"es.object.keys",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json"
  ],
  	"core-js/actual/json/is-raw-json": [
  	"esnext.json.is-raw-json"
  ],
  	"core-js/actual/json/parse": [
  	"es.object.keys",
  	"esnext.json.parse"
  ],
  	"core-js/actual/json/raw-json": [
  	"es.object.create",
  	"es.object.freeze",
  	"esnext.json.raw-json"
  ],
  	"core-js/actual/json/stringify": [
  	"es.date.to-json",
  	"es.json.stringify"
  ],
  	"core-js/actual/json/to-string-tag": [
  	"es.json.to-string-tag"
  ],
  	"core-js/actual/map": [
  	"es.array.iterator",
  	"es.map",
  	"es.map.group-by",
  	"es.object.to-string",
  	"es.string.iterator",
  	"esnext.map.group-by",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/map/group-by": [
  	"es.map",
  	"es.map.group-by",
  	"es.object.to-string",
  	"esnext.map.group-by"
  ],
  	"core-js/actual/math": [
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc",
  	"esnext.math.f16round"
  ],
  	"core-js/actual/math/acosh": [
  	"es.math.acosh"
  ],
  	"core-js/actual/math/asinh": [
  	"es.math.asinh"
  ],
  	"core-js/actual/math/atanh": [
  	"es.math.atanh"
  ],
  	"core-js/actual/math/cbrt": [
  	"es.math.cbrt"
  ],
  	"core-js/actual/math/clz32": [
  	"es.math.clz32"
  ],
  	"core-js/actual/math/cosh": [
  	"es.math.cosh"
  ],
  	"core-js/actual/math/expm1": [
  	"es.math.expm1"
  ],
  	"core-js/actual/math/f16round": [
  	"esnext.math.f16round"
  ],
  	"core-js/actual/math/fround": [
  	"es.math.fround"
  ],
  	"core-js/actual/math/hypot": [
  	"es.math.hypot"
  ],
  	"core-js/actual/math/imul": [
  	"es.math.imul"
  ],
  	"core-js/actual/math/log10": [
  	"es.math.log10"
  ],
  	"core-js/actual/math/log1p": [
  	"es.math.log1p"
  ],
  	"core-js/actual/math/log2": [
  	"es.math.log2"
  ],
  	"core-js/actual/math/sign": [
  	"es.math.sign"
  ],
  	"core-js/actual/math/sinh": [
  	"es.math.sinh"
  ],
  	"core-js/actual/math/tanh": [
  	"es.math.tanh"
  ],
  	"core-js/actual/math/to-string-tag": [
  	"es.math.to-string-tag"
  ],
  	"core-js/actual/math/trunc": [
  	"es.math.trunc"
  ],
  	"core-js/actual/number": [
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision"
  ],
  	"core-js/actual/number/constructor": [
  	"es.number.constructor"
  ],
  	"core-js/actual/number/epsilon": [
  	"es.number.epsilon"
  ],
  	"core-js/actual/number/is-finite": [
  	"es.number.is-finite"
  ],
  	"core-js/actual/number/is-integer": [
  	"es.number.is-integer"
  ],
  	"core-js/actual/number/is-nan": [
  	"es.number.is-nan"
  ],
  	"core-js/actual/number/is-safe-integer": [
  	"es.number.is-safe-integer"
  ],
  	"core-js/actual/number/max-safe-integer": [
  	"es.number.max-safe-integer"
  ],
  	"core-js/actual/number/min-safe-integer": [
  	"es.number.min-safe-integer"
  ],
  	"core-js/actual/number/parse-float": [
  	"es.number.parse-float"
  ],
  	"core-js/actual/number/parse-int": [
  	"es.number.parse-int"
  ],
  	"core-js/actual/number/to-exponential": [
  	"es.number.to-exponential"
  ],
  	"core-js/actual/number/to-fixed": [
  	"es.number.to-fixed"
  ],
  	"core-js/actual/number/to-precision": [
  	"es.number.to-precision"
  ],
  	"core-js/actual/number/virtual": [
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision"
  ],
  	"core-js/actual/number/virtual/to-exponential": [
  	"es.number.to-exponential"
  ],
  	"core-js/actual/number/virtual/to-fixed": [
  	"es.number.to-fixed"
  ],
  	"core-js/actual/number/virtual/to-precision": [
  	"es.number.to-precision"
  ],
  	"core-js/actual/object": [
  	"es.symbol",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.reflect.to-string-tag",
  	"esnext.object.group-by",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/object/assign": [
  	"es.object.assign"
  ],
  	"core-js/actual/object/create": [
  	"es.object.create"
  ],
  	"core-js/actual/object/define-getter": [
  	"es.object.define-getter"
  ],
  	"core-js/actual/object/define-properties": [
  	"es.object.define-properties"
  ],
  	"core-js/actual/object/define-property": [
  	"es.object.define-property"
  ],
  	"core-js/actual/object/define-setter": [
  	"es.object.define-setter"
  ],
  	"core-js/actual/object/entries": [
  	"es.object.entries"
  ],
  	"core-js/actual/object/freeze": [
  	"es.object.freeze"
  ],
  	"core-js/actual/object/from-entries": [
  	"es.array.iterator",
  	"es.object.from-entries",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/object/get-own-property-descriptor": [
  	"es.object.get-own-property-descriptor"
  ],
  	"core-js/actual/object/get-own-property-descriptors": [
  	"es.object.get-own-property-descriptors"
  ],
  	"core-js/actual/object/get-own-property-names": [
  	"es.object.get-own-property-names"
  ],
  	"core-js/actual/object/get-own-property-symbols": [
  	"es.symbol"
  ],
  	"core-js/actual/object/get-prototype-of": [
  	"es.object.get-prototype-of"
  ],
  	"core-js/actual/object/group-by": [
  	"es.object.create",
  	"es.object.group-by",
  	"esnext.object.group-by"
  ],
  	"core-js/actual/object/has-own": [
  	"es.object.has-own"
  ],
  	"core-js/actual/object/is": [
  	"es.object.is"
  ],
  	"core-js/actual/object/is-extensible": [
  	"es.object.is-extensible"
  ],
  	"core-js/actual/object/is-frozen": [
  	"es.object.is-frozen"
  ],
  	"core-js/actual/object/is-sealed": [
  	"es.object.is-sealed"
  ],
  	"core-js/actual/object/keys": [
  	"es.object.keys"
  ],
  	"core-js/actual/object/lookup-getter": [
  	"es.object.lookup-getter"
  ],
  	"core-js/actual/object/lookup-setter": [
  	"es.object.lookup-setter"
  ],
  	"core-js/actual/object/prevent-extensions": [
  	"es.object.prevent-extensions"
  ],
  	"core-js/actual/object/proto": [
  	"es.object.proto"
  ],
  	"core-js/actual/object/seal": [
  	"es.object.seal"
  ],
  	"core-js/actual/object/set-prototype-of": [
  	"es.object.set-prototype-of"
  ],
  	"core-js/actual/object/to-string": [
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/actual/object/values": [
  	"es.object.values"
  ],
  	"core-js/actual/parse-float": [
  	"es.parse-float"
  ],
  	"core-js/actual/parse-int": [
  	"es.parse-int"
  ],
  	"core-js/actual/promise": [
  	"es.aggregate-error",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.string.iterator",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/promise/all-settled": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/promise/any": [
  	"es.aggregate-error",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.any",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/promise/finally": [
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.finally"
  ],
  	"core-js/actual/promise/try": [
  	"es.promise",
  	"esnext.promise.try"
  ],
  	"core-js/actual/promise/with-resolvers": [
  	"es.promise",
  	"es.promise.with-resolvers",
  	"esnext.promise.with-resolvers"
  ],
  	"core-js/actual/queue-microtask": [
  	"web.queue-microtask"
  ],
  	"core-js/actual/reflect": [
  	"es.object.to-string",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/actual/reflect/apply": [
  	"es.reflect.apply"
  ],
  	"core-js/actual/reflect/construct": [
  	"es.reflect.construct"
  ],
  	"core-js/actual/reflect/define-property": [
  	"es.reflect.define-property"
  ],
  	"core-js/actual/reflect/delete-property": [
  	"es.reflect.delete-property"
  ],
  	"core-js/actual/reflect/get": [
  	"es.reflect.get"
  ],
  	"core-js/actual/reflect/get-own-property-descriptor": [
  	"es.reflect.get-own-property-descriptor"
  ],
  	"core-js/actual/reflect/get-prototype-of": [
  	"es.reflect.get-prototype-of"
  ],
  	"core-js/actual/reflect/has": [
  	"es.reflect.has"
  ],
  	"core-js/actual/reflect/is-extensible": [
  	"es.reflect.is-extensible"
  ],
  	"core-js/actual/reflect/own-keys": [
  	"es.reflect.own-keys"
  ],
  	"core-js/actual/reflect/prevent-extensions": [
  	"es.reflect.prevent-extensions"
  ],
  	"core-js/actual/reflect/set": [
  	"es.reflect.set"
  ],
  	"core-js/actual/reflect/set-prototype-of": [
  	"es.reflect.set-prototype-of"
  ],
  	"core-js/actual/reflect/to-string-tag": [
  	"es.reflect.to-string-tag"
  ],
  	"core-js/actual/regexp": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.string.match",
  	"es.string.replace",
  	"es.string.search",
  	"es.string.split",
  	"esnext.regexp.escape"
  ],
  	"core-js/actual/regexp/constructor": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.sticky"
  ],
  	"core-js/actual/regexp/dot-all": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec"
  ],
  	"core-js/actual/regexp/escape": [
  	"esnext.regexp.escape"
  ],
  	"core-js/actual/regexp/flags": [
  	"es.regexp.flags"
  ],
  	"core-js/actual/regexp/match": [
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/actual/regexp/replace": [
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/actual/regexp/search": [
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/actual/regexp/split": [
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/actual/regexp/sticky": [
  	"es.regexp.constructor",
  	"es.regexp.exec",
  	"es.regexp.sticky"
  ],
  	"core-js/actual/regexp/test": [
  	"es.regexp.exec",
  	"es.regexp.test"
  ],
  	"core-js/actual/regexp/to-string": [
  	"es.regexp.to-string"
  ],
  	"core-js/actual/self": [
  	"web.self"
  ],
  	"core-js/actual/set": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.iterator",
  	"esnext.set.difference.v2",
  	"esnext.set.intersection.v2",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.union.v2",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/set-immediate": [
  	"web.immediate"
  ],
  	"core-js/actual/set-interval": [
  	"web.timers"
  ],
  	"core-js/actual/set-timeout": [
  	"web.timers"
  ],
  	"core-js/actual/set/difference": [
  	"es.set",
  	"es.set.difference.v2",
  	"esnext.set.difference.v2"
  ],
  	"core-js/actual/set/intersection": [
  	"es.set",
  	"es.set.intersection.v2",
  	"esnext.set.intersection.v2"
  ],
  	"core-js/actual/set/is-disjoint-from": [
  	"es.set",
  	"es.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from.v2"
  ],
  	"core-js/actual/set/is-subset-of": [
  	"es.set",
  	"es.set.is-subset-of.v2",
  	"esnext.set.is-subset-of.v2"
  ],
  	"core-js/actual/set/is-superset-of": [
  	"es.set",
  	"es.set.is-superset-of.v2",
  	"esnext.set.is-superset-of.v2"
  ],
  	"core-js/actual/set/symmetric-difference": [
  	"es.set",
  	"es.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference.v2"
  ],
  	"core-js/actual/set/union": [
  	"es.set",
  	"es.set.union.v2",
  	"esnext.set.union.v2"
  ],
  	"core-js/actual/string": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"esnext.string.is-well-formed",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/actual/string/anchor": [
  	"es.string.anchor"
  ],
  	"core-js/actual/string/at": [
  	"es.string.at-alternative"
  ],
  	"core-js/actual/string/big": [
  	"es.string.big"
  ],
  	"core-js/actual/string/blink": [
  	"es.string.blink"
  ],
  	"core-js/actual/string/bold": [
  	"es.string.bold"
  ],
  	"core-js/actual/string/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/actual/string/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/actual/string/fixed": [
  	"es.string.fixed"
  ],
  	"core-js/actual/string/fontcolor": [
  	"es.string.fontcolor"
  ],
  	"core-js/actual/string/fontsize": [
  	"es.string.fontsize"
  ],
  	"core-js/actual/string/from-code-point": [
  	"es.string.from-code-point"
  ],
  	"core-js/actual/string/includes": [
  	"es.string.includes"
  ],
  	"core-js/actual/string/is-well-formed": [
  	"es.string.is-well-formed",
  	"esnext.string.is-well-formed"
  ],
  	"core-js/actual/string/italics": [
  	"es.string.italics"
  ],
  	"core-js/actual/string/iterator": [
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/actual/string/link": [
  	"es.string.link"
  ],
  	"core-js/actual/string/match": [
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/actual/string/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/actual/string/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/actual/string/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/actual/string/raw": [
  	"es.string.raw"
  ],
  	"core-js/actual/string/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/actual/string/replace": [
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/actual/string/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all"
  ],
  	"core-js/actual/string/search": [
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/actual/string/small": [
  	"es.string.small"
  ],
  	"core-js/actual/string/split": [
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/actual/string/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/actual/string/strike": [
  	"es.string.strike"
  ],
  	"core-js/actual/string/sub": [
  	"es.string.sub"
  ],
  	"core-js/actual/string/substr": [
  	"es.string.substr"
  ],
  	"core-js/actual/string/sup": [
  	"es.string.sup"
  ],
  	"core-js/actual/string/to-well-formed": [
  	"es.string.to-well-formed",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/actual/string/trim": [
  	"es.string.trim"
  ],
  	"core-js/actual/string/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/actual/string/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/actual/string/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/actual/string/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/actual/string/virtual": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.includes",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"esnext.string.is-well-formed",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/actual/string/virtual/anchor": [
  	"es.string.anchor"
  ],
  	"core-js/actual/string/virtual/at": [
  	"es.string.at-alternative"
  ],
  	"core-js/actual/string/virtual/big": [
  	"es.string.big"
  ],
  	"core-js/actual/string/virtual/blink": [
  	"es.string.blink"
  ],
  	"core-js/actual/string/virtual/bold": [
  	"es.string.bold"
  ],
  	"core-js/actual/string/virtual/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/actual/string/virtual/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/actual/string/virtual/fixed": [
  	"es.string.fixed"
  ],
  	"core-js/actual/string/virtual/fontcolor": [
  	"es.string.fontcolor"
  ],
  	"core-js/actual/string/virtual/fontsize": [
  	"es.string.fontsize"
  ],
  	"core-js/actual/string/virtual/includes": [
  	"es.string.includes"
  ],
  	"core-js/actual/string/virtual/is-well-formed": [
  	"es.string.is-well-formed",
  	"esnext.string.is-well-formed"
  ],
  	"core-js/actual/string/virtual/italics": [
  	"es.string.italics"
  ],
  	"core-js/actual/string/virtual/iterator": [
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/actual/string/virtual/link": [
  	"es.string.link"
  ],
  	"core-js/actual/string/virtual/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/actual/string/virtual/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/actual/string/virtual/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/actual/string/virtual/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/actual/string/virtual/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all"
  ],
  	"core-js/actual/string/virtual/small": [
  	"es.string.small"
  ],
  	"core-js/actual/string/virtual/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/actual/string/virtual/strike": [
  	"es.string.strike"
  ],
  	"core-js/actual/string/virtual/sub": [
  	"es.string.sub"
  ],
  	"core-js/actual/string/virtual/substr": [
  	"es.string.substr"
  ],
  	"core-js/actual/string/virtual/sup": [
  	"es.string.sup"
  ],
  	"core-js/actual/string/virtual/to-well-formed": [
  	"es.string.to-well-formed",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/actual/string/virtual/trim": [
  	"es.string.trim"
  ],
  	"core-js/actual/string/virtual/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/actual/string/virtual/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/actual/string/virtual/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/actual/string/virtual/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/actual/structured-clone": [
  	"es.error.to-string",
  	"es.array.iterator",
  	"es.map",
  	"es.object.keys",
  	"es.object.to-string",
  	"es.set",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.structured-clone"
  ],
  	"core-js/actual/suppressed-error": [
  ],
  	"core-js/actual/symbol": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.array.concat",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag",
  	"esnext.function.metadata",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.dispose",
  	"esnext.symbol.metadata",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/symbol/async-dispose": [
  	"esnext.symbol.async-dispose"
  ],
  	"core-js/actual/symbol/async-iterator": [
  	"es.symbol.async-iterator"
  ],
  	"core-js/actual/symbol/description": [
  	"es.symbol.description"
  ],
  	"core-js/actual/symbol/dispose": [
  	"esnext.symbol.dispose"
  ],
  	"core-js/actual/symbol/for": [
  	"es.symbol"
  ],
  	"core-js/actual/symbol/has-instance": [
  	"es.symbol.has-instance",
  	"es.function.has-instance"
  ],
  	"core-js/actual/symbol/is-concat-spreadable": [
  	"es.symbol.is-concat-spreadable",
  	"es.array.concat"
  ],
  	"core-js/actual/symbol/iterator": [
  	"es.symbol.iterator",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/symbol/key-for": [
  	"es.symbol"
  ],
  	"core-js/actual/symbol/match": [
  	"es.symbol.match",
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/actual/symbol/match-all": [
  	"es.symbol.match-all",
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/actual/symbol/metadata": [
  	"esnext.function.metadata",
  	"esnext.symbol.metadata"
  ],
  	"core-js/actual/symbol/replace": [
  	"es.symbol.replace",
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/actual/symbol/search": [
  	"es.symbol.search",
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/actual/symbol/species": [
  	"es.symbol.species"
  ],
  	"core-js/actual/symbol/split": [
  	"es.symbol.split",
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/actual/symbol/to-primitive": [
  	"es.symbol.to-primitive",
  	"es.date.to-primitive"
  ],
  	"core-js/actual/symbol/to-string-tag": [
  	"es.symbol.to-string-tag",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/actual/symbol/unscopables": [
  	"es.symbol.unscopables"
  ],
  	"core-js/actual/typed-array": [
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/at": [
  	"es.typed-array.at"
  ],
  	"core-js/actual/typed-array/copy-within": [
  	"es.typed-array.copy-within"
  ],
  	"core-js/actual/typed-array/entries": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/actual/typed-array/every": [
  	"es.typed-array.every"
  ],
  	"core-js/actual/typed-array/fill": [
  	"es.typed-array.fill"
  ],
  	"core-js/actual/typed-array/filter": [
  	"es.typed-array.filter"
  ],
  	"core-js/actual/typed-array/find": [
  	"es.typed-array.find"
  ],
  	"core-js/actual/typed-array/find-index": [
  	"es.typed-array.find-index"
  ],
  	"core-js/actual/typed-array/find-last": [
  	"es.typed-array.find-last",
  	"esnext.typed-array.find-last"
  ],
  	"core-js/actual/typed-array/find-last-index": [
  	"es.typed-array.find-last-index",
  	"esnext.typed-array.find-last-index"
  ],
  	"core-js/actual/typed-array/float32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.float32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/float64-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.float64-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/for-each": [
  	"es.typed-array.for-each"
  ],
  	"core-js/actual/typed-array/from": [
  	"es.typed-array.from"
  ],
  	"core-js/actual/typed-array/from-base64": [
  	"esnext.uint8-array.from-base64"
  ],
  	"core-js/actual/typed-array/from-hex": [
  	"esnext.uint8-array.from-hex"
  ],
  	"core-js/actual/typed-array/includes": [
  	"es.typed-array.includes"
  ],
  	"core-js/actual/typed-array/index-of": [
  	"es.typed-array.index-of"
  ],
  	"core-js/actual/typed-array/int16-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.int16-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/int32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.int32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/int8-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.int8-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/iterator": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/actual/typed-array/join": [
  	"es.typed-array.join"
  ],
  	"core-js/actual/typed-array/keys": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/actual/typed-array/last-index-of": [
  	"es.typed-array.last-index-of"
  ],
  	"core-js/actual/typed-array/map": [
  	"es.typed-array.map"
  ],
  	"core-js/actual/typed-array/methods": [
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/of": [
  	"es.typed-array.of"
  ],
  	"core-js/actual/typed-array/reduce": [
  	"es.typed-array.reduce"
  ],
  	"core-js/actual/typed-array/reduce-right": [
  	"es.typed-array.reduce-right"
  ],
  	"core-js/actual/typed-array/reverse": [
  	"es.typed-array.reverse"
  ],
  	"core-js/actual/typed-array/set": [
  	"es.typed-array.set"
  ],
  	"core-js/actual/typed-array/set-from-base64": [
  	"esnext.uint8-array.set-from-base64"
  ],
  	"core-js/actual/typed-array/set-from-hex": [
  	"esnext.uint8-array.set-from-hex"
  ],
  	"core-js/actual/typed-array/slice": [
  	"es.typed-array.slice"
  ],
  	"core-js/actual/typed-array/some": [
  	"es.typed-array.some"
  ],
  	"core-js/actual/typed-array/sort": [
  	"es.typed-array.sort"
  ],
  	"core-js/actual/typed-array/subarray": [
  	"es.typed-array.subarray"
  ],
  	"core-js/actual/typed-array/to-base64": [
  	"esnext.uint8-array.to-base64"
  ],
  	"core-js/actual/typed-array/to-hex": [
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/to-locale-string": [
  	"es.typed-array.to-locale-string"
  ],
  	"core-js/actual/typed-array/to-reversed": [
  	"es.typed-array.to-reversed",
  	"esnext.typed-array.to-reversed"
  ],
  	"core-js/actual/typed-array/to-sorted": [
  	"es.typed-array.sort",
  	"es.typed-array.to-sorted",
  	"esnext.typed-array.to-sorted"
  ],
  	"core-js/actual/typed-array/to-spliced": [
  	"esnext.typed-array.to-spliced"
  ],
  	"core-js/actual/typed-array/to-string": [
  	"es.typed-array.to-string"
  ],
  	"core-js/actual/typed-array/uint16-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint16-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/uint32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/uint8-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint8-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/uint8-clamped-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/actual/typed-array/values": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/actual/typed-array/with": [
  	"es.typed-array.with",
  	"esnext.typed-array.with"
  ],
  	"core-js/actual/unescape": [
  	"es.unescape"
  ],
  	"core-js/actual/url": [
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/actual/url-search-params": [
  	"web.dom-collections.iterator",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/actual/url/can-parse": [
  	"web.url",
  	"web.url.can-parse"
  ],
  	"core-js/actual/url/parse": [
  	"web.url",
  	"web.url.parse"
  ],
  	"core-js/actual/url/to-json": [
  	"web.url.to-json"
  ],
  	"core-js/actual/weak-map": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.weak-map",
  	"web.dom-collections.iterator"
  ],
  	"core-js/actual/weak-set": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.weak-set",
  	"web.dom-collections.iterator"
  ],
  	"core-js/es": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.error.cause",
  	"es.error.to-string",
  	"es.aggregate-error",
  	"es.aggregate-error.cause",
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string",
  	"es.escape",
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name",
  	"es.global-this",
  	"es.json.stringify",
  	"es.json.to-string-tag",
  	"es.map",
  	"es.map.group-by",
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc",
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.parse-float",
  	"es.parse-int",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag",
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"es.unescape",
  	"es.weak-map",
  	"es.weak-set"
  ],
  	"core-js/es/aggregate-error": [
  ],
  	"core-js/es/array": [
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/es/array-buffer": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.object.to-string"
  ],
  	"core-js/es/array-buffer/constructor": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.object.to-string"
  ],
  	"core-js/es/array-buffer/detached": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.array-buffer.detached"
  ],
  	"core-js/es/array-buffer/is-view": [
  	"es.array-buffer.is-view"
  ],
  	"core-js/es/array-buffer/slice": [
  	"es.array-buffer.slice"
  ],
  	"core-js/es/array-buffer/transfer": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.transfer"
  ],
  	"core-js/es/array-buffer/transfer-to-fixed-length": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/es/array/at": [
  	"es.array.at"
  ],
  	"core-js/es/array/concat": [
  	"es.array.concat"
  ],
  	"core-js/es/array/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/es/array/entries": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/es/array/every": [
  	"es.array.every"
  ],
  	"core-js/es/array/fill": [
  	"es.array.fill"
  ],
  	"core-js/es/array/filter": [
  	"es.array.filter"
  ],
  	"core-js/es/array/find": [
  	"es.array.find"
  ],
  	"core-js/es/array/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/es/array/find-last": [
  	"es.array.find-last"
  ],
  	"core-js/es/array/find-last-index": [
  	"es.array.find-last-index"
  ],
  	"core-js/es/array/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/es/array/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/es/array/for-each": [
  	"es.array.for-each"
  ],
  	"core-js/es/array/from": [
  	"es.array.from",
  	"es.string.iterator"
  ],
  	"core-js/es/array/includes": [
  	"es.array.includes"
  ],
  	"core-js/es/array/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/es/array/is-array": [
  	"es.array.is-array"
  ],
  	"core-js/es/array/iterator": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/es/array/join": [
  	"es.array.join"
  ],
  	"core-js/es/array/keys": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/es/array/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/es/array/map": [
  	"es.array.map"
  ],
  	"core-js/es/array/of": [
  	"es.array.of"
  ],
  	"core-js/es/array/push": [
  	"es.array.push"
  ],
  	"core-js/es/array/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/es/array/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/es/array/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/es/array/slice": [
  	"es.array.slice"
  ],
  	"core-js/es/array/some": [
  	"es.array.some"
  ],
  	"core-js/es/array/sort": [
  	"es.array.sort"
  ],
  	"core-js/es/array/splice": [
  	"es.array.splice"
  ],
  	"core-js/es/array/to-reversed": [
  	"es.array.to-reversed"
  ],
  	"core-js/es/array/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted"
  ],
  	"core-js/es/array/to-spliced": [
  	"es.array.to-spliced"
  ],
  	"core-js/es/array/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/es/array/values": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/es/array/virtual": [
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.object.to-string"
  ],
  	"core-js/es/array/virtual/at": [
  	"es.array.at"
  ],
  	"core-js/es/array/virtual/concat": [
  	"es.array.concat"
  ],
  	"core-js/es/array/virtual/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/es/array/virtual/entries": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/es/array/virtual/every": [
  	"es.array.every"
  ],
  	"core-js/es/array/virtual/fill": [
  	"es.array.fill"
  ],
  	"core-js/es/array/virtual/filter": [
  	"es.array.filter"
  ],
  	"core-js/es/array/virtual/find": [
  	"es.array.find"
  ],
  	"core-js/es/array/virtual/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/es/array/virtual/find-last": [
  	"es.array.find-last"
  ],
  	"core-js/es/array/virtual/find-last-index": [
  	"es.array.find-last-index"
  ],
  	"core-js/es/array/virtual/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/es/array/virtual/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/es/array/virtual/for-each": [
  	"es.array.for-each"
  ],
  	"core-js/es/array/virtual/includes": [
  	"es.array.includes"
  ],
  	"core-js/es/array/virtual/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/es/array/virtual/iterator": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/es/array/virtual/join": [
  	"es.array.join"
  ],
  	"core-js/es/array/virtual/keys": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/es/array/virtual/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/es/array/virtual/map": [
  	"es.array.map"
  ],
  	"core-js/es/array/virtual/push": [
  	"es.array.push"
  ],
  	"core-js/es/array/virtual/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/es/array/virtual/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/es/array/virtual/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/es/array/virtual/slice": [
  	"es.array.slice"
  ],
  	"core-js/es/array/virtual/some": [
  	"es.array.some"
  ],
  	"core-js/es/array/virtual/sort": [
  	"es.array.sort"
  ],
  	"core-js/es/array/virtual/splice": [
  	"es.array.splice"
  ],
  	"core-js/es/array/virtual/to-reversed": [
  	"es.array.to-reversed"
  ],
  	"core-js/es/array/virtual/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted"
  ],
  	"core-js/es/array/virtual/to-spliced": [
  	"es.array.to-spliced"
  ],
  	"core-js/es/array/virtual/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/es/array/virtual/values": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/es/array/virtual/with": [
  	"es.array.with"
  ],
  	"core-js/es/array/with": [
  	"es.array.with"
  ],
  	"core-js/es/data-view": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.object.to-string"
  ],
  	"core-js/es/date": [
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string"
  ],
  	"core-js/es/date/get-year": [
  	"es.date.get-year"
  ],
  	"core-js/es/date/now": [
  	"es.date.now"
  ],
  	"core-js/es/date/set-year": [
  	"es.date.set-year"
  ],
  	"core-js/es/date/to-gmt-string": [
  	"es.date.to-gmt-string"
  ],
  	"core-js/es/date/to-iso-string": [
  	"es.date.to-iso-string",
  	"es.date.to-json"
  ],
  	"core-js/es/date/to-json": [
  	"es.date.to-json"
  ],
  	"core-js/es/date/to-primitive": [
  	"es.date.to-primitive"
  ],
  	"core-js/es/date/to-string": [
  	"es.date.to-string"
  ],
  	"core-js/es/error": [
  	"es.error.cause",
  	"es.error.to-string"
  ],
  	"core-js/es/error/constructor": [
  	"es.error.cause"
  ],
  	"core-js/es/error/to-string": [
  	"es.error.to-string"
  ],
  	"core-js/es/escape": [
  	"es.escape"
  ],
  	"core-js/es/function": [
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name"
  ],
  	"core-js/es/function/bind": [
  	"es.function.bind"
  ],
  	"core-js/es/function/has-instance": [
  	"es.function.has-instance"
  ],
  	"core-js/es/function/name": [
  	"es.function.name"
  ],
  	"core-js/es/function/virtual": [
  	"es.function.bind"
  ],
  	"core-js/es/function/virtual/bind": [
  	"es.function.bind"
  ],
  	"core-js/es/get-iterator": [
  	"es.array.iterator",
  	"es.string.iterator"
  ],
  	"core-js/es/get-iterator-method": [
  	"es.array.iterator",
  	"es.string.iterator"
  ],
  	"core-js/es/global-this": [
  	"es.global-this"
  ],
  	"core-js/es/instance/at": [
  	"es.array.at",
  	"es.string.at-alternative"
  ],
  	"core-js/es/instance/bind": [
  	"es.function.bind"
  ],
  	"core-js/es/instance/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/es/instance/concat": [
  	"es.array.concat"
  ],
  	"core-js/es/instance/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/es/instance/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/es/instance/entries": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/es/instance/every": [
  	"es.array.every"
  ],
  	"core-js/es/instance/fill": [
  	"es.array.fill"
  ],
  	"core-js/es/instance/filter": [
  	"es.array.filter"
  ],
  	"core-js/es/instance/find": [
  	"es.array.find"
  ],
  	"core-js/es/instance/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/es/instance/find-last": [
  	"es.array.find-last"
  ],
  	"core-js/es/instance/find-last-index": [
  	"es.array.find-last-index"
  ],
  	"core-js/es/instance/flags": [
  	"es.regexp.flags"
  ],
  	"core-js/es/instance/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/es/instance/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/es/instance/for-each": [
  	"es.array.for-each"
  ],
  	"core-js/es/instance/includes": [
  	"es.array.includes",
  	"es.string.includes"
  ],
  	"core-js/es/instance/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/es/instance/is-well-formed": [
  	"es.string.is-well-formed"
  ],
  	"core-js/es/instance/keys": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/es/instance/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/es/instance/map": [
  	"es.array.map"
  ],
  	"core-js/es/instance/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/es/instance/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/es/instance/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/es/instance/push": [
  	"es.array.push"
  ],
  	"core-js/es/instance/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/es/instance/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/es/instance/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/es/instance/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all"
  ],
  	"core-js/es/instance/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/es/instance/slice": [
  	"es.array.slice"
  ],
  	"core-js/es/instance/some": [
  	"es.array.some"
  ],
  	"core-js/es/instance/sort": [
  	"es.array.sort"
  ],
  	"core-js/es/instance/splice": [
  	"es.array.splice"
  ],
  	"core-js/es/instance/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/es/instance/to-reversed": [
  	"es.array.to-reversed"
  ],
  	"core-js/es/instance/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted"
  ],
  	"core-js/es/instance/to-spliced": [
  	"es.array.to-spliced"
  ],
  	"core-js/es/instance/to-well-formed": [
  	"es.string.to-well-formed"
  ],
  	"core-js/es/instance/trim": [
  	"es.string.trim"
  ],
  	"core-js/es/instance/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/es/instance/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/es/instance/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/es/instance/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/es/instance/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/es/instance/values": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/es/instance/with": [
  	"es.array.with"
  ],
  	"core-js/es/is-iterable": [
  	"es.array.iterator",
  	"es.string.iterator"
  ],
  	"core-js/es/json": [
  	"es.date.to-json",
  	"es.json.stringify",
  	"es.json.to-string-tag"
  ],
  	"core-js/es/json/stringify": [
  	"es.date.to-json",
  	"es.json.stringify"
  ],
  	"core-js/es/json/to-string-tag": [
  	"es.json.to-string-tag"
  ],
  	"core-js/es/map": [
  	"es.array.iterator",
  	"es.map",
  	"es.map.group-by",
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/es/map/group-by": [
  	"es.map",
  	"es.map.group-by",
  	"es.object.to-string"
  ],
  	"core-js/es/math": [
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc"
  ],
  	"core-js/es/math/acosh": [
  	"es.math.acosh"
  ],
  	"core-js/es/math/asinh": [
  	"es.math.asinh"
  ],
  	"core-js/es/math/atanh": [
  	"es.math.atanh"
  ],
  	"core-js/es/math/cbrt": [
  	"es.math.cbrt"
  ],
  	"core-js/es/math/clz32": [
  	"es.math.clz32"
  ],
  	"core-js/es/math/cosh": [
  	"es.math.cosh"
  ],
  	"core-js/es/math/expm1": [
  	"es.math.expm1"
  ],
  	"core-js/es/math/fround": [
  	"es.math.fround"
  ],
  	"core-js/es/math/hypot": [
  	"es.math.hypot"
  ],
  	"core-js/es/math/imul": [
  	"es.math.imul"
  ],
  	"core-js/es/math/log10": [
  	"es.math.log10"
  ],
  	"core-js/es/math/log1p": [
  	"es.math.log1p"
  ],
  	"core-js/es/math/log2": [
  	"es.math.log2"
  ],
  	"core-js/es/math/sign": [
  	"es.math.sign"
  ],
  	"core-js/es/math/sinh": [
  	"es.math.sinh"
  ],
  	"core-js/es/math/tanh": [
  	"es.math.tanh"
  ],
  	"core-js/es/math/to-string-tag": [
  	"es.math.to-string-tag"
  ],
  	"core-js/es/math/trunc": [
  	"es.math.trunc"
  ],
  	"core-js/es/number": [
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision"
  ],
  	"core-js/es/number/constructor": [
  	"es.number.constructor"
  ],
  	"core-js/es/number/epsilon": [
  	"es.number.epsilon"
  ],
  	"core-js/es/number/is-finite": [
  	"es.number.is-finite"
  ],
  	"core-js/es/number/is-integer": [
  	"es.number.is-integer"
  ],
  	"core-js/es/number/is-nan": [
  	"es.number.is-nan"
  ],
  	"core-js/es/number/is-safe-integer": [
  	"es.number.is-safe-integer"
  ],
  	"core-js/es/number/max-safe-integer": [
  	"es.number.max-safe-integer"
  ],
  	"core-js/es/number/min-safe-integer": [
  	"es.number.min-safe-integer"
  ],
  	"core-js/es/number/parse-float": [
  	"es.number.parse-float"
  ],
  	"core-js/es/number/parse-int": [
  	"es.number.parse-int"
  ],
  	"core-js/es/number/to-exponential": [
  	"es.number.to-exponential"
  ],
  	"core-js/es/number/to-fixed": [
  	"es.number.to-fixed"
  ],
  	"core-js/es/number/to-precision": [
  	"es.number.to-precision"
  ],
  	"core-js/es/number/virtual": [
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision"
  ],
  	"core-js/es/number/virtual/to-exponential": [
  	"es.number.to-exponential"
  ],
  	"core-js/es/number/virtual/to-fixed": [
  	"es.number.to-fixed"
  ],
  	"core-js/es/number/virtual/to-precision": [
  	"es.number.to-precision"
  ],
  	"core-js/es/object": [
  	"es.symbol",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/es/object/assign": [
  	"es.object.assign"
  ],
  	"core-js/es/object/create": [
  	"es.object.create"
  ],
  	"core-js/es/object/define-getter": [
  	"es.object.define-getter"
  ],
  	"core-js/es/object/define-properties": [
  	"es.object.define-properties"
  ],
  	"core-js/es/object/define-property": [
  	"es.object.define-property"
  ],
  	"core-js/es/object/define-setter": [
  	"es.object.define-setter"
  ],
  	"core-js/es/object/entries": [
  	"es.object.entries"
  ],
  	"core-js/es/object/freeze": [
  	"es.object.freeze"
  ],
  	"core-js/es/object/from-entries": [
  	"es.array.iterator",
  	"es.object.from-entries"
  ],
  	"core-js/es/object/get-own-property-descriptor": [
  	"es.object.get-own-property-descriptor"
  ],
  	"core-js/es/object/get-own-property-descriptors": [
  	"es.object.get-own-property-descriptors"
  ],
  	"core-js/es/object/get-own-property-names": [
  	"es.object.get-own-property-names"
  ],
  	"core-js/es/object/get-own-property-symbols": [
  	"es.symbol"
  ],
  	"core-js/es/object/get-prototype-of": [
  	"es.object.get-prototype-of"
  ],
  	"core-js/es/object/group-by": [
  	"es.object.create",
  	"es.object.group-by"
  ],
  	"core-js/es/object/has-own": [
  	"es.object.has-own"
  ],
  	"core-js/es/object/is": [
  	"es.object.is"
  ],
  	"core-js/es/object/is-extensible": [
  	"es.object.is-extensible"
  ],
  	"core-js/es/object/is-frozen": [
  	"es.object.is-frozen"
  ],
  	"core-js/es/object/is-sealed": [
  	"es.object.is-sealed"
  ],
  	"core-js/es/object/keys": [
  	"es.object.keys"
  ],
  	"core-js/es/object/lookup-getter": [
  	"es.object.lookup-getter"
  ],
  	"core-js/es/object/lookup-setter": [
  	"es.object.lookup-setter"
  ],
  	"core-js/es/object/prevent-extensions": [
  	"es.object.prevent-extensions"
  ],
  	"core-js/es/object/proto": [
  	"es.object.proto"
  ],
  	"core-js/es/object/seal": [
  	"es.object.seal"
  ],
  	"core-js/es/object/set-prototype-of": [
  	"es.object.set-prototype-of"
  ],
  	"core-js/es/object/to-string": [
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/es/object/values": [
  	"es.object.values"
  ],
  	"core-js/es/parse-float": [
  	"es.parse-float"
  ],
  	"core-js/es/parse-int": [
  	"es.parse-int"
  ],
  	"core-js/es/promise": [
  	"es.aggregate-error",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.string.iterator"
  ],
  	"core-js/es/promise/all-settled": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.string.iterator"
  ],
  	"core-js/es/promise/any": [
  	"es.aggregate-error",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.any",
  	"es.string.iterator"
  ],
  	"core-js/es/promise/finally": [
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.finally"
  ],
  	"core-js/es/promise/with-resolvers": [
  	"es.promise",
  	"es.promise.with-resolvers"
  ],
  	"core-js/es/reflect": [
  	"es.object.to-string",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/es/reflect/apply": [
  	"es.reflect.apply"
  ],
  	"core-js/es/reflect/construct": [
  	"es.reflect.construct"
  ],
  	"core-js/es/reflect/define-property": [
  	"es.reflect.define-property"
  ],
  	"core-js/es/reflect/delete-property": [
  	"es.reflect.delete-property"
  ],
  	"core-js/es/reflect/get": [
  	"es.reflect.get"
  ],
  	"core-js/es/reflect/get-own-property-descriptor": [
  	"es.reflect.get-own-property-descriptor"
  ],
  	"core-js/es/reflect/get-prototype-of": [
  	"es.reflect.get-prototype-of"
  ],
  	"core-js/es/reflect/has": [
  	"es.reflect.has"
  ],
  	"core-js/es/reflect/is-extensible": [
  	"es.reflect.is-extensible"
  ],
  	"core-js/es/reflect/own-keys": [
  	"es.reflect.own-keys"
  ],
  	"core-js/es/reflect/prevent-extensions": [
  	"es.reflect.prevent-extensions"
  ],
  	"core-js/es/reflect/set": [
  	"es.reflect.set"
  ],
  	"core-js/es/reflect/set-prototype-of": [
  	"es.reflect.set-prototype-of"
  ],
  	"core-js/es/reflect/to-string-tag": [
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/es/regexp": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.string.match",
  	"es.string.replace",
  	"es.string.search",
  	"es.string.split"
  ],
  	"core-js/es/regexp/constructor": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.sticky"
  ],
  	"core-js/es/regexp/dot-all": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec"
  ],
  	"core-js/es/regexp/flags": [
  	"es.regexp.flags"
  ],
  	"core-js/es/regexp/match": [
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/es/regexp/replace": [
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/es/regexp/search": [
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/es/regexp/split": [
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/es/regexp/sticky": [
  	"es.regexp.constructor",
  	"es.regexp.exec",
  	"es.regexp.sticky"
  ],
  	"core-js/es/regexp/test": [
  	"es.regexp.exec",
  	"es.regexp.test"
  ],
  	"core-js/es/regexp/to-string": [
  	"es.regexp.to-string"
  ],
  	"core-js/es/set": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.iterator"
  ],
  	"core-js/es/set/difference": [
  	"es.set",
  	"es.set.difference.v2"
  ],
  	"core-js/es/set/intersection": [
  	"es.set",
  	"es.set.intersection.v2"
  ],
  	"core-js/es/set/is-disjoint-from": [
  	"es.set",
  	"es.set.is-disjoint-from.v2"
  ],
  	"core-js/es/set/is-subset-of": [
  	"es.set",
  	"es.set.is-subset-of.v2"
  ],
  	"core-js/es/set/is-superset-of": [
  	"es.set",
  	"es.set.is-superset-of.v2"
  ],
  	"core-js/es/set/symmetric-difference": [
  	"es.set",
  	"es.set.symmetric-difference.v2"
  ],
  	"core-js/es/set/union": [
  	"es.set",
  	"es.set.union.v2"
  ],
  	"core-js/es/string": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup"
  ],
  	"core-js/es/string/anchor": [
  	"es.string.anchor"
  ],
  	"core-js/es/string/at": [
  	"es.string.at-alternative"
  ],
  	"core-js/es/string/big": [
  	"es.string.big"
  ],
  	"core-js/es/string/blink": [
  	"es.string.blink"
  ],
  	"core-js/es/string/bold": [
  	"es.string.bold"
  ],
  	"core-js/es/string/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/es/string/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/es/string/fixed": [
  	"es.string.fixed"
  ],
  	"core-js/es/string/fontcolor": [
  	"es.string.fontcolor"
  ],
  	"core-js/es/string/fontsize": [
  	"es.string.fontsize"
  ],
  	"core-js/es/string/from-code-point": [
  	"es.string.from-code-point"
  ],
  	"core-js/es/string/includes": [
  	"es.string.includes"
  ],
  	"core-js/es/string/is-well-formed": [
  	"es.string.is-well-formed"
  ],
  	"core-js/es/string/italics": [
  	"es.string.italics"
  ],
  	"core-js/es/string/iterator": [
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/es/string/link": [
  	"es.string.link"
  ],
  	"core-js/es/string/match": [
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/es/string/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/es/string/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/es/string/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/es/string/raw": [
  	"es.string.raw"
  ],
  	"core-js/es/string/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/es/string/replace": [
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/es/string/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all"
  ],
  	"core-js/es/string/search": [
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/es/string/small": [
  	"es.string.small"
  ],
  	"core-js/es/string/split": [
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/es/string/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/es/string/strike": [
  	"es.string.strike"
  ],
  	"core-js/es/string/sub": [
  	"es.string.sub"
  ],
  	"core-js/es/string/substr": [
  	"es.string.substr"
  ],
  	"core-js/es/string/sup": [
  	"es.string.sup"
  ],
  	"core-js/es/string/to-well-formed": [
  	"es.string.to-well-formed"
  ],
  	"core-js/es/string/trim": [
  	"es.string.trim"
  ],
  	"core-js/es/string/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/es/string/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/es/string/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/es/string/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/es/string/virtual": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.includes",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup"
  ],
  	"core-js/es/string/virtual/anchor": [
  	"es.string.anchor"
  ],
  	"core-js/es/string/virtual/at": [
  	"es.string.at-alternative"
  ],
  	"core-js/es/string/virtual/big": [
  	"es.string.big"
  ],
  	"core-js/es/string/virtual/blink": [
  	"es.string.blink"
  ],
  	"core-js/es/string/virtual/bold": [
  	"es.string.bold"
  ],
  	"core-js/es/string/virtual/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/es/string/virtual/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/es/string/virtual/fixed": [
  	"es.string.fixed"
  ],
  	"core-js/es/string/virtual/fontcolor": [
  	"es.string.fontcolor"
  ],
  	"core-js/es/string/virtual/fontsize": [
  	"es.string.fontsize"
  ],
  	"core-js/es/string/virtual/includes": [
  	"es.string.includes"
  ],
  	"core-js/es/string/virtual/is-well-formed": [
  	"es.string.is-well-formed"
  ],
  	"core-js/es/string/virtual/italics": [
  	"es.string.italics"
  ],
  	"core-js/es/string/virtual/iterator": [
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/es/string/virtual/link": [
  	"es.string.link"
  ],
  	"core-js/es/string/virtual/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/es/string/virtual/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/es/string/virtual/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/es/string/virtual/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/es/string/virtual/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all"
  ],
  	"core-js/es/string/virtual/small": [
  	"es.string.small"
  ],
  	"core-js/es/string/virtual/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/es/string/virtual/strike": [
  	"es.string.strike"
  ],
  	"core-js/es/string/virtual/sub": [
  	"es.string.sub"
  ],
  	"core-js/es/string/virtual/substr": [
  	"es.string.substr"
  ],
  	"core-js/es/string/virtual/sup": [
  	"es.string.sup"
  ],
  	"core-js/es/string/virtual/to-well-formed": [
  	"es.string.to-well-formed"
  ],
  	"core-js/es/string/virtual/trim": [
  	"es.string.trim"
  ],
  	"core-js/es/string/virtual/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/es/string/virtual/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/es/string/virtual/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/es/string/virtual/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/es/symbol": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.array.concat",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/es/symbol/async-iterator": [
  	"es.symbol.async-iterator"
  ],
  	"core-js/es/symbol/description": [
  	"es.symbol.description"
  ],
  	"core-js/es/symbol/for": [
  	"es.symbol"
  ],
  	"core-js/es/symbol/has-instance": [
  	"es.symbol.has-instance",
  	"es.function.has-instance"
  ],
  	"core-js/es/symbol/is-concat-spreadable": [
  	"es.symbol.is-concat-spreadable",
  	"es.array.concat"
  ],
  	"core-js/es/symbol/iterator": [
  	"es.symbol.iterator",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/es/symbol/key-for": [
  	"es.symbol"
  ],
  	"core-js/es/symbol/match": [
  	"es.symbol.match",
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/es/symbol/match-all": [
  	"es.symbol.match-all",
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/es/symbol/replace": [
  	"es.symbol.replace",
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/es/symbol/search": [
  	"es.symbol.search",
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/es/symbol/species": [
  	"es.symbol.species"
  ],
  	"core-js/es/symbol/split": [
  	"es.symbol.split",
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/es/symbol/to-primitive": [
  	"es.symbol.to-primitive",
  	"es.date.to-primitive"
  ],
  	"core-js/es/symbol/to-string-tag": [
  	"es.symbol.to-string-tag",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/es/symbol/unscopables": [
  	"es.symbol.unscopables"
  ],
  	"core-js/es/typed-array": [
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/es/typed-array/at": [
  	"es.typed-array.at"
  ],
  	"core-js/es/typed-array/copy-within": [
  	"es.typed-array.copy-within"
  ],
  	"core-js/es/typed-array/entries": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/es/typed-array/every": [
  	"es.typed-array.every"
  ],
  	"core-js/es/typed-array/fill": [
  	"es.typed-array.fill"
  ],
  	"core-js/es/typed-array/filter": [
  	"es.typed-array.filter"
  ],
  	"core-js/es/typed-array/find": [
  	"es.typed-array.find"
  ],
  	"core-js/es/typed-array/find-index": [
  	"es.typed-array.find-index"
  ],
  	"core-js/es/typed-array/find-last": [
  	"es.typed-array.find-last"
  ],
  	"core-js/es/typed-array/find-last-index": [
  	"es.typed-array.find-last-index"
  ],
  	"core-js/es/typed-array/float32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.float32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/es/typed-array/float64-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.float64-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/es/typed-array/for-each": [
  	"es.typed-array.for-each"
  ],
  	"core-js/es/typed-array/from": [
  	"es.typed-array.from"
  ],
  	"core-js/es/typed-array/includes": [
  	"es.typed-array.includes"
  ],
  	"core-js/es/typed-array/index-of": [
  	"es.typed-array.index-of"
  ],
  	"core-js/es/typed-array/int16-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.int16-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/es/typed-array/int32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.int32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/es/typed-array/int8-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.int8-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/es/typed-array/iterator": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/es/typed-array/join": [
  	"es.typed-array.join"
  ],
  	"core-js/es/typed-array/keys": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/es/typed-array/last-index-of": [
  	"es.typed-array.last-index-of"
  ],
  	"core-js/es/typed-array/map": [
  	"es.typed-array.map"
  ],
  	"core-js/es/typed-array/methods": [
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/es/typed-array/of": [
  	"es.typed-array.of"
  ],
  	"core-js/es/typed-array/reduce": [
  	"es.typed-array.reduce"
  ],
  	"core-js/es/typed-array/reduce-right": [
  	"es.typed-array.reduce-right"
  ],
  	"core-js/es/typed-array/reverse": [
  	"es.typed-array.reverse"
  ],
  	"core-js/es/typed-array/set": [
  	"es.typed-array.set"
  ],
  	"core-js/es/typed-array/slice": [
  	"es.typed-array.slice"
  ],
  	"core-js/es/typed-array/some": [
  	"es.typed-array.some"
  ],
  	"core-js/es/typed-array/sort": [
  	"es.typed-array.sort"
  ],
  	"core-js/es/typed-array/subarray": [
  	"es.typed-array.subarray"
  ],
  	"core-js/es/typed-array/to-locale-string": [
  	"es.typed-array.to-locale-string"
  ],
  	"core-js/es/typed-array/to-reversed": [
  	"es.typed-array.to-reversed"
  ],
  	"core-js/es/typed-array/to-sorted": [
  	"es.typed-array.sort",
  	"es.typed-array.to-sorted"
  ],
  	"core-js/es/typed-array/to-string": [
  	"es.typed-array.to-string"
  ],
  	"core-js/es/typed-array/uint16-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint16-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/es/typed-array/uint32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/es/typed-array/uint8-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint8-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/es/typed-array/uint8-clamped-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/es/typed-array/values": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/es/typed-array/with": [
  	"es.typed-array.with"
  ],
  	"core-js/es/unescape": [
  	"es.unescape"
  ],
  	"core-js/es/weak-map": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.weak-map"
  ],
  	"core-js/es/weak-set": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.weak-set"
  ],
  	"core-js/features": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.error.cause",
  	"es.error.to-string",
  	"es.aggregate-error",
  	"es.aggregate-error.cause",
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string",
  	"es.escape",
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name",
  	"es.global-this",
  	"es.json.stringify",
  	"es.json.to-string-tag",
  	"es.map",
  	"es.map.group-by",
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc",
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.parse-float",
  	"es.parse-int",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag",
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"es.unescape",
  	"es.weak-map",
  	"es.weak-set",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.bigint.range",
  	"esnext.composite-key",
  	"esnext.composite-symbol",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.demethodize",
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor",
  	"esnext.function.metadata",
  	"esnext.function.un-this",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.f16round",
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.sum-precise",
  	"esnext.math.umulh",
  	"esnext.number.from-string",
  	"esnext.number.range",
  	"esnext.object.has-own",
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values",
  	"esnext.object.group-by",
  	"esnext.observable",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.reflect.define-metadata",
  	"esnext.reflect.delete-metadata",
  	"esnext.reflect.get-metadata",
  	"esnext.reflect.get-metadata-keys",
  	"esnext.reflect.get-own-metadata",
  	"esnext.reflect.get-own-metadata-keys",
  	"esnext.reflect.has-metadata",
  	"esnext.reflect.has-own-metadata",
  	"esnext.reflect.metadata",
  	"esnext.regexp.escape",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"esnext.string.at",
  	"esnext.string.cooked",
  	"esnext.string.code-points",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.custom-matcher",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.symbol.replace-all",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of",
  	"web.atob",
  	"web.btoa",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.immediate",
  	"web.queue-microtask",
  	"web.self",
  	"web.structured-clone",
  	"web.timers",
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/features/aggregate-error": [
  ],
  	"core-js/features/array": [
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with"
  ],
  	"core-js/features/array-buffer": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.object.to-string",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/features/array-buffer/constructor": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.object.to-string",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/features/array-buffer/detached": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.array-buffer.detached",
  	"esnext.array-buffer.detached"
  ],
  	"core-js/features/array-buffer/is-view": [
  	"es.array-buffer.is-view"
  ],
  	"core-js/features/array-buffer/slice": [
  	"es.array-buffer.slice"
  ],
  	"core-js/features/array-buffer/transfer": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.transfer",
  	"esnext.array-buffer.transfer"
  ],
  	"core-js/features/array-buffer/transfer-to-fixed-length": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.transfer-to-fixed-length",
  	"esnext.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/features/array/at": [
  	"es.array.at",
  	"esnext.array.at"
  ],
  	"core-js/features/array/concat": [
  	"es.array.concat"
  ],
  	"core-js/features/array/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/features/array/entries": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/features/array/every": [
  	"es.array.every"
  ],
  	"core-js/features/array/fill": [
  	"es.array.fill"
  ],
  	"core-js/features/array/filter": [
  	"es.array.filter"
  ],
  	"core-js/features/array/filter-out": [
  	"esnext.array.filter-out"
  ],
  	"core-js/features/array/filter-reject": [
  	"esnext.array.filter-reject"
  ],
  	"core-js/features/array/find": [
  	"es.array.find"
  ],
  	"core-js/features/array/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/features/array/find-last": [
  	"es.array.find-last",
  	"esnext.array.find-last"
  ],
  	"core-js/features/array/find-last-index": [
  	"es.array.find-last-index",
  	"esnext.array.find-last-index"
  ],
  	"core-js/features/array/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/features/array/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/features/array/for-each": [
  	"es.array.for-each"
  ],
  	"core-js/features/array/from": [
  	"es.array.from",
  	"es.string.iterator"
  ],
  	"core-js/features/array/from-async": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.array.from-async"
  ],
  	"core-js/features/array/group": [
  	"esnext.array.group"
  ],
  	"core-js/features/array/group-by": [
  	"esnext.array.group-by"
  ],
  	"core-js/features/array/group-by-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-by-to-map"
  ],
  	"core-js/features/array/group-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-to-map"
  ],
  	"core-js/features/array/includes": [
  	"es.array.includes"
  ],
  	"core-js/features/array/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/features/array/is-array": [
  	"es.array.is-array"
  ],
  	"core-js/features/array/is-template-object": [
  	"esnext.array.is-template-object"
  ],
  	"core-js/features/array/iterator": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/features/array/join": [
  	"es.array.join"
  ],
  	"core-js/features/array/keys": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/features/array/last-index": [
  	"esnext.array.last-index"
  ],
  	"core-js/features/array/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/features/array/last-item": [
  	"esnext.array.last-item"
  ],
  	"core-js/features/array/map": [
  	"es.array.map"
  ],
  	"core-js/features/array/of": [
  	"es.array.of"
  ],
  	"core-js/features/array/push": [
  	"es.array.push"
  ],
  	"core-js/features/array/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/features/array/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/features/array/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/features/array/slice": [
  	"es.array.slice"
  ],
  	"core-js/features/array/some": [
  	"es.array.some"
  ],
  	"core-js/features/array/sort": [
  	"es.array.sort"
  ],
  	"core-js/features/array/splice": [
  	"es.array.splice"
  ],
  	"core-js/features/array/to-reversed": [
  	"es.array.to-reversed",
  	"esnext.array.to-reversed"
  ],
  	"core-js/features/array/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted",
  	"esnext.array.to-sorted"
  ],
  	"core-js/features/array/to-spliced": [
  	"es.array.to-spliced",
  	"esnext.array.to-spliced"
  ],
  	"core-js/features/array/unique-by": [
  	"es.map",
  	"esnext.array.unique-by"
  ],
  	"core-js/features/array/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/features/array/values": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/features/array/virtual": [
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with"
  ],
  	"core-js/features/array/virtual/at": [
  	"es.array.at",
  	"esnext.array.at"
  ],
  	"core-js/features/array/virtual/concat": [
  	"es.array.concat"
  ],
  	"core-js/features/array/virtual/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/features/array/virtual/entries": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/features/array/virtual/every": [
  	"es.array.every"
  ],
  	"core-js/features/array/virtual/fill": [
  	"es.array.fill"
  ],
  	"core-js/features/array/virtual/filter": [
  	"es.array.filter"
  ],
  	"core-js/features/array/virtual/filter-out": [
  	"esnext.array.filter-out"
  ],
  	"core-js/features/array/virtual/filter-reject": [
  	"esnext.array.filter-reject"
  ],
  	"core-js/features/array/virtual/find": [
  	"es.array.find"
  ],
  	"core-js/features/array/virtual/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/features/array/virtual/find-last": [
  	"es.array.find-last",
  	"esnext.array.find-last"
  ],
  	"core-js/features/array/virtual/find-last-index": [
  	"es.array.find-last-index",
  	"esnext.array.find-last-index"
  ],
  	"core-js/features/array/virtual/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/features/array/virtual/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/features/array/virtual/for-each": [
  	"es.array.for-each"
  ],
  	"core-js/features/array/virtual/group": [
  	"esnext.array.group"
  ],
  	"core-js/features/array/virtual/group-by": [
  	"esnext.array.group-by"
  ],
  	"core-js/features/array/virtual/group-by-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-by-to-map"
  ],
  	"core-js/features/array/virtual/group-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-to-map"
  ],
  	"core-js/features/array/virtual/includes": [
  	"es.array.includes"
  ],
  	"core-js/features/array/virtual/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/features/array/virtual/iterator": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/features/array/virtual/join": [
  	"es.array.join"
  ],
  	"core-js/features/array/virtual/keys": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/features/array/virtual/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/features/array/virtual/map": [
  	"es.array.map"
  ],
  	"core-js/features/array/virtual/push": [
  	"es.array.push"
  ],
  	"core-js/features/array/virtual/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/features/array/virtual/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/features/array/virtual/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/features/array/virtual/slice": [
  	"es.array.slice"
  ],
  	"core-js/features/array/virtual/some": [
  	"es.array.some"
  ],
  	"core-js/features/array/virtual/sort": [
  	"es.array.sort"
  ],
  	"core-js/features/array/virtual/splice": [
  	"es.array.splice"
  ],
  	"core-js/features/array/virtual/to-reversed": [
  	"es.array.to-reversed",
  	"esnext.array.to-reversed"
  ],
  	"core-js/features/array/virtual/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted",
  	"esnext.array.to-sorted"
  ],
  	"core-js/features/array/virtual/to-spliced": [
  	"es.array.to-spliced",
  	"esnext.array.to-spliced"
  ],
  	"core-js/features/array/virtual/unique-by": [
  	"es.map",
  	"esnext.array.unique-by"
  ],
  	"core-js/features/array/virtual/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/features/array/virtual/values": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/features/array/virtual/with": [
  	"es.array.with",
  	"esnext.array.with"
  ],
  	"core-js/features/array/with": [
  	"es.array.with",
  	"esnext.array.with"
  ],
  	"core-js/features/async-disposable-stack": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"es.promise",
  	"esnext.suppressed-error.constructor",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.iterator.dispose"
  ],
  	"core-js/features/async-disposable-stack/constructor": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"es.promise",
  	"esnext.suppressed-error.constructor",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.iterator.dispose"
  ],
  	"core-js/features/async-iterator": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/async-iterator/as-indexed-pairs": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs"
  ],
  	"core-js/features/async-iterator/async-dispose": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.async-dispose"
  ],
  	"core-js/features/async-iterator/drop": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.drop"
  ],
  	"core-js/features/async-iterator/every": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.every"
  ],
  	"core-js/features/async-iterator/filter": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.filter"
  ],
  	"core-js/features/async-iterator/find": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.find"
  ],
  	"core-js/features/async-iterator/flat-map": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.flat-map"
  ],
  	"core-js/features/async-iterator/for-each": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.for-each"
  ],
  	"core-js/features/async-iterator/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/async-iterator/indexed": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.indexed"
  ],
  	"core-js/features/async-iterator/map": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.map"
  ],
  	"core-js/features/async-iterator/reduce": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.reduce"
  ],
  	"core-js/features/async-iterator/some": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.some"
  ],
  	"core-js/features/async-iterator/take": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.take"
  ],
  	"core-js/features/async-iterator/to-array": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.to-array"
  ],
  	"core-js/features/atob": [
  	"es.error.to-string",
  	"es.object.to-string",
  	"web.atob",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/features/bigint": [
  	"es.object.to-string",
  	"esnext.bigint.range"
  ],
  	"core-js/features/bigint/range": [
  	"es.object.to-string",
  	"esnext.bigint.range"
  ],
  	"core-js/features/btoa": [
  	"es.error.to-string",
  	"es.object.to-string",
  	"web.btoa",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/features/clear-immediate": [
  	"web.immediate"
  ],
  	"core-js/features/composite-key": [
  	"esnext.composite-key"
  ],
  	"core-js/features/composite-symbol": [
  	"es.symbol",
  	"esnext.composite-symbol"
  ],
  	"core-js/features/data-view": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.object.to-string",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped"
  ],
  	"core-js/features/data-view/get-float16": [
  	"esnext.data-view.get-float16"
  ],
  	"core-js/features/data-view/get-uint8-clamped": [
  	"esnext.data-view.get-uint8-clamped"
  ],
  	"core-js/features/data-view/set-float16": [
  	"esnext.data-view.set-float16"
  ],
  	"core-js/features/data-view/set-uint8-clamped": [
  	"esnext.data-view.set-uint8-clamped"
  ],
  	"core-js/features/date": [
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string"
  ],
  	"core-js/features/date/get-year": [
  	"es.date.get-year"
  ],
  	"core-js/features/date/now": [
  	"es.date.now"
  ],
  	"core-js/features/date/set-year": [
  	"es.date.set-year"
  ],
  	"core-js/features/date/to-gmt-string": [
  	"es.date.to-gmt-string"
  ],
  	"core-js/features/date/to-iso-string": [
  	"es.date.to-iso-string",
  	"es.date.to-json"
  ],
  	"core-js/features/date/to-json": [
  	"es.date.to-json"
  ],
  	"core-js/features/date/to-primitive": [
  	"es.date.to-primitive"
  ],
  	"core-js/features/date/to-string": [
  	"es.date.to-string"
  ],
  	"core-js/features/disposable-stack": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"esnext.suppressed-error.constructor",
  	"esnext.disposable-stack.constructor",
  	"esnext.iterator.dispose"
  ],
  	"core-js/features/disposable-stack/constructor": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"esnext.suppressed-error.constructor",
  	"esnext.disposable-stack.constructor",
  	"esnext.iterator.dispose"
  ],
  	"core-js/features/dom-collections": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/dom-collections/for-each": [
  	"web.dom-collections.for-each"
  ],
  	"core-js/features/dom-collections/iterator": [
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/dom-exception": [
  	"es.error.to-string",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/features/dom-exception/constructor": [
  	"es.error.to-string",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack"
  ],
  	"core-js/features/dom-exception/to-string-tag": [
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/features/error": [
  	"es.error.cause",
  	"es.error.to-string"
  ],
  	"core-js/features/error/constructor": [
  	"es.error.cause"
  ],
  	"core-js/features/error/to-string": [
  	"es.error.to-string"
  ],
  	"core-js/features/escape": [
  	"es.escape"
  ],
  	"core-js/features/function": [
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name",
  	"esnext.function.demethodize",
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor",
  	"esnext.function.metadata",
  	"esnext.function.un-this"
  ],
  	"core-js/features/function/bind": [
  	"es.function.bind"
  ],
  	"core-js/features/function/demethodize": [
  	"esnext.function.demethodize"
  ],
  	"core-js/features/function/has-instance": [
  	"es.function.has-instance"
  ],
  	"core-js/features/function/is-callable": [
  	"esnext.function.is-callable"
  ],
  	"core-js/features/function/is-constructor": [
  	"esnext.function.is-constructor"
  ],
  	"core-js/features/function/metadata": [
  	"esnext.function.metadata"
  ],
  	"core-js/features/function/name": [
  	"es.function.name"
  ],
  	"core-js/features/function/un-this": [
  	"esnext.function.un-this"
  ],
  	"core-js/features/function/virtual": [
  	"es.function.bind",
  	"esnext.function.demethodize",
  	"esnext.function.un-this"
  ],
  	"core-js/features/function/virtual/bind": [
  	"es.function.bind"
  ],
  	"core-js/features/function/virtual/demethodize": [
  	"esnext.function.demethodize"
  ],
  	"core-js/features/function/virtual/un-this": [
  	"esnext.function.un-this"
  ],
  	"core-js/features/get-iterator": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/get-iterator-method": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/global-this": [
  	"es.global-this",
  	"esnext.global-this"
  ],
  	"core-js/features/instance/at": [
  	"es.array.at",
  	"es.string.at-alternative",
  	"esnext.array.at",
  	"esnext.string.at"
  ],
  	"core-js/features/instance/bind": [
  	"es.function.bind"
  ],
  	"core-js/features/instance/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/features/instance/code-points": [
  	"es.object.to-string",
  	"esnext.string.code-points"
  ],
  	"core-js/features/instance/concat": [
  	"es.array.concat"
  ],
  	"core-js/features/instance/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/features/instance/demethodize": [
  	"esnext.function.demethodize"
  ],
  	"core-js/features/instance/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/features/instance/entries": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/instance/every": [
  	"es.array.every"
  ],
  	"core-js/features/instance/fill": [
  	"es.array.fill"
  ],
  	"core-js/features/instance/filter": [
  	"es.array.filter"
  ],
  	"core-js/features/instance/filter-out": [
  	"esnext.array.filter-out"
  ],
  	"core-js/features/instance/filter-reject": [
  	"esnext.array.filter-reject"
  ],
  	"core-js/features/instance/find": [
  	"es.array.find"
  ],
  	"core-js/features/instance/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/features/instance/find-last": [
  	"es.array.find-last",
  	"esnext.array.find-last"
  ],
  	"core-js/features/instance/find-last-index": [
  	"es.array.find-last-index",
  	"esnext.array.find-last-index"
  ],
  	"core-js/features/instance/flags": [
  	"es.regexp.flags"
  ],
  	"core-js/features/instance/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/features/instance/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/features/instance/for-each": [
  	"es.array.for-each",
  	"web.dom-collections.for-each"
  ],
  	"core-js/features/instance/group": [
  	"esnext.array.group"
  ],
  	"core-js/features/instance/group-by": [
  	"esnext.array.group-by"
  ],
  	"core-js/features/instance/group-by-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-by-to-map"
  ],
  	"core-js/features/instance/group-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-to-map"
  ],
  	"core-js/features/instance/includes": [
  	"es.array.includes",
  	"es.string.includes"
  ],
  	"core-js/features/instance/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/features/instance/is-well-formed": [
  	"es.string.is-well-formed"
  ],
  	"core-js/features/instance/keys": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/instance/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/features/instance/map": [
  	"es.array.map"
  ],
  	"core-js/features/instance/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all",
  	"esnext.string.match-all"
  ],
  	"core-js/features/instance/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/features/instance/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/features/instance/push": [
  	"es.array.push"
  ],
  	"core-js/features/instance/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/features/instance/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/features/instance/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/features/instance/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all",
  	"esnext.string.replace-all"
  ],
  	"core-js/features/instance/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/features/instance/slice": [
  	"es.array.slice"
  ],
  	"core-js/features/instance/some": [
  	"es.array.some"
  ],
  	"core-js/features/instance/sort": [
  	"es.array.sort"
  ],
  	"core-js/features/instance/splice": [
  	"es.array.splice"
  ],
  	"core-js/features/instance/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/features/instance/to-reversed": [
  	"es.array.to-reversed",
  	"esnext.array.to-reversed"
  ],
  	"core-js/features/instance/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted",
  	"esnext.array.to-sorted"
  ],
  	"core-js/features/instance/to-spliced": [
  	"es.array.to-spliced",
  	"esnext.array.to-spliced"
  ],
  	"core-js/features/instance/to-well-formed": [
  	"es.string.to-well-formed"
  ],
  	"core-js/features/instance/trim": [
  	"es.string.trim"
  ],
  	"core-js/features/instance/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/features/instance/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/features/instance/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/features/instance/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/features/instance/un-this": [
  	"esnext.function.un-this"
  ],
  	"core-js/features/instance/unique-by": [
  	"es.map",
  	"esnext.array.unique-by"
  ],
  	"core-js/features/instance/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/features/instance/values": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/instance/with": [
  	"es.array.with",
  	"esnext.array.with"
  ],
  	"core-js/features/is-iterable": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/iterator": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/iterator/as-indexed-pairs": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs"
  ],
  	"core-js/features/iterator/dispose": [
  	"esnext.iterator.dispose"
  ],
  	"core-js/features/iterator/drop": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.drop"
  ],
  	"core-js/features/iterator/every": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.every"
  ],
  	"core-js/features/iterator/filter": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.filter"
  ],
  	"core-js/features/iterator/find": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.find"
  ],
  	"core-js/features/iterator/flat-map": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.flat-map"
  ],
  	"core-js/features/iterator/for-each": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.for-each"
  ],
  	"core-js/features/iterator/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.iterator.constructor",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.map",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/iterator/indexed": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.indexed"
  ],
  	"core-js/features/iterator/map": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.map"
  ],
  	"core-js/features/iterator/range": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.range"
  ],
  	"core-js/features/iterator/reduce": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.reduce"
  ],
  	"core-js/features/iterator/some": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.some"
  ],
  	"core-js/features/iterator/take": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.take"
  ],
  	"core-js/features/iterator/to-array": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.to-array"
  ],
  	"core-js/features/iterator/to-async": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.iterator.constructor",
  	"esnext.iterator.to-async"
  ],
  	"core-js/features/json": [
  	"es.date.to-json",
  	"es.json.stringify",
  	"es.json.to-string-tag",
  	"es.object.create",
  	"es.object.freeze",
  	"es.object.keys",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json"
  ],
  	"core-js/features/json/is-raw-json": [
  	"esnext.json.is-raw-json"
  ],
  	"core-js/features/json/parse": [
  	"es.object.keys",
  	"esnext.json.parse"
  ],
  	"core-js/features/json/raw-json": [
  	"es.object.create",
  	"es.object.freeze",
  	"esnext.json.raw-json"
  ],
  	"core-js/features/json/stringify": [
  	"es.date.to-json",
  	"es.json.stringify"
  ],
  	"core-js/features/json/to-string-tag": [
  	"es.json.to-string-tag"
  ],
  	"core-js/features/map": [
  	"es.array.iterator",
  	"es.map",
  	"es.map.group-by",
  	"es.object.to-string",
  	"es.string.iterator",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/map/delete-all": [
  	"es.map",
  	"esnext.map.delete-all"
  ],
  	"core-js/features/map/emplace": [
  	"es.map",
  	"esnext.map.emplace"
  ],
  	"core-js/features/map/every": [
  	"es.map",
  	"esnext.map.every"
  ],
  	"core-js/features/map/filter": [
  	"es.map",
  	"esnext.map.filter"
  ],
  	"core-js/features/map/find": [
  	"es.map",
  	"esnext.map.find"
  ],
  	"core-js/features/map/find-key": [
  	"es.map",
  	"esnext.map.find-key"
  ],
  	"core-js/features/map/from": [
  	"es.array.iterator",
  	"es.map",
  	"es.object.to-string",
  	"es.string.iterator",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.includes",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/map/group-by": [
  	"es.map",
  	"es.map.group-by",
  	"es.object.to-string",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update"
  ],
  	"core-js/features/map/includes": [
  	"es.map",
  	"esnext.map.includes"
  ],
  	"core-js/features/map/key-by": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update"
  ],
  	"core-js/features/map/key-of": [
  	"es.map",
  	"esnext.map.key-of"
  ],
  	"core-js/features/map/map-keys": [
  	"es.map",
  	"esnext.map.map-keys"
  ],
  	"core-js/features/map/map-values": [
  	"es.map",
  	"esnext.map.map-values"
  ],
  	"core-js/features/map/merge": [
  	"es.map",
  	"esnext.map.merge"
  ],
  	"core-js/features/map/of": [
  	"es.array.iterator",
  	"es.map",
  	"es.object.to-string",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.includes",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update"
  ],
  	"core-js/features/map/reduce": [
  	"es.map",
  	"esnext.map.reduce"
  ],
  	"core-js/features/map/some": [
  	"es.map",
  	"esnext.map.some"
  ],
  	"core-js/features/map/update": [
  	"es.map",
  	"esnext.map.update"
  ],
  	"core-js/features/map/update-or-insert": [
  	"es.map",
  	"esnext.map.update-or-insert"
  ],
  	"core-js/features/map/upsert": [
  	"es.map",
  	"esnext.map.upsert"
  ],
  	"core-js/features/math": [
  	"es.array.iterator",
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.f16round",
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.sum-precise",
  	"esnext.math.umulh"
  ],
  	"core-js/features/math/acosh": [
  	"es.math.acosh"
  ],
  	"core-js/features/math/asinh": [
  	"es.math.asinh"
  ],
  	"core-js/features/math/atanh": [
  	"es.math.atanh"
  ],
  	"core-js/features/math/cbrt": [
  	"es.math.cbrt"
  ],
  	"core-js/features/math/clamp": [
  	"esnext.math.clamp"
  ],
  	"core-js/features/math/clz32": [
  	"es.math.clz32"
  ],
  	"core-js/features/math/cosh": [
  	"es.math.cosh"
  ],
  	"core-js/features/math/deg-per-rad": [
  	"esnext.math.deg-per-rad"
  ],
  	"core-js/features/math/degrees": [
  	"esnext.math.degrees"
  ],
  	"core-js/features/math/expm1": [
  	"es.math.expm1"
  ],
  	"core-js/features/math/f16round": [
  	"esnext.math.f16round"
  ],
  	"core-js/features/math/fround": [
  	"es.math.fround"
  ],
  	"core-js/features/math/fscale": [
  	"esnext.math.fscale"
  ],
  	"core-js/features/math/hypot": [
  	"es.math.hypot"
  ],
  	"core-js/features/math/iaddh": [
  	"esnext.math.iaddh"
  ],
  	"core-js/features/math/imul": [
  	"es.math.imul"
  ],
  	"core-js/features/math/imulh": [
  	"esnext.math.imulh"
  ],
  	"core-js/features/math/isubh": [
  	"esnext.math.isubh"
  ],
  	"core-js/features/math/log10": [
  	"es.math.log10"
  ],
  	"core-js/features/math/log1p": [
  	"es.math.log1p"
  ],
  	"core-js/features/math/log2": [
  	"es.math.log2"
  ],
  	"core-js/features/math/rad-per-deg": [
  	"esnext.math.rad-per-deg"
  ],
  	"core-js/features/math/radians": [
  	"esnext.math.radians"
  ],
  	"core-js/features/math/scale": [
  	"esnext.math.scale"
  ],
  	"core-js/features/math/seeded-prng": [
  	"esnext.math.seeded-prng"
  ],
  	"core-js/features/math/sign": [
  	"es.math.sign"
  ],
  	"core-js/features/math/signbit": [
  	"esnext.math.signbit"
  ],
  	"core-js/features/math/sinh": [
  	"es.math.sinh"
  ],
  	"core-js/features/math/sum-precise": [
  	"es.array.iterator",
  	"esnext.math.sum-precise"
  ],
  	"core-js/features/math/tanh": [
  	"es.math.tanh"
  ],
  	"core-js/features/math/to-string-tag": [
  	"es.math.to-string-tag"
  ],
  	"core-js/features/math/trunc": [
  	"es.math.trunc"
  ],
  	"core-js/features/math/umulh": [
  	"esnext.math.umulh"
  ],
  	"core-js/features/number": [
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision",
  	"es.object.to-string",
  	"esnext.number.from-string",
  	"esnext.number.range"
  ],
  	"core-js/features/number/constructor": [
  	"es.number.constructor"
  ],
  	"core-js/features/number/epsilon": [
  	"es.number.epsilon"
  ],
  	"core-js/features/number/from-string": [
  	"esnext.number.from-string"
  ],
  	"core-js/features/number/is-finite": [
  	"es.number.is-finite"
  ],
  	"core-js/features/number/is-integer": [
  	"es.number.is-integer"
  ],
  	"core-js/features/number/is-nan": [
  	"es.number.is-nan"
  ],
  	"core-js/features/number/is-safe-integer": [
  	"es.number.is-safe-integer"
  ],
  	"core-js/features/number/max-safe-integer": [
  	"es.number.max-safe-integer"
  ],
  	"core-js/features/number/min-safe-integer": [
  	"es.number.min-safe-integer"
  ],
  	"core-js/features/number/parse-float": [
  	"es.number.parse-float"
  ],
  	"core-js/features/number/parse-int": [
  	"es.number.parse-int"
  ],
  	"core-js/features/number/range": [
  	"es.object.to-string",
  	"esnext.number.range"
  ],
  	"core-js/features/number/to-exponential": [
  	"es.number.to-exponential"
  ],
  	"core-js/features/number/to-fixed": [
  	"es.number.to-fixed"
  ],
  	"core-js/features/number/to-precision": [
  	"es.number.to-precision"
  ],
  	"core-js/features/number/virtual": [
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision"
  ],
  	"core-js/features/number/virtual/to-exponential": [
  	"es.number.to-exponential"
  ],
  	"core-js/features/number/virtual/to-fixed": [
  	"es.number.to-fixed"
  ],
  	"core-js/features/number/virtual/to-precision": [
  	"es.number.to-precision"
  ],
  	"core-js/features/object": [
  	"es.symbol",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.reflect.to-string-tag",
  	"esnext.object.has-own",
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values",
  	"esnext.object.group-by",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/object/assign": [
  	"es.object.assign"
  ],
  	"core-js/features/object/create": [
  	"es.object.create"
  ],
  	"core-js/features/object/define-getter": [
  	"es.object.define-getter"
  ],
  	"core-js/features/object/define-properties": [
  	"es.object.define-properties"
  ],
  	"core-js/features/object/define-property": [
  	"es.object.define-property"
  ],
  	"core-js/features/object/define-setter": [
  	"es.object.define-setter"
  ],
  	"core-js/features/object/entries": [
  	"es.object.entries"
  ],
  	"core-js/features/object/freeze": [
  	"es.object.freeze"
  ],
  	"core-js/features/object/from-entries": [
  	"es.array.iterator",
  	"es.object.from-entries",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/object/get-own-property-descriptor": [
  	"es.object.get-own-property-descriptor"
  ],
  	"core-js/features/object/get-own-property-descriptors": [
  	"es.object.get-own-property-descriptors"
  ],
  	"core-js/features/object/get-own-property-names": [
  	"es.object.get-own-property-names"
  ],
  	"core-js/features/object/get-own-property-symbols": [
  	"es.symbol"
  ],
  	"core-js/features/object/get-prototype-of": [
  	"es.object.get-prototype-of"
  ],
  	"core-js/features/object/group-by": [
  	"es.object.create",
  	"es.object.group-by",
  	"esnext.object.group-by"
  ],
  	"core-js/features/object/has-own": [
  	"es.object.has-own",
  	"esnext.object.has-own"
  ],
  	"core-js/features/object/is": [
  	"es.object.is"
  ],
  	"core-js/features/object/is-extensible": [
  	"es.object.is-extensible"
  ],
  	"core-js/features/object/is-frozen": [
  	"es.object.is-frozen"
  ],
  	"core-js/features/object/is-sealed": [
  	"es.object.is-sealed"
  ],
  	"core-js/features/object/iterate-entries": [
  	"esnext.object.iterate-entries"
  ],
  	"core-js/features/object/iterate-keys": [
  	"esnext.object.iterate-keys"
  ],
  	"core-js/features/object/iterate-values": [
  	"esnext.object.iterate-values"
  ],
  	"core-js/features/object/keys": [
  	"es.object.keys"
  ],
  	"core-js/features/object/lookup-getter": [
  	"es.object.lookup-getter"
  ],
  	"core-js/features/object/lookup-setter": [
  	"es.object.lookup-setter"
  ],
  	"core-js/features/object/prevent-extensions": [
  	"es.object.prevent-extensions"
  ],
  	"core-js/features/object/proto": [
  	"es.object.proto"
  ],
  	"core-js/features/object/seal": [
  	"es.object.seal"
  ],
  	"core-js/features/object/set-prototype-of": [
  	"es.object.set-prototype-of"
  ],
  	"core-js/features/object/to-string": [
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/features/object/values": [
  	"es.object.values"
  ],
  	"core-js/features/observable": [
  	"es.object.to-string",
  	"es.string.iterator",
  	"esnext.observable",
  	"esnext.symbol.observable",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/parse-float": [
  	"es.parse-float"
  ],
  	"core-js/features/parse-int": [
  	"es.parse-int"
  ],
  	"core-js/features/promise": [
  	"es.aggregate-error",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.string.iterator",
  	"esnext.aggregate-error",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/promise/all-settled": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.string.iterator",
  	"esnext.promise.all-settled",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/promise/any": [
  	"es.aggregate-error",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.any",
  	"es.string.iterator",
  	"esnext.aggregate-error",
  	"esnext.promise.any",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/promise/finally": [
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.finally"
  ],
  	"core-js/features/promise/try": [
  	"es.promise",
  	"esnext.promise.try"
  ],
  	"core-js/features/promise/with-resolvers": [
  	"es.promise",
  	"es.promise.with-resolvers",
  	"esnext.promise.with-resolvers"
  ],
  	"core-js/features/queue-microtask": [
  	"web.queue-microtask"
  ],
  	"core-js/features/reflect": [
  	"es.object.to-string",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag",
  	"esnext.reflect.define-metadata",
  	"esnext.reflect.delete-metadata",
  	"esnext.reflect.get-metadata",
  	"esnext.reflect.get-metadata-keys",
  	"esnext.reflect.get-own-metadata",
  	"esnext.reflect.get-own-metadata-keys",
  	"esnext.reflect.has-metadata",
  	"esnext.reflect.has-own-metadata",
  	"esnext.reflect.metadata"
  ],
  	"core-js/features/reflect/apply": [
  	"es.reflect.apply"
  ],
  	"core-js/features/reflect/construct": [
  	"es.reflect.construct"
  ],
  	"core-js/features/reflect/define-metadata": [
  	"esnext.reflect.define-metadata"
  ],
  	"core-js/features/reflect/define-property": [
  	"es.reflect.define-property"
  ],
  	"core-js/features/reflect/delete-metadata": [
  	"esnext.reflect.delete-metadata"
  ],
  	"core-js/features/reflect/delete-property": [
  	"es.reflect.delete-property"
  ],
  	"core-js/features/reflect/get": [
  	"es.reflect.get"
  ],
  	"core-js/features/reflect/get-metadata": [
  	"esnext.reflect.get-metadata"
  ],
  	"core-js/features/reflect/get-metadata-keys": [
  	"esnext.reflect.get-metadata-keys"
  ],
  	"core-js/features/reflect/get-own-metadata": [
  	"esnext.reflect.get-own-metadata"
  ],
  	"core-js/features/reflect/get-own-metadata-keys": [
  	"esnext.reflect.get-own-metadata-keys"
  ],
  	"core-js/features/reflect/get-own-property-descriptor": [
  	"es.reflect.get-own-property-descriptor"
  ],
  	"core-js/features/reflect/get-prototype-of": [
  	"es.reflect.get-prototype-of"
  ],
  	"core-js/features/reflect/has": [
  	"es.reflect.has"
  ],
  	"core-js/features/reflect/has-metadata": [
  	"esnext.reflect.has-metadata"
  ],
  	"core-js/features/reflect/has-own-metadata": [
  	"esnext.reflect.has-own-metadata"
  ],
  	"core-js/features/reflect/is-extensible": [
  	"es.reflect.is-extensible"
  ],
  	"core-js/features/reflect/metadata": [
  	"esnext.reflect.metadata"
  ],
  	"core-js/features/reflect/own-keys": [
  	"es.reflect.own-keys"
  ],
  	"core-js/features/reflect/prevent-extensions": [
  	"es.reflect.prevent-extensions"
  ],
  	"core-js/features/reflect/set": [
  	"es.reflect.set"
  ],
  	"core-js/features/reflect/set-prototype-of": [
  	"es.reflect.set-prototype-of"
  ],
  	"core-js/features/reflect/to-string-tag": [
  	"es.reflect.to-string-tag"
  ],
  	"core-js/features/regexp": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.string.match",
  	"es.string.replace",
  	"es.string.search",
  	"es.string.split",
  	"esnext.regexp.escape"
  ],
  	"core-js/features/regexp/constructor": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.sticky"
  ],
  	"core-js/features/regexp/dot-all": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec"
  ],
  	"core-js/features/regexp/escape": [
  	"esnext.regexp.escape"
  ],
  	"core-js/features/regexp/flags": [
  	"es.regexp.flags"
  ],
  	"core-js/features/regexp/match": [
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/features/regexp/replace": [
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/features/regexp/search": [
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/features/regexp/split": [
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/features/regexp/sticky": [
  	"es.regexp.constructor",
  	"es.regexp.exec",
  	"es.regexp.sticky"
  ],
  	"core-js/features/regexp/test": [
  	"es.regexp.exec",
  	"es.regexp.test"
  ],
  	"core-js/features/regexp/to-string": [
  	"es.regexp.to-string"
  ],
  	"core-js/features/self": [
  	"web.self"
  ],
  	"core-js/features/set": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.iterator",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/set-immediate": [
  	"web.immediate"
  ],
  	"core-js/features/set-interval": [
  	"web.timers"
  ],
  	"core-js/features/set-timeout": [
  	"web.timers"
  ],
  	"core-js/features/set/add-all": [
  	"es.set",
  	"esnext.set.add-all"
  ],
  	"core-js/features/set/delete-all": [
  	"es.set",
  	"esnext.set.delete-all"
  ],
  	"core-js/features/set/difference": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.difference.v2",
  	"es.string.iterator",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/set/every": [
  	"es.set",
  	"esnext.set.every"
  ],
  	"core-js/features/set/filter": [
  	"es.set",
  	"esnext.set.filter"
  ],
  	"core-js/features/set/find": [
  	"es.set",
  	"esnext.set.find"
  ],
  	"core-js/features/set/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.set",
  	"es.string.iterator",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.union.v2",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/set/intersection": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.intersection.v2",
  	"es.string.iterator",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/set/is-disjoint-from": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.is-disjoint-from.v2",
  	"es.string.iterator",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/set/is-subset-of": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.is-subset-of.v2",
  	"es.string.iterator",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/set/is-superset-of": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.is-superset-of.v2",
  	"es.string.iterator",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/set/join": [
  	"es.set",
  	"esnext.set.join"
  ],
  	"core-js/features/set/map": [
  	"es.set",
  	"esnext.set.map"
  ],
  	"core-js/features/set/of": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.set",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.intersection.v2",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.union.v2"
  ],
  	"core-js/features/set/reduce": [
  	"es.set",
  	"esnext.set.reduce"
  ],
  	"core-js/features/set/some": [
  	"es.set",
  	"esnext.set.some"
  ],
  	"core-js/features/set/symmetric-difference": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.symmetric-difference.v2",
  	"es.string.iterator",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/set/union": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.union.v2",
  	"es.string.iterator",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/string": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"es.weak-map",
  	"esnext.string.at",
  	"esnext.string.cooked",
  	"esnext.string.code-points",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/features/string/anchor": [
  	"es.string.anchor"
  ],
  	"core-js/features/string/at": [
  	"es.string.at-alternative",
  	"esnext.string.at"
  ],
  	"core-js/features/string/big": [
  	"es.string.big"
  ],
  	"core-js/features/string/blink": [
  	"es.string.blink"
  ],
  	"core-js/features/string/bold": [
  	"es.string.bold"
  ],
  	"core-js/features/string/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/features/string/code-points": [
  	"es.object.to-string",
  	"esnext.string.code-points"
  ],
  	"core-js/features/string/cooked": [
  	"esnext.string.cooked"
  ],
  	"core-js/features/string/dedent": [
  	"es.string.from-code-point",
  	"es.weak-map",
  	"esnext.string.dedent"
  ],
  	"core-js/features/string/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/features/string/fixed": [
  	"es.string.fixed"
  ],
  	"core-js/features/string/fontcolor": [
  	"es.string.fontcolor"
  ],
  	"core-js/features/string/fontsize": [
  	"es.string.fontsize"
  ],
  	"core-js/features/string/from-code-point": [
  	"es.string.from-code-point"
  ],
  	"core-js/features/string/includes": [
  	"es.string.includes"
  ],
  	"core-js/features/string/is-well-formed": [
  	"es.string.is-well-formed",
  	"esnext.string.is-well-formed"
  ],
  	"core-js/features/string/italics": [
  	"es.string.italics"
  ],
  	"core-js/features/string/iterator": [
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/features/string/link": [
  	"es.string.link"
  ],
  	"core-js/features/string/match": [
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/features/string/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all",
  	"esnext.string.match-all"
  ],
  	"core-js/features/string/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/features/string/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/features/string/raw": [
  	"es.string.raw"
  ],
  	"core-js/features/string/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/features/string/replace": [
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/features/string/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all",
  	"esnext.string.replace-all"
  ],
  	"core-js/features/string/search": [
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/features/string/small": [
  	"es.string.small"
  ],
  	"core-js/features/string/split": [
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/features/string/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/features/string/strike": [
  	"es.string.strike"
  ],
  	"core-js/features/string/sub": [
  	"es.string.sub"
  ],
  	"core-js/features/string/substr": [
  	"es.string.substr"
  ],
  	"core-js/features/string/sup": [
  	"es.string.sup"
  ],
  	"core-js/features/string/to-well-formed": [
  	"es.string.to-well-formed",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/features/string/trim": [
  	"es.string.trim"
  ],
  	"core-js/features/string/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/features/string/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/features/string/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/features/string/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/features/string/virtual": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.includes",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"esnext.string.at",
  	"esnext.string.code-points",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/features/string/virtual/anchor": [
  	"es.string.anchor"
  ],
  	"core-js/features/string/virtual/at": [
  	"es.string.at-alternative",
  	"esnext.string.at"
  ],
  	"core-js/features/string/virtual/big": [
  	"es.string.big"
  ],
  	"core-js/features/string/virtual/blink": [
  	"es.string.blink"
  ],
  	"core-js/features/string/virtual/bold": [
  	"es.string.bold"
  ],
  	"core-js/features/string/virtual/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/features/string/virtual/code-points": [
  	"es.object.to-string",
  	"esnext.string.code-points"
  ],
  	"core-js/features/string/virtual/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/features/string/virtual/fixed": [
  	"es.string.fixed"
  ],
  	"core-js/features/string/virtual/fontcolor": [
  	"es.string.fontcolor"
  ],
  	"core-js/features/string/virtual/fontsize": [
  	"es.string.fontsize"
  ],
  	"core-js/features/string/virtual/includes": [
  	"es.string.includes"
  ],
  	"core-js/features/string/virtual/is-well-formed": [
  	"es.string.is-well-formed",
  	"esnext.string.is-well-formed"
  ],
  	"core-js/features/string/virtual/italics": [
  	"es.string.italics"
  ],
  	"core-js/features/string/virtual/iterator": [
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/features/string/virtual/link": [
  	"es.string.link"
  ],
  	"core-js/features/string/virtual/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all",
  	"esnext.string.match-all"
  ],
  	"core-js/features/string/virtual/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/features/string/virtual/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/features/string/virtual/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/features/string/virtual/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all",
  	"esnext.string.replace-all"
  ],
  	"core-js/features/string/virtual/small": [
  	"es.string.small"
  ],
  	"core-js/features/string/virtual/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/features/string/virtual/strike": [
  	"es.string.strike"
  ],
  	"core-js/features/string/virtual/sub": [
  	"es.string.sub"
  ],
  	"core-js/features/string/virtual/substr": [
  	"es.string.substr"
  ],
  	"core-js/features/string/virtual/sup": [
  	"es.string.sup"
  ],
  	"core-js/features/string/virtual/to-well-formed": [
  	"es.string.to-well-formed",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/features/string/virtual/trim": [
  	"es.string.trim"
  ],
  	"core-js/features/string/virtual/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/features/string/virtual/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/features/string/virtual/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/features/string/virtual/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/features/structured-clone": [
  	"es.error.to-string",
  	"es.array.iterator",
  	"es.map",
  	"es.object.keys",
  	"es.object.to-string",
  	"es.set",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.structured-clone"
  ],
  	"core-js/features/suppressed-error": [
  ],
  	"core-js/features/symbol": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.array.concat",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag",
  	"esnext.function.metadata",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.custom-matcher",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.symbol.replace-all",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/symbol/async-dispose": [
  	"esnext.symbol.async-dispose"
  ],
  	"core-js/features/symbol/async-iterator": [
  	"es.symbol.async-iterator"
  ],
  	"core-js/features/symbol/custom-matcher": [
  	"esnext.symbol.custom-matcher"
  ],
  	"core-js/features/symbol/description": [
  	"es.symbol.description"
  ],
  	"core-js/features/symbol/dispose": [
  	"esnext.symbol.dispose"
  ],
  	"core-js/features/symbol/for": [
  	"es.symbol"
  ],
  	"core-js/features/symbol/has-instance": [
  	"es.symbol.has-instance",
  	"es.function.has-instance"
  ],
  	"core-js/features/symbol/is-concat-spreadable": [
  	"es.symbol.is-concat-spreadable",
  	"es.array.concat"
  ],
  	"core-js/features/symbol/is-registered": [
  	"es.symbol",
  	"esnext.symbol.is-registered"
  ],
  	"core-js/features/symbol/is-registered-symbol": [
  	"es.symbol",
  	"esnext.symbol.is-registered-symbol"
  ],
  	"core-js/features/symbol/is-well-known": [
  	"es.symbol",
  	"esnext.symbol.is-well-known"
  ],
  	"core-js/features/symbol/is-well-known-symbol": [
  	"es.symbol",
  	"esnext.symbol.is-well-known-symbol"
  ],
  	"core-js/features/symbol/iterator": [
  	"es.symbol.iterator",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/symbol/key-for": [
  	"es.symbol"
  ],
  	"core-js/features/symbol/match": [
  	"es.symbol.match",
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/features/symbol/match-all": [
  	"es.symbol.match-all",
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/features/symbol/matcher": [
  	"esnext.symbol.matcher"
  ],
  	"core-js/features/symbol/metadata": [
  	"esnext.function.metadata",
  	"esnext.symbol.metadata"
  ],
  	"core-js/features/symbol/metadata-key": [
  	"esnext.symbol.metadata-key"
  ],
  	"core-js/features/symbol/observable": [
  	"esnext.symbol.observable"
  ],
  	"core-js/features/symbol/pattern-match": [
  	"esnext.symbol.pattern-match"
  ],
  	"core-js/features/symbol/replace": [
  	"es.symbol.replace",
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/features/symbol/replace-all": [
  	"esnext.symbol.replace-all"
  ],
  	"core-js/features/symbol/search": [
  	"es.symbol.search",
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/features/symbol/species": [
  	"es.symbol.species"
  ],
  	"core-js/features/symbol/split": [
  	"es.symbol.split",
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/features/symbol/to-primitive": [
  	"es.symbol.to-primitive",
  	"es.date.to-primitive"
  ],
  	"core-js/features/symbol/to-string-tag": [
  	"es.symbol.to-string-tag",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/features/symbol/unscopables": [
  	"es.symbol.unscopables"
  ],
  	"core-js/features/typed-array": [
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/at": [
  	"es.typed-array.at",
  	"esnext.typed-array.at"
  ],
  	"core-js/features/typed-array/copy-within": [
  	"es.typed-array.copy-within"
  ],
  	"core-js/features/typed-array/entries": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/features/typed-array/every": [
  	"es.typed-array.every"
  ],
  	"core-js/features/typed-array/fill": [
  	"es.typed-array.fill"
  ],
  	"core-js/features/typed-array/filter": [
  	"es.typed-array.filter"
  ],
  	"core-js/features/typed-array/filter-out": [
  	"esnext.typed-array.filter-out"
  ],
  	"core-js/features/typed-array/filter-reject": [
  	"esnext.typed-array.filter-reject"
  ],
  	"core-js/features/typed-array/find": [
  	"es.typed-array.find"
  ],
  	"core-js/features/typed-array/find-index": [
  	"es.typed-array.find-index"
  ],
  	"core-js/features/typed-array/find-last": [
  	"es.typed-array.find-last",
  	"esnext.typed-array.find-last"
  ],
  	"core-js/features/typed-array/find-last-index": [
  	"es.typed-array.find-last-index",
  	"esnext.typed-array.find-last-index"
  ],
  	"core-js/features/typed-array/float32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.float32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/float64-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.float64-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/for-each": [
  	"es.typed-array.for-each"
  ],
  	"core-js/features/typed-array/from": [
  	"es.typed-array.from"
  ],
  	"core-js/features/typed-array/from-async": [
  	"esnext.typed-array.from-async"
  ],
  	"core-js/features/typed-array/from-base64": [
  	"esnext.uint8-array.from-base64"
  ],
  	"core-js/features/typed-array/from-hex": [
  	"esnext.uint8-array.from-hex"
  ],
  	"core-js/features/typed-array/group-by": [
  	"esnext.typed-array.group-by"
  ],
  	"core-js/features/typed-array/includes": [
  	"es.typed-array.includes"
  ],
  	"core-js/features/typed-array/index-of": [
  	"es.typed-array.index-of"
  ],
  	"core-js/features/typed-array/int16-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.int16-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/int32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.int32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/int8-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.int8-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/iterator": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/features/typed-array/join": [
  	"es.typed-array.join"
  ],
  	"core-js/features/typed-array/keys": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/features/typed-array/last-index-of": [
  	"es.typed-array.last-index-of"
  ],
  	"core-js/features/typed-array/map": [
  	"es.typed-array.map"
  ],
  	"core-js/features/typed-array/methods": [
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/of": [
  	"es.typed-array.of"
  ],
  	"core-js/features/typed-array/reduce": [
  	"es.typed-array.reduce"
  ],
  	"core-js/features/typed-array/reduce-right": [
  	"es.typed-array.reduce-right"
  ],
  	"core-js/features/typed-array/reverse": [
  	"es.typed-array.reverse"
  ],
  	"core-js/features/typed-array/set": [
  	"es.typed-array.set"
  ],
  	"core-js/features/typed-array/set-from-base64": [
  	"esnext.uint8-array.set-from-base64"
  ],
  	"core-js/features/typed-array/set-from-hex": [
  	"esnext.uint8-array.set-from-hex"
  ],
  	"core-js/features/typed-array/slice": [
  	"es.typed-array.slice"
  ],
  	"core-js/features/typed-array/some": [
  	"es.typed-array.some"
  ],
  	"core-js/features/typed-array/sort": [
  	"es.typed-array.sort"
  ],
  	"core-js/features/typed-array/subarray": [
  	"es.typed-array.subarray"
  ],
  	"core-js/features/typed-array/to-base64": [
  	"esnext.uint8-array.to-base64"
  ],
  	"core-js/features/typed-array/to-hex": [
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/to-locale-string": [
  	"es.typed-array.to-locale-string"
  ],
  	"core-js/features/typed-array/to-reversed": [
  	"es.typed-array.to-reversed",
  	"esnext.typed-array.to-reversed"
  ],
  	"core-js/features/typed-array/to-sorted": [
  	"es.typed-array.sort",
  	"es.typed-array.to-sorted",
  	"esnext.typed-array.to-sorted"
  ],
  	"core-js/features/typed-array/to-spliced": [
  	"esnext.typed-array.to-spliced"
  ],
  	"core-js/features/typed-array/to-string": [
  	"es.typed-array.to-string"
  ],
  	"core-js/features/typed-array/uint16-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.uint16-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/uint32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/uint8-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.uint8-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/uint8-clamped-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/features/typed-array/unique-by": [
  	"es.map",
  	"esnext.typed-array.unique-by"
  ],
  	"core-js/features/typed-array/values": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/features/typed-array/with": [
  	"es.typed-array.with",
  	"esnext.typed-array.with"
  ],
  	"core-js/features/unescape": [
  	"es.unescape"
  ],
  	"core-js/features/url": [
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/features/url-search-params": [
  	"web.dom-collections.iterator",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/features/url/can-parse": [
  	"web.url",
  	"web.url.can-parse"
  ],
  	"core-js/features/url/parse": [
  	"web.url",
  	"web.url.parse"
  ],
  	"core-js/features/url/to-json": [
  	"web.url.to-json"
  ],
  	"core-js/features/weak-map": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.weak-map",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/weak-map/delete-all": [
  	"es.weak-map",
  	"esnext.weak-map.delete-all"
  ],
  	"core-js/features/weak-map/emplace": [
  	"es.weak-map",
  	"esnext.weak-map.emplace"
  ],
  	"core-js/features/weak-map/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.weak-map",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.emplace",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/weak-map/of": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.weak-map",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace"
  ],
  	"core-js/features/weak-map/upsert": [
  	"es.weak-map",
  	"esnext.weak-map.upsert"
  ],
  	"core-js/features/weak-set": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.weak-set",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/weak-set/add-all": [
  	"es.weak-set",
  	"esnext.weak-set.add-all"
  ],
  	"core-js/features/weak-set/delete-all": [
  	"es.weak-set",
  	"esnext.weak-set.delete-all"
  ],
  	"core-js/features/weak-set/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.weak-set",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"web.dom-collections.iterator"
  ],
  	"core-js/features/weak-set/of": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.weak-set",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.of"
  ],
  	"core-js/full": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.error.cause",
  	"es.error.to-string",
  	"es.aggregate-error",
  	"es.aggregate-error.cause",
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string",
  	"es.escape",
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name",
  	"es.global-this",
  	"es.json.stringify",
  	"es.json.to-string-tag",
  	"es.map",
  	"es.map.group-by",
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc",
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.parse-float",
  	"es.parse-int",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag",
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"es.unescape",
  	"es.weak-map",
  	"es.weak-set",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.bigint.range",
  	"esnext.composite-key",
  	"esnext.composite-symbol",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.demethodize",
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor",
  	"esnext.function.metadata",
  	"esnext.function.un-this",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.f16round",
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.sum-precise",
  	"esnext.math.umulh",
  	"esnext.number.from-string",
  	"esnext.number.range",
  	"esnext.object.has-own",
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values",
  	"esnext.object.group-by",
  	"esnext.observable",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.reflect.define-metadata",
  	"esnext.reflect.delete-metadata",
  	"esnext.reflect.get-metadata",
  	"esnext.reflect.get-metadata-keys",
  	"esnext.reflect.get-own-metadata",
  	"esnext.reflect.get-own-metadata-keys",
  	"esnext.reflect.has-metadata",
  	"esnext.reflect.has-own-metadata",
  	"esnext.reflect.metadata",
  	"esnext.regexp.escape",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"esnext.string.at",
  	"esnext.string.cooked",
  	"esnext.string.code-points",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.custom-matcher",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.symbol.replace-all",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of",
  	"web.atob",
  	"web.btoa",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.immediate",
  	"web.queue-microtask",
  	"web.self",
  	"web.structured-clone",
  	"web.timers",
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/full/aggregate-error": [
  ],
  	"core-js/full/array": [
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with"
  ],
  	"core-js/full/array-buffer": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.object.to-string",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/full/array-buffer/constructor": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.object.to-string",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/full/array-buffer/detached": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.array-buffer.detached",
  	"esnext.array-buffer.detached"
  ],
  	"core-js/full/array-buffer/is-view": [
  	"es.array-buffer.is-view"
  ],
  	"core-js/full/array-buffer/slice": [
  	"es.array-buffer.slice"
  ],
  	"core-js/full/array-buffer/transfer": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.transfer",
  	"esnext.array-buffer.transfer"
  ],
  	"core-js/full/array-buffer/transfer-to-fixed-length": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.transfer-to-fixed-length",
  	"esnext.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/full/array/at": [
  	"es.array.at",
  	"esnext.array.at"
  ],
  	"core-js/full/array/concat": [
  	"es.array.concat"
  ],
  	"core-js/full/array/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/full/array/entries": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/full/array/every": [
  	"es.array.every"
  ],
  	"core-js/full/array/fill": [
  	"es.array.fill"
  ],
  	"core-js/full/array/filter": [
  	"es.array.filter"
  ],
  	"core-js/full/array/filter-out": [
  	"esnext.array.filter-out"
  ],
  	"core-js/full/array/filter-reject": [
  	"esnext.array.filter-reject"
  ],
  	"core-js/full/array/find": [
  	"es.array.find"
  ],
  	"core-js/full/array/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/full/array/find-last": [
  	"es.array.find-last",
  	"esnext.array.find-last"
  ],
  	"core-js/full/array/find-last-index": [
  	"es.array.find-last-index",
  	"esnext.array.find-last-index"
  ],
  	"core-js/full/array/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/full/array/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/full/array/for-each": [
  	"es.array.for-each"
  ],
  	"core-js/full/array/from": [
  	"es.array.from",
  	"es.string.iterator"
  ],
  	"core-js/full/array/from-async": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.array.from-async"
  ],
  	"core-js/full/array/group": [
  	"esnext.array.group"
  ],
  	"core-js/full/array/group-by": [
  	"esnext.array.group-by"
  ],
  	"core-js/full/array/group-by-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-by-to-map"
  ],
  	"core-js/full/array/group-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-to-map"
  ],
  	"core-js/full/array/includes": [
  	"es.array.includes"
  ],
  	"core-js/full/array/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/full/array/is-array": [
  	"es.array.is-array"
  ],
  	"core-js/full/array/is-template-object": [
  	"esnext.array.is-template-object"
  ],
  	"core-js/full/array/iterator": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/full/array/join": [
  	"es.array.join"
  ],
  	"core-js/full/array/keys": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/full/array/last-index": [
  	"esnext.array.last-index"
  ],
  	"core-js/full/array/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/full/array/last-item": [
  	"esnext.array.last-item"
  ],
  	"core-js/full/array/map": [
  	"es.array.map"
  ],
  	"core-js/full/array/of": [
  	"es.array.of"
  ],
  	"core-js/full/array/push": [
  	"es.array.push"
  ],
  	"core-js/full/array/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/full/array/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/full/array/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/full/array/slice": [
  	"es.array.slice"
  ],
  	"core-js/full/array/some": [
  	"es.array.some"
  ],
  	"core-js/full/array/sort": [
  	"es.array.sort"
  ],
  	"core-js/full/array/splice": [
  	"es.array.splice"
  ],
  	"core-js/full/array/to-reversed": [
  	"es.array.to-reversed",
  	"esnext.array.to-reversed"
  ],
  	"core-js/full/array/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted",
  	"esnext.array.to-sorted"
  ],
  	"core-js/full/array/to-spliced": [
  	"es.array.to-spliced",
  	"esnext.array.to-spliced"
  ],
  	"core-js/full/array/unique-by": [
  	"es.map",
  	"esnext.array.unique-by"
  ],
  	"core-js/full/array/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/full/array/values": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/full/array/virtual": [
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with"
  ],
  	"core-js/full/array/virtual/at": [
  	"es.array.at",
  	"esnext.array.at"
  ],
  	"core-js/full/array/virtual/concat": [
  	"es.array.concat"
  ],
  	"core-js/full/array/virtual/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/full/array/virtual/entries": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/full/array/virtual/every": [
  	"es.array.every"
  ],
  	"core-js/full/array/virtual/fill": [
  	"es.array.fill"
  ],
  	"core-js/full/array/virtual/filter": [
  	"es.array.filter"
  ],
  	"core-js/full/array/virtual/filter-out": [
  	"esnext.array.filter-out"
  ],
  	"core-js/full/array/virtual/filter-reject": [
  	"esnext.array.filter-reject"
  ],
  	"core-js/full/array/virtual/find": [
  	"es.array.find"
  ],
  	"core-js/full/array/virtual/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/full/array/virtual/find-last": [
  	"es.array.find-last",
  	"esnext.array.find-last"
  ],
  	"core-js/full/array/virtual/find-last-index": [
  	"es.array.find-last-index",
  	"esnext.array.find-last-index"
  ],
  	"core-js/full/array/virtual/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/full/array/virtual/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/full/array/virtual/for-each": [
  	"es.array.for-each"
  ],
  	"core-js/full/array/virtual/group": [
  	"esnext.array.group"
  ],
  	"core-js/full/array/virtual/group-by": [
  	"esnext.array.group-by"
  ],
  	"core-js/full/array/virtual/group-by-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-by-to-map"
  ],
  	"core-js/full/array/virtual/group-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-to-map"
  ],
  	"core-js/full/array/virtual/includes": [
  	"es.array.includes"
  ],
  	"core-js/full/array/virtual/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/full/array/virtual/iterator": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/full/array/virtual/join": [
  	"es.array.join"
  ],
  	"core-js/full/array/virtual/keys": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/full/array/virtual/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/full/array/virtual/map": [
  	"es.array.map"
  ],
  	"core-js/full/array/virtual/push": [
  	"es.array.push"
  ],
  	"core-js/full/array/virtual/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/full/array/virtual/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/full/array/virtual/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/full/array/virtual/slice": [
  	"es.array.slice"
  ],
  	"core-js/full/array/virtual/some": [
  	"es.array.some"
  ],
  	"core-js/full/array/virtual/sort": [
  	"es.array.sort"
  ],
  	"core-js/full/array/virtual/splice": [
  	"es.array.splice"
  ],
  	"core-js/full/array/virtual/to-reversed": [
  	"es.array.to-reversed",
  	"esnext.array.to-reversed"
  ],
  	"core-js/full/array/virtual/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted",
  	"esnext.array.to-sorted"
  ],
  	"core-js/full/array/virtual/to-spliced": [
  	"es.array.to-spliced",
  	"esnext.array.to-spliced"
  ],
  	"core-js/full/array/virtual/unique-by": [
  	"es.map",
  	"esnext.array.unique-by"
  ],
  	"core-js/full/array/virtual/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/full/array/virtual/values": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/full/array/virtual/with": [
  	"es.array.with",
  	"esnext.array.with"
  ],
  	"core-js/full/array/with": [
  	"es.array.with",
  	"esnext.array.with"
  ],
  	"core-js/full/async-disposable-stack": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"es.promise",
  	"esnext.suppressed-error.constructor",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.iterator.dispose"
  ],
  	"core-js/full/async-disposable-stack/constructor": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"es.promise",
  	"esnext.suppressed-error.constructor",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.iterator.dispose"
  ],
  	"core-js/full/async-iterator": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/async-iterator/as-indexed-pairs": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs"
  ],
  	"core-js/full/async-iterator/async-dispose": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.async-dispose"
  ],
  	"core-js/full/async-iterator/drop": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.drop"
  ],
  	"core-js/full/async-iterator/every": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.every"
  ],
  	"core-js/full/async-iterator/filter": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.filter"
  ],
  	"core-js/full/async-iterator/find": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.find"
  ],
  	"core-js/full/async-iterator/flat-map": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.flat-map"
  ],
  	"core-js/full/async-iterator/for-each": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.for-each"
  ],
  	"core-js/full/async-iterator/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/async-iterator/indexed": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.indexed"
  ],
  	"core-js/full/async-iterator/map": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.map"
  ],
  	"core-js/full/async-iterator/reduce": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.reduce"
  ],
  	"core-js/full/async-iterator/some": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.some"
  ],
  	"core-js/full/async-iterator/take": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.take"
  ],
  	"core-js/full/async-iterator/to-array": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.to-array"
  ],
  	"core-js/full/atob": [
  	"es.error.to-string",
  	"es.object.to-string",
  	"web.atob",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/full/bigint": [
  	"es.object.to-string",
  	"esnext.bigint.range"
  ],
  	"core-js/full/bigint/range": [
  	"es.object.to-string",
  	"esnext.bigint.range"
  ],
  	"core-js/full/btoa": [
  	"es.error.to-string",
  	"es.object.to-string",
  	"web.btoa",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/full/clear-immediate": [
  	"web.immediate"
  ],
  	"core-js/full/composite-key": [
  	"esnext.composite-key"
  ],
  	"core-js/full/composite-symbol": [
  	"es.symbol",
  	"esnext.composite-symbol"
  ],
  	"core-js/full/data-view": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.object.to-string",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped"
  ],
  	"core-js/full/data-view/get-float16": [
  	"esnext.data-view.get-float16"
  ],
  	"core-js/full/data-view/get-uint8-clamped": [
  	"esnext.data-view.get-uint8-clamped"
  ],
  	"core-js/full/data-view/set-float16": [
  	"esnext.data-view.set-float16"
  ],
  	"core-js/full/data-view/set-uint8-clamped": [
  	"esnext.data-view.set-uint8-clamped"
  ],
  	"core-js/full/date": [
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string"
  ],
  	"core-js/full/date/get-year": [
  	"es.date.get-year"
  ],
  	"core-js/full/date/now": [
  	"es.date.now"
  ],
  	"core-js/full/date/set-year": [
  	"es.date.set-year"
  ],
  	"core-js/full/date/to-gmt-string": [
  	"es.date.to-gmt-string"
  ],
  	"core-js/full/date/to-iso-string": [
  	"es.date.to-iso-string",
  	"es.date.to-json"
  ],
  	"core-js/full/date/to-json": [
  	"es.date.to-json"
  ],
  	"core-js/full/date/to-primitive": [
  	"es.date.to-primitive"
  ],
  	"core-js/full/date/to-string": [
  	"es.date.to-string"
  ],
  	"core-js/full/disposable-stack": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"esnext.suppressed-error.constructor",
  	"esnext.disposable-stack.constructor",
  	"esnext.iterator.dispose"
  ],
  	"core-js/full/disposable-stack/constructor": [
  	"es.error.cause",
  	"es.error.to-string",
  	"es.object.to-string",
  	"esnext.suppressed-error.constructor",
  	"esnext.disposable-stack.constructor",
  	"esnext.iterator.dispose"
  ],
  	"core-js/full/dom-collections": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/dom-collections/for-each": [
  	"web.dom-collections.for-each"
  ],
  	"core-js/full/dom-collections/iterator": [
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/dom-exception": [
  	"es.error.to-string",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/full/dom-exception/constructor": [
  	"es.error.to-string",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack"
  ],
  	"core-js/full/dom-exception/to-string-tag": [
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/full/error": [
  	"es.error.cause",
  	"es.error.to-string"
  ],
  	"core-js/full/error/constructor": [
  	"es.error.cause"
  ],
  	"core-js/full/error/to-string": [
  	"es.error.to-string"
  ],
  	"core-js/full/escape": [
  	"es.escape"
  ],
  	"core-js/full/function": [
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name",
  	"esnext.function.demethodize",
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor",
  	"esnext.function.metadata",
  	"esnext.function.un-this"
  ],
  	"core-js/full/function/bind": [
  	"es.function.bind"
  ],
  	"core-js/full/function/demethodize": [
  	"esnext.function.demethodize"
  ],
  	"core-js/full/function/has-instance": [
  	"es.function.has-instance"
  ],
  	"core-js/full/function/is-callable": [
  	"esnext.function.is-callable"
  ],
  	"core-js/full/function/is-constructor": [
  	"esnext.function.is-constructor"
  ],
  	"core-js/full/function/metadata": [
  	"esnext.function.metadata"
  ],
  	"core-js/full/function/name": [
  	"es.function.name"
  ],
  	"core-js/full/function/un-this": [
  	"esnext.function.un-this"
  ],
  	"core-js/full/function/virtual": [
  	"es.function.bind",
  	"esnext.function.demethodize",
  	"esnext.function.un-this"
  ],
  	"core-js/full/function/virtual/bind": [
  	"es.function.bind"
  ],
  	"core-js/full/function/virtual/demethodize": [
  	"esnext.function.demethodize"
  ],
  	"core-js/full/function/virtual/un-this": [
  	"esnext.function.un-this"
  ],
  	"core-js/full/get-iterator": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/get-iterator-method": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/global-this": [
  	"es.global-this",
  	"esnext.global-this"
  ],
  	"core-js/full/instance/at": [
  	"es.array.at",
  	"es.string.at-alternative",
  	"esnext.array.at",
  	"esnext.string.at"
  ],
  	"core-js/full/instance/bind": [
  	"es.function.bind"
  ],
  	"core-js/full/instance/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/full/instance/code-points": [
  	"es.object.to-string",
  	"esnext.string.code-points"
  ],
  	"core-js/full/instance/concat": [
  	"es.array.concat"
  ],
  	"core-js/full/instance/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/full/instance/demethodize": [
  	"esnext.function.demethodize"
  ],
  	"core-js/full/instance/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/full/instance/entries": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/instance/every": [
  	"es.array.every"
  ],
  	"core-js/full/instance/fill": [
  	"es.array.fill"
  ],
  	"core-js/full/instance/filter": [
  	"es.array.filter"
  ],
  	"core-js/full/instance/filter-out": [
  	"esnext.array.filter-out"
  ],
  	"core-js/full/instance/filter-reject": [
  	"esnext.array.filter-reject"
  ],
  	"core-js/full/instance/find": [
  	"es.array.find"
  ],
  	"core-js/full/instance/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/full/instance/find-last": [
  	"es.array.find-last",
  	"esnext.array.find-last"
  ],
  	"core-js/full/instance/find-last-index": [
  	"es.array.find-last-index",
  	"esnext.array.find-last-index"
  ],
  	"core-js/full/instance/flags": [
  	"es.regexp.flags"
  ],
  	"core-js/full/instance/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/full/instance/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/full/instance/for-each": [
  	"es.array.for-each",
  	"web.dom-collections.for-each"
  ],
  	"core-js/full/instance/group": [
  	"esnext.array.group"
  ],
  	"core-js/full/instance/group-by": [
  	"esnext.array.group-by"
  ],
  	"core-js/full/instance/group-by-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-by-to-map"
  ],
  	"core-js/full/instance/group-to-map": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.array.group-to-map"
  ],
  	"core-js/full/instance/includes": [
  	"es.array.includes",
  	"es.string.includes"
  ],
  	"core-js/full/instance/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/full/instance/is-well-formed": [
  	"es.string.is-well-formed"
  ],
  	"core-js/full/instance/keys": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/instance/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/full/instance/map": [
  	"es.array.map"
  ],
  	"core-js/full/instance/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all",
  	"esnext.string.match-all"
  ],
  	"core-js/full/instance/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/full/instance/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/full/instance/push": [
  	"es.array.push"
  ],
  	"core-js/full/instance/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/full/instance/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/full/instance/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/full/instance/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all",
  	"esnext.string.replace-all"
  ],
  	"core-js/full/instance/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/full/instance/slice": [
  	"es.array.slice"
  ],
  	"core-js/full/instance/some": [
  	"es.array.some"
  ],
  	"core-js/full/instance/sort": [
  	"es.array.sort"
  ],
  	"core-js/full/instance/splice": [
  	"es.array.splice"
  ],
  	"core-js/full/instance/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/full/instance/to-reversed": [
  	"es.array.to-reversed",
  	"esnext.array.to-reversed"
  ],
  	"core-js/full/instance/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted",
  	"esnext.array.to-sorted"
  ],
  	"core-js/full/instance/to-spliced": [
  	"es.array.to-spliced",
  	"esnext.array.to-spliced"
  ],
  	"core-js/full/instance/to-well-formed": [
  	"es.string.to-well-formed"
  ],
  	"core-js/full/instance/trim": [
  	"es.string.trim"
  ],
  	"core-js/full/instance/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/full/instance/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/full/instance/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/full/instance/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/full/instance/un-this": [
  	"esnext.function.un-this"
  ],
  	"core-js/full/instance/unique-by": [
  	"es.map",
  	"esnext.array.unique-by"
  ],
  	"core-js/full/instance/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/full/instance/values": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/instance/with": [
  	"es.array.with",
  	"esnext.array.with"
  ],
  	"core-js/full/is-iterable": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/iterator": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/iterator/as-indexed-pairs": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs"
  ],
  	"core-js/full/iterator/dispose": [
  	"esnext.iterator.dispose"
  ],
  	"core-js/full/iterator/drop": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.drop"
  ],
  	"core-js/full/iterator/every": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.every"
  ],
  	"core-js/full/iterator/filter": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.filter"
  ],
  	"core-js/full/iterator/find": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.find"
  ],
  	"core-js/full/iterator/flat-map": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.flat-map"
  ],
  	"core-js/full/iterator/for-each": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.for-each"
  ],
  	"core-js/full/iterator/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"esnext.iterator.constructor",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.map",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/iterator/indexed": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.indexed"
  ],
  	"core-js/full/iterator/map": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.map"
  ],
  	"core-js/full/iterator/range": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.range"
  ],
  	"core-js/full/iterator/reduce": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.reduce"
  ],
  	"core-js/full/iterator/some": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.some"
  ],
  	"core-js/full/iterator/take": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.take"
  ],
  	"core-js/full/iterator/to-array": [
  	"es.object.to-string",
  	"esnext.iterator.constructor",
  	"esnext.iterator.to-array"
  ],
  	"core-js/full/iterator/to-async": [
  	"es.object.to-string",
  	"es.promise",
  	"esnext.iterator.constructor",
  	"esnext.iterator.to-async"
  ],
  	"core-js/full/json": [
  	"es.date.to-json",
  	"es.json.stringify",
  	"es.json.to-string-tag",
  	"es.object.create",
  	"es.object.freeze",
  	"es.object.keys",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json"
  ],
  	"core-js/full/json/is-raw-json": [
  	"esnext.json.is-raw-json"
  ],
  	"core-js/full/json/parse": [
  	"es.object.keys",
  	"esnext.json.parse"
  ],
  	"core-js/full/json/raw-json": [
  	"es.object.create",
  	"es.object.freeze",
  	"esnext.json.raw-json"
  ],
  	"core-js/full/json/stringify": [
  	"es.date.to-json",
  	"es.json.stringify"
  ],
  	"core-js/full/json/to-string-tag": [
  	"es.json.to-string-tag"
  ],
  	"core-js/full/map": [
  	"es.array.iterator",
  	"es.map",
  	"es.map.group-by",
  	"es.object.to-string",
  	"es.string.iterator",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/map/delete-all": [
  	"es.map",
  	"esnext.map.delete-all"
  ],
  	"core-js/full/map/emplace": [
  	"es.map",
  	"esnext.map.emplace"
  ],
  	"core-js/full/map/every": [
  	"es.map",
  	"esnext.map.every"
  ],
  	"core-js/full/map/filter": [
  	"es.map",
  	"esnext.map.filter"
  ],
  	"core-js/full/map/find": [
  	"es.map",
  	"esnext.map.find"
  ],
  	"core-js/full/map/find-key": [
  	"es.map",
  	"esnext.map.find-key"
  ],
  	"core-js/full/map/from": [
  	"es.array.iterator",
  	"es.map",
  	"es.object.to-string",
  	"es.string.iterator",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.includes",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/map/group-by": [
  	"es.map",
  	"es.map.group-by",
  	"es.object.to-string",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update"
  ],
  	"core-js/full/map/includes": [
  	"es.map",
  	"esnext.map.includes"
  ],
  	"core-js/full/map/key-by": [
  	"es.map",
  	"es.object.to-string",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update"
  ],
  	"core-js/full/map/key-of": [
  	"es.map",
  	"esnext.map.key-of"
  ],
  	"core-js/full/map/map-keys": [
  	"es.map",
  	"esnext.map.map-keys"
  ],
  	"core-js/full/map/map-values": [
  	"es.map",
  	"esnext.map.map-values"
  ],
  	"core-js/full/map/merge": [
  	"es.map",
  	"esnext.map.merge"
  ],
  	"core-js/full/map/of": [
  	"es.array.iterator",
  	"es.map",
  	"es.object.to-string",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.includes",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update"
  ],
  	"core-js/full/map/reduce": [
  	"es.map",
  	"esnext.map.reduce"
  ],
  	"core-js/full/map/some": [
  	"es.map",
  	"esnext.map.some"
  ],
  	"core-js/full/map/update": [
  	"es.map",
  	"esnext.map.update"
  ],
  	"core-js/full/map/update-or-insert": [
  	"es.map",
  	"esnext.map.update-or-insert"
  ],
  	"core-js/full/map/upsert": [
  	"es.map",
  	"esnext.map.upsert"
  ],
  	"core-js/full/math": [
  	"es.array.iterator",
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.f16round",
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.sum-precise",
  	"esnext.math.umulh"
  ],
  	"core-js/full/math/acosh": [
  	"es.math.acosh"
  ],
  	"core-js/full/math/asinh": [
  	"es.math.asinh"
  ],
  	"core-js/full/math/atanh": [
  	"es.math.atanh"
  ],
  	"core-js/full/math/cbrt": [
  	"es.math.cbrt"
  ],
  	"core-js/full/math/clamp": [
  	"esnext.math.clamp"
  ],
  	"core-js/full/math/clz32": [
  	"es.math.clz32"
  ],
  	"core-js/full/math/cosh": [
  	"es.math.cosh"
  ],
  	"core-js/full/math/deg-per-rad": [
  	"esnext.math.deg-per-rad"
  ],
  	"core-js/full/math/degrees": [
  	"esnext.math.degrees"
  ],
  	"core-js/full/math/expm1": [
  	"es.math.expm1"
  ],
  	"core-js/full/math/f16round": [
  	"esnext.math.f16round"
  ],
  	"core-js/full/math/fround": [
  	"es.math.fround"
  ],
  	"core-js/full/math/fscale": [
  	"esnext.math.fscale"
  ],
  	"core-js/full/math/hypot": [
  	"es.math.hypot"
  ],
  	"core-js/full/math/iaddh": [
  	"esnext.math.iaddh"
  ],
  	"core-js/full/math/imul": [
  	"es.math.imul"
  ],
  	"core-js/full/math/imulh": [
  	"esnext.math.imulh"
  ],
  	"core-js/full/math/isubh": [
  	"esnext.math.isubh"
  ],
  	"core-js/full/math/log10": [
  	"es.math.log10"
  ],
  	"core-js/full/math/log1p": [
  	"es.math.log1p"
  ],
  	"core-js/full/math/log2": [
  	"es.math.log2"
  ],
  	"core-js/full/math/rad-per-deg": [
  	"esnext.math.rad-per-deg"
  ],
  	"core-js/full/math/radians": [
  	"esnext.math.radians"
  ],
  	"core-js/full/math/scale": [
  	"esnext.math.scale"
  ],
  	"core-js/full/math/seeded-prng": [
  	"esnext.math.seeded-prng"
  ],
  	"core-js/full/math/sign": [
  	"es.math.sign"
  ],
  	"core-js/full/math/signbit": [
  	"esnext.math.signbit"
  ],
  	"core-js/full/math/sinh": [
  	"es.math.sinh"
  ],
  	"core-js/full/math/sum-precise": [
  	"es.array.iterator",
  	"esnext.math.sum-precise"
  ],
  	"core-js/full/math/tanh": [
  	"es.math.tanh"
  ],
  	"core-js/full/math/to-string-tag": [
  	"es.math.to-string-tag"
  ],
  	"core-js/full/math/trunc": [
  	"es.math.trunc"
  ],
  	"core-js/full/math/umulh": [
  	"esnext.math.umulh"
  ],
  	"core-js/full/number": [
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision",
  	"es.object.to-string",
  	"esnext.number.from-string",
  	"esnext.number.range"
  ],
  	"core-js/full/number/constructor": [
  	"es.number.constructor"
  ],
  	"core-js/full/number/epsilon": [
  	"es.number.epsilon"
  ],
  	"core-js/full/number/from-string": [
  	"esnext.number.from-string"
  ],
  	"core-js/full/number/is-finite": [
  	"es.number.is-finite"
  ],
  	"core-js/full/number/is-integer": [
  	"es.number.is-integer"
  ],
  	"core-js/full/number/is-nan": [
  	"es.number.is-nan"
  ],
  	"core-js/full/number/is-safe-integer": [
  	"es.number.is-safe-integer"
  ],
  	"core-js/full/number/max-safe-integer": [
  	"es.number.max-safe-integer"
  ],
  	"core-js/full/number/min-safe-integer": [
  	"es.number.min-safe-integer"
  ],
  	"core-js/full/number/parse-float": [
  	"es.number.parse-float"
  ],
  	"core-js/full/number/parse-int": [
  	"es.number.parse-int"
  ],
  	"core-js/full/number/range": [
  	"es.object.to-string",
  	"esnext.number.range"
  ],
  	"core-js/full/number/to-exponential": [
  	"es.number.to-exponential"
  ],
  	"core-js/full/number/to-fixed": [
  	"es.number.to-fixed"
  ],
  	"core-js/full/number/to-precision": [
  	"es.number.to-precision"
  ],
  	"core-js/full/number/virtual": [
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision"
  ],
  	"core-js/full/number/virtual/to-exponential": [
  	"es.number.to-exponential"
  ],
  	"core-js/full/number/virtual/to-fixed": [
  	"es.number.to-fixed"
  ],
  	"core-js/full/number/virtual/to-precision": [
  	"es.number.to-precision"
  ],
  	"core-js/full/object": [
  	"es.symbol",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.reflect.to-string-tag",
  	"esnext.object.has-own",
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values",
  	"esnext.object.group-by",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/object/assign": [
  	"es.object.assign"
  ],
  	"core-js/full/object/create": [
  	"es.object.create"
  ],
  	"core-js/full/object/define-getter": [
  	"es.object.define-getter"
  ],
  	"core-js/full/object/define-properties": [
  	"es.object.define-properties"
  ],
  	"core-js/full/object/define-property": [
  	"es.object.define-property"
  ],
  	"core-js/full/object/define-setter": [
  	"es.object.define-setter"
  ],
  	"core-js/full/object/entries": [
  	"es.object.entries"
  ],
  	"core-js/full/object/freeze": [
  	"es.object.freeze"
  ],
  	"core-js/full/object/from-entries": [
  	"es.array.iterator",
  	"es.object.from-entries",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/object/get-own-property-descriptor": [
  	"es.object.get-own-property-descriptor"
  ],
  	"core-js/full/object/get-own-property-descriptors": [
  	"es.object.get-own-property-descriptors"
  ],
  	"core-js/full/object/get-own-property-names": [
  	"es.object.get-own-property-names"
  ],
  	"core-js/full/object/get-own-property-symbols": [
  	"es.symbol"
  ],
  	"core-js/full/object/get-prototype-of": [
  	"es.object.get-prototype-of"
  ],
  	"core-js/full/object/group-by": [
  	"es.object.create",
  	"es.object.group-by",
  	"esnext.object.group-by"
  ],
  	"core-js/full/object/has-own": [
  	"es.object.has-own",
  	"esnext.object.has-own"
  ],
  	"core-js/full/object/is": [
  	"es.object.is"
  ],
  	"core-js/full/object/is-extensible": [
  	"es.object.is-extensible"
  ],
  	"core-js/full/object/is-frozen": [
  	"es.object.is-frozen"
  ],
  	"core-js/full/object/is-sealed": [
  	"es.object.is-sealed"
  ],
  	"core-js/full/object/iterate-entries": [
  	"esnext.object.iterate-entries"
  ],
  	"core-js/full/object/iterate-keys": [
  	"esnext.object.iterate-keys"
  ],
  	"core-js/full/object/iterate-values": [
  	"esnext.object.iterate-values"
  ],
  	"core-js/full/object/keys": [
  	"es.object.keys"
  ],
  	"core-js/full/object/lookup-getter": [
  	"es.object.lookup-getter"
  ],
  	"core-js/full/object/lookup-setter": [
  	"es.object.lookup-setter"
  ],
  	"core-js/full/object/prevent-extensions": [
  	"es.object.prevent-extensions"
  ],
  	"core-js/full/object/proto": [
  	"es.object.proto"
  ],
  	"core-js/full/object/seal": [
  	"es.object.seal"
  ],
  	"core-js/full/object/set-prototype-of": [
  	"es.object.set-prototype-of"
  ],
  	"core-js/full/object/to-string": [
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/full/object/values": [
  	"es.object.values"
  ],
  	"core-js/full/observable": [
  	"es.object.to-string",
  	"es.string.iterator",
  	"esnext.observable",
  	"esnext.symbol.observable",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/parse-float": [
  	"es.parse-float"
  ],
  	"core-js/full/parse-int": [
  	"es.parse-int"
  ],
  	"core-js/full/promise": [
  	"es.aggregate-error",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.string.iterator",
  	"esnext.aggregate-error",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/promise/all-settled": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.string.iterator",
  	"esnext.promise.all-settled",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/promise/any": [
  	"es.aggregate-error",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.any",
  	"es.string.iterator",
  	"esnext.aggregate-error",
  	"esnext.promise.any",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/promise/finally": [
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.finally"
  ],
  	"core-js/full/promise/try": [
  	"es.promise",
  	"esnext.promise.try"
  ],
  	"core-js/full/promise/with-resolvers": [
  	"es.promise",
  	"es.promise.with-resolvers",
  	"esnext.promise.with-resolvers"
  ],
  	"core-js/full/queue-microtask": [
  	"web.queue-microtask"
  ],
  	"core-js/full/reflect": [
  	"es.object.to-string",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag",
  	"esnext.reflect.define-metadata",
  	"esnext.reflect.delete-metadata",
  	"esnext.reflect.get-metadata",
  	"esnext.reflect.get-metadata-keys",
  	"esnext.reflect.get-own-metadata",
  	"esnext.reflect.get-own-metadata-keys",
  	"esnext.reflect.has-metadata",
  	"esnext.reflect.has-own-metadata",
  	"esnext.reflect.metadata"
  ],
  	"core-js/full/reflect/apply": [
  	"es.reflect.apply"
  ],
  	"core-js/full/reflect/construct": [
  	"es.reflect.construct"
  ],
  	"core-js/full/reflect/define-metadata": [
  	"esnext.reflect.define-metadata"
  ],
  	"core-js/full/reflect/define-property": [
  	"es.reflect.define-property"
  ],
  	"core-js/full/reflect/delete-metadata": [
  	"esnext.reflect.delete-metadata"
  ],
  	"core-js/full/reflect/delete-property": [
  	"es.reflect.delete-property"
  ],
  	"core-js/full/reflect/get": [
  	"es.reflect.get"
  ],
  	"core-js/full/reflect/get-metadata": [
  	"esnext.reflect.get-metadata"
  ],
  	"core-js/full/reflect/get-metadata-keys": [
  	"esnext.reflect.get-metadata-keys"
  ],
  	"core-js/full/reflect/get-own-metadata": [
  	"esnext.reflect.get-own-metadata"
  ],
  	"core-js/full/reflect/get-own-metadata-keys": [
  	"esnext.reflect.get-own-metadata-keys"
  ],
  	"core-js/full/reflect/get-own-property-descriptor": [
  	"es.reflect.get-own-property-descriptor"
  ],
  	"core-js/full/reflect/get-prototype-of": [
  	"es.reflect.get-prototype-of"
  ],
  	"core-js/full/reflect/has": [
  	"es.reflect.has"
  ],
  	"core-js/full/reflect/has-metadata": [
  	"esnext.reflect.has-metadata"
  ],
  	"core-js/full/reflect/has-own-metadata": [
  	"esnext.reflect.has-own-metadata"
  ],
  	"core-js/full/reflect/is-extensible": [
  	"es.reflect.is-extensible"
  ],
  	"core-js/full/reflect/metadata": [
  	"esnext.reflect.metadata"
  ],
  	"core-js/full/reflect/own-keys": [
  	"es.reflect.own-keys"
  ],
  	"core-js/full/reflect/prevent-extensions": [
  	"es.reflect.prevent-extensions"
  ],
  	"core-js/full/reflect/set": [
  	"es.reflect.set"
  ],
  	"core-js/full/reflect/set-prototype-of": [
  	"es.reflect.set-prototype-of"
  ],
  	"core-js/full/reflect/to-string-tag": [
  	"es.reflect.to-string-tag"
  ],
  	"core-js/full/regexp": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.string.match",
  	"es.string.replace",
  	"es.string.search",
  	"es.string.split",
  	"esnext.regexp.escape"
  ],
  	"core-js/full/regexp/constructor": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.sticky"
  ],
  	"core-js/full/regexp/dot-all": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec"
  ],
  	"core-js/full/regexp/escape": [
  	"esnext.regexp.escape"
  ],
  	"core-js/full/regexp/flags": [
  	"es.regexp.flags"
  ],
  	"core-js/full/regexp/match": [
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/full/regexp/replace": [
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/full/regexp/search": [
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/full/regexp/split": [
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/full/regexp/sticky": [
  	"es.regexp.constructor",
  	"es.regexp.exec",
  	"es.regexp.sticky"
  ],
  	"core-js/full/regexp/test": [
  	"es.regexp.exec",
  	"es.regexp.test"
  ],
  	"core-js/full/regexp/to-string": [
  	"es.regexp.to-string"
  ],
  	"core-js/full/self": [
  	"web.self"
  ],
  	"core-js/full/set": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.iterator",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/set-immediate": [
  	"web.immediate"
  ],
  	"core-js/full/set-interval": [
  	"web.timers"
  ],
  	"core-js/full/set-timeout": [
  	"web.timers"
  ],
  	"core-js/full/set/add-all": [
  	"es.set",
  	"esnext.set.add-all"
  ],
  	"core-js/full/set/delete-all": [
  	"es.set",
  	"esnext.set.delete-all"
  ],
  	"core-js/full/set/difference": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.difference.v2",
  	"es.string.iterator",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/set/every": [
  	"es.set",
  	"esnext.set.every"
  ],
  	"core-js/full/set/filter": [
  	"es.set",
  	"esnext.set.filter"
  ],
  	"core-js/full/set/find": [
  	"es.set",
  	"esnext.set.find"
  ],
  	"core-js/full/set/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.set",
  	"es.string.iterator",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.union.v2",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/set/intersection": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.intersection.v2",
  	"es.string.iterator",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/set/is-disjoint-from": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.is-disjoint-from.v2",
  	"es.string.iterator",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/set/is-subset-of": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.is-subset-of.v2",
  	"es.string.iterator",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/set/is-superset-of": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.is-superset-of.v2",
  	"es.string.iterator",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/set/join": [
  	"es.set",
  	"esnext.set.join"
  ],
  	"core-js/full/set/map": [
  	"es.set",
  	"esnext.set.map"
  ],
  	"core-js/full/set/of": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.set",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.intersection.v2",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.union.v2"
  ],
  	"core-js/full/set/reduce": [
  	"es.set",
  	"esnext.set.reduce"
  ],
  	"core-js/full/set/some": [
  	"es.set",
  	"esnext.set.some"
  ],
  	"core-js/full/set/symmetric-difference": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.symmetric-difference.v2",
  	"es.string.iterator",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/set/union": [
  	"es.array.iterator",
  	"es.set",
  	"es.set.union.v2",
  	"es.string.iterator",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/string": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"es.weak-map",
  	"esnext.string.at",
  	"esnext.string.cooked",
  	"esnext.string.code-points",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/full/string/anchor": [
  	"es.string.anchor"
  ],
  	"core-js/full/string/at": [
  	"es.string.at-alternative",
  	"esnext.string.at"
  ],
  	"core-js/full/string/big": [
  	"es.string.big"
  ],
  	"core-js/full/string/blink": [
  	"es.string.blink"
  ],
  	"core-js/full/string/bold": [
  	"es.string.bold"
  ],
  	"core-js/full/string/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/full/string/code-points": [
  	"es.object.to-string",
  	"esnext.string.code-points"
  ],
  	"core-js/full/string/cooked": [
  	"esnext.string.cooked"
  ],
  	"core-js/full/string/dedent": [
  	"es.string.from-code-point",
  	"es.weak-map",
  	"esnext.string.dedent"
  ],
  	"core-js/full/string/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/full/string/fixed": [
  	"es.string.fixed"
  ],
  	"core-js/full/string/fontcolor": [
  	"es.string.fontcolor"
  ],
  	"core-js/full/string/fontsize": [
  	"es.string.fontsize"
  ],
  	"core-js/full/string/from-code-point": [
  	"es.string.from-code-point"
  ],
  	"core-js/full/string/includes": [
  	"es.string.includes"
  ],
  	"core-js/full/string/is-well-formed": [
  	"es.string.is-well-formed",
  	"esnext.string.is-well-formed"
  ],
  	"core-js/full/string/italics": [
  	"es.string.italics"
  ],
  	"core-js/full/string/iterator": [
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/full/string/link": [
  	"es.string.link"
  ],
  	"core-js/full/string/match": [
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/full/string/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all",
  	"esnext.string.match-all"
  ],
  	"core-js/full/string/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/full/string/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/full/string/raw": [
  	"es.string.raw"
  ],
  	"core-js/full/string/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/full/string/replace": [
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/full/string/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all",
  	"esnext.string.replace-all"
  ],
  	"core-js/full/string/search": [
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/full/string/small": [
  	"es.string.small"
  ],
  	"core-js/full/string/split": [
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/full/string/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/full/string/strike": [
  	"es.string.strike"
  ],
  	"core-js/full/string/sub": [
  	"es.string.sub"
  ],
  	"core-js/full/string/substr": [
  	"es.string.substr"
  ],
  	"core-js/full/string/sup": [
  	"es.string.sup"
  ],
  	"core-js/full/string/to-well-formed": [
  	"es.string.to-well-formed",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/full/string/trim": [
  	"es.string.trim"
  ],
  	"core-js/full/string/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/full/string/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/full/string/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/full/string/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/full/string/virtual": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.includes",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"esnext.string.at",
  	"esnext.string.code-points",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/full/string/virtual/anchor": [
  	"es.string.anchor"
  ],
  	"core-js/full/string/virtual/at": [
  	"es.string.at-alternative",
  	"esnext.string.at"
  ],
  	"core-js/full/string/virtual/big": [
  	"es.string.big"
  ],
  	"core-js/full/string/virtual/blink": [
  	"es.string.blink"
  ],
  	"core-js/full/string/virtual/bold": [
  	"es.string.bold"
  ],
  	"core-js/full/string/virtual/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/full/string/virtual/code-points": [
  	"es.object.to-string",
  	"esnext.string.code-points"
  ],
  	"core-js/full/string/virtual/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/full/string/virtual/fixed": [
  	"es.string.fixed"
  ],
  	"core-js/full/string/virtual/fontcolor": [
  	"es.string.fontcolor"
  ],
  	"core-js/full/string/virtual/fontsize": [
  	"es.string.fontsize"
  ],
  	"core-js/full/string/virtual/includes": [
  	"es.string.includes"
  ],
  	"core-js/full/string/virtual/is-well-formed": [
  	"es.string.is-well-formed",
  	"esnext.string.is-well-formed"
  ],
  	"core-js/full/string/virtual/italics": [
  	"es.string.italics"
  ],
  	"core-js/full/string/virtual/iterator": [
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/full/string/virtual/link": [
  	"es.string.link"
  ],
  	"core-js/full/string/virtual/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all",
  	"esnext.string.match-all"
  ],
  	"core-js/full/string/virtual/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/full/string/virtual/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/full/string/virtual/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/full/string/virtual/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all",
  	"esnext.string.replace-all"
  ],
  	"core-js/full/string/virtual/small": [
  	"es.string.small"
  ],
  	"core-js/full/string/virtual/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/full/string/virtual/strike": [
  	"es.string.strike"
  ],
  	"core-js/full/string/virtual/sub": [
  	"es.string.sub"
  ],
  	"core-js/full/string/virtual/substr": [
  	"es.string.substr"
  ],
  	"core-js/full/string/virtual/sup": [
  	"es.string.sup"
  ],
  	"core-js/full/string/virtual/to-well-formed": [
  	"es.string.to-well-formed",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/full/string/virtual/trim": [
  	"es.string.trim"
  ],
  	"core-js/full/string/virtual/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/full/string/virtual/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/full/string/virtual/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/full/string/virtual/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/full/structured-clone": [
  	"es.error.to-string",
  	"es.array.iterator",
  	"es.map",
  	"es.object.keys",
  	"es.object.to-string",
  	"es.set",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.structured-clone"
  ],
  	"core-js/full/suppressed-error": [
  ],
  	"core-js/full/symbol": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.array.concat",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag",
  	"esnext.function.metadata",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.custom-matcher",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.symbol.replace-all",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/symbol/async-dispose": [
  	"esnext.symbol.async-dispose"
  ],
  	"core-js/full/symbol/async-iterator": [
  	"es.symbol.async-iterator"
  ],
  	"core-js/full/symbol/custom-matcher": [
  	"esnext.symbol.custom-matcher"
  ],
  	"core-js/full/symbol/description": [
  	"es.symbol.description"
  ],
  	"core-js/full/symbol/dispose": [
  	"esnext.symbol.dispose"
  ],
  	"core-js/full/symbol/for": [
  	"es.symbol"
  ],
  	"core-js/full/symbol/has-instance": [
  	"es.symbol.has-instance",
  	"es.function.has-instance"
  ],
  	"core-js/full/symbol/is-concat-spreadable": [
  	"es.symbol.is-concat-spreadable",
  	"es.array.concat"
  ],
  	"core-js/full/symbol/is-registered": [
  	"es.symbol",
  	"esnext.symbol.is-registered"
  ],
  	"core-js/full/symbol/is-registered-symbol": [
  	"es.symbol",
  	"esnext.symbol.is-registered-symbol"
  ],
  	"core-js/full/symbol/is-well-known": [
  	"es.symbol",
  	"esnext.symbol.is-well-known"
  ],
  	"core-js/full/symbol/is-well-known-symbol": [
  	"es.symbol",
  	"esnext.symbol.is-well-known-symbol"
  ],
  	"core-js/full/symbol/iterator": [
  	"es.symbol.iterator",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/symbol/key-for": [
  	"es.symbol"
  ],
  	"core-js/full/symbol/match": [
  	"es.symbol.match",
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/full/symbol/match-all": [
  	"es.symbol.match-all",
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/full/symbol/matcher": [
  	"esnext.symbol.matcher"
  ],
  	"core-js/full/symbol/metadata": [
  	"esnext.function.metadata",
  	"esnext.symbol.metadata"
  ],
  	"core-js/full/symbol/metadata-key": [
  	"esnext.symbol.metadata-key"
  ],
  	"core-js/full/symbol/observable": [
  	"esnext.symbol.observable"
  ],
  	"core-js/full/symbol/pattern-match": [
  	"esnext.symbol.pattern-match"
  ],
  	"core-js/full/symbol/replace": [
  	"es.symbol.replace",
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/full/symbol/replace-all": [
  	"esnext.symbol.replace-all"
  ],
  	"core-js/full/symbol/search": [
  	"es.symbol.search",
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/full/symbol/species": [
  	"es.symbol.species"
  ],
  	"core-js/full/symbol/split": [
  	"es.symbol.split",
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/full/symbol/to-primitive": [
  	"es.symbol.to-primitive",
  	"es.date.to-primitive"
  ],
  	"core-js/full/symbol/to-string-tag": [
  	"es.symbol.to-string-tag",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/full/symbol/unscopables": [
  	"es.symbol.unscopables"
  ],
  	"core-js/full/typed-array": [
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/at": [
  	"es.typed-array.at",
  	"esnext.typed-array.at"
  ],
  	"core-js/full/typed-array/copy-within": [
  	"es.typed-array.copy-within"
  ],
  	"core-js/full/typed-array/entries": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/full/typed-array/every": [
  	"es.typed-array.every"
  ],
  	"core-js/full/typed-array/fill": [
  	"es.typed-array.fill"
  ],
  	"core-js/full/typed-array/filter": [
  	"es.typed-array.filter"
  ],
  	"core-js/full/typed-array/filter-out": [
  	"esnext.typed-array.filter-out"
  ],
  	"core-js/full/typed-array/filter-reject": [
  	"esnext.typed-array.filter-reject"
  ],
  	"core-js/full/typed-array/find": [
  	"es.typed-array.find"
  ],
  	"core-js/full/typed-array/find-index": [
  	"es.typed-array.find-index"
  ],
  	"core-js/full/typed-array/find-last": [
  	"es.typed-array.find-last",
  	"esnext.typed-array.find-last"
  ],
  	"core-js/full/typed-array/find-last-index": [
  	"es.typed-array.find-last-index",
  	"esnext.typed-array.find-last-index"
  ],
  	"core-js/full/typed-array/float32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.float32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/float64-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.float64-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/for-each": [
  	"es.typed-array.for-each"
  ],
  	"core-js/full/typed-array/from": [
  	"es.typed-array.from"
  ],
  	"core-js/full/typed-array/from-async": [
  	"esnext.typed-array.from-async"
  ],
  	"core-js/full/typed-array/from-base64": [
  	"esnext.uint8-array.from-base64"
  ],
  	"core-js/full/typed-array/from-hex": [
  	"esnext.uint8-array.from-hex"
  ],
  	"core-js/full/typed-array/group-by": [
  	"esnext.typed-array.group-by"
  ],
  	"core-js/full/typed-array/includes": [
  	"es.typed-array.includes"
  ],
  	"core-js/full/typed-array/index-of": [
  	"es.typed-array.index-of"
  ],
  	"core-js/full/typed-array/int16-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.int16-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/int32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.int32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/int8-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.int8-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/iterator": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/full/typed-array/join": [
  	"es.typed-array.join"
  ],
  	"core-js/full/typed-array/keys": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/full/typed-array/last-index-of": [
  	"es.typed-array.last-index-of"
  ],
  	"core-js/full/typed-array/map": [
  	"es.typed-array.map"
  ],
  	"core-js/full/typed-array/methods": [
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/of": [
  	"es.typed-array.of"
  ],
  	"core-js/full/typed-array/reduce": [
  	"es.typed-array.reduce"
  ],
  	"core-js/full/typed-array/reduce-right": [
  	"es.typed-array.reduce-right"
  ],
  	"core-js/full/typed-array/reverse": [
  	"es.typed-array.reverse"
  ],
  	"core-js/full/typed-array/set": [
  	"es.typed-array.set"
  ],
  	"core-js/full/typed-array/set-from-base64": [
  	"esnext.uint8-array.set-from-base64"
  ],
  	"core-js/full/typed-array/set-from-hex": [
  	"esnext.uint8-array.set-from-hex"
  ],
  	"core-js/full/typed-array/slice": [
  	"es.typed-array.slice"
  ],
  	"core-js/full/typed-array/some": [
  	"es.typed-array.some"
  ],
  	"core-js/full/typed-array/sort": [
  	"es.typed-array.sort"
  ],
  	"core-js/full/typed-array/subarray": [
  	"es.typed-array.subarray"
  ],
  	"core-js/full/typed-array/to-base64": [
  	"esnext.uint8-array.to-base64"
  ],
  	"core-js/full/typed-array/to-hex": [
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/to-locale-string": [
  	"es.typed-array.to-locale-string"
  ],
  	"core-js/full/typed-array/to-reversed": [
  	"es.typed-array.to-reversed",
  	"esnext.typed-array.to-reversed"
  ],
  	"core-js/full/typed-array/to-sorted": [
  	"es.typed-array.sort",
  	"es.typed-array.to-sorted",
  	"esnext.typed-array.to-sorted"
  ],
  	"core-js/full/typed-array/to-spliced": [
  	"esnext.typed-array.to-spliced"
  ],
  	"core-js/full/typed-array/to-string": [
  	"es.typed-array.to-string"
  ],
  	"core-js/full/typed-array/uint16-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.uint16-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/uint32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/uint8-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.uint8-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/uint8-clamped-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.map",
  	"es.object.to-string",
  	"es.promise",
  	"es.string.iterator",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/full/typed-array/unique-by": [
  	"es.map",
  	"esnext.typed-array.unique-by"
  ],
  	"core-js/full/typed-array/values": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/full/typed-array/with": [
  	"es.typed-array.with",
  	"esnext.typed-array.with"
  ],
  	"core-js/full/unescape": [
  	"es.unescape"
  ],
  	"core-js/full/url": [
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/full/url-search-params": [
  	"web.dom-collections.iterator",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/full/url/can-parse": [
  	"web.url",
  	"web.url.can-parse"
  ],
  	"core-js/full/url/parse": [
  	"web.url",
  	"web.url.parse"
  ],
  	"core-js/full/url/to-json": [
  	"web.url.to-json"
  ],
  	"core-js/full/weak-map": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.weak-map",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/weak-map/delete-all": [
  	"es.weak-map",
  	"esnext.weak-map.delete-all"
  ],
  	"core-js/full/weak-map/emplace": [
  	"es.weak-map",
  	"esnext.weak-map.emplace"
  ],
  	"core-js/full/weak-map/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.weak-map",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.emplace",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/weak-map/of": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.weak-map",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace"
  ],
  	"core-js/full/weak-map/upsert": [
  	"es.weak-map",
  	"esnext.weak-map.upsert"
  ],
  	"core-js/full/weak-set": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.weak-set",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/weak-set/add-all": [
  	"es.weak-set",
  	"esnext.weak-set.add-all"
  ],
  	"core-js/full/weak-set/delete-all": [
  	"es.weak-set",
  	"esnext.weak-set.delete-all"
  ],
  	"core-js/full/weak-set/from": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.weak-set",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"web.dom-collections.iterator"
  ],
  	"core-js/full/weak-set/of": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.weak-set",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.of"
  ],
  	"core-js/modules/es.aggregate-error": [
  	"es.aggregate-error"
  ],
  	"core-js/modules/es.aggregate-error.cause": [
  	"es.aggregate-error.cause"
  ],
  	"core-js/modules/es.aggregate-error.constructor": [
  	"es.aggregate-error.constructor"
  ],
  	"core-js/modules/es.array-buffer.constructor": [
  	"es.array-buffer.constructor"
  ],
  	"core-js/modules/es.array-buffer.detached": [
  	"es.array-buffer.detached"
  ],
  	"core-js/modules/es.array-buffer.is-view": [
  	"es.array-buffer.is-view"
  ],
  	"core-js/modules/es.array-buffer.slice": [
  	"es.array-buffer.slice"
  ],
  	"core-js/modules/es.array-buffer.transfer": [
  	"es.array-buffer.transfer"
  ],
  	"core-js/modules/es.array-buffer.transfer-to-fixed-length": [
  	"es.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/modules/es.array.at": [
  	"es.array.at"
  ],
  	"core-js/modules/es.array.concat": [
  	"es.array.concat"
  ],
  	"core-js/modules/es.array.copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/modules/es.array.every": [
  	"es.array.every"
  ],
  	"core-js/modules/es.array.fill": [
  	"es.array.fill"
  ],
  	"core-js/modules/es.array.filter": [
  	"es.array.filter"
  ],
  	"core-js/modules/es.array.find": [
  	"es.array.find"
  ],
  	"core-js/modules/es.array.find-index": [
  	"es.array.find-index"
  ],
  	"core-js/modules/es.array.find-last": [
  	"es.array.find-last"
  ],
  	"core-js/modules/es.array.find-last-index": [
  	"es.array.find-last-index"
  ],
  	"core-js/modules/es.array.flat": [
  	"es.array.flat"
  ],
  	"core-js/modules/es.array.flat-map": [
  	"es.array.flat-map"
  ],
  	"core-js/modules/es.array.for-each": [
  	"es.array.for-each"
  ],
  	"core-js/modules/es.array.from": [
  	"es.array.from"
  ],
  	"core-js/modules/es.array.includes": [
  	"es.array.includes"
  ],
  	"core-js/modules/es.array.index-of": [
  	"es.array.index-of"
  ],
  	"core-js/modules/es.array.is-array": [
  	"es.array.is-array"
  ],
  	"core-js/modules/es.array.iterator": [
  	"es.array.iterator"
  ],
  	"core-js/modules/es.array.join": [
  	"es.array.join"
  ],
  	"core-js/modules/es.array.last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/modules/es.array.map": [
  	"es.array.map"
  ],
  	"core-js/modules/es.array.of": [
  	"es.array.of"
  ],
  	"core-js/modules/es.array.push": [
  	"es.array.push"
  ],
  	"core-js/modules/es.array.reduce": [
  	"es.array.reduce"
  ],
  	"core-js/modules/es.array.reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/modules/es.array.reverse": [
  	"es.array.reverse"
  ],
  	"core-js/modules/es.array.slice": [
  	"es.array.slice"
  ],
  	"core-js/modules/es.array.some": [
  	"es.array.some"
  ],
  	"core-js/modules/es.array.sort": [
  	"es.array.sort"
  ],
  	"core-js/modules/es.array.species": [
  	"es.array.species"
  ],
  	"core-js/modules/es.array.splice": [
  	"es.array.splice"
  ],
  	"core-js/modules/es.array.to-reversed": [
  	"es.array.to-reversed"
  ],
  	"core-js/modules/es.array.to-sorted": [
  	"es.array.to-sorted"
  ],
  	"core-js/modules/es.array.to-spliced": [
  	"es.array.to-spliced"
  ],
  	"core-js/modules/es.array.unscopables.flat": [
  	"es.array.unscopables.flat"
  ],
  	"core-js/modules/es.array.unscopables.flat-map": [
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/modules/es.array.unshift": [
  	"es.array.unshift"
  ],
  	"core-js/modules/es.array.with": [
  	"es.array.with"
  ],
  	"core-js/modules/es.data-view": [
  	"es.data-view"
  ],
  	"core-js/modules/es.data-view.constructor": [
  	"es.data-view.constructor"
  ],
  	"core-js/modules/es.date.get-year": [
  	"es.date.get-year"
  ],
  	"core-js/modules/es.date.now": [
  	"es.date.now"
  ],
  	"core-js/modules/es.date.set-year": [
  	"es.date.set-year"
  ],
  	"core-js/modules/es.date.to-gmt-string": [
  	"es.date.to-gmt-string"
  ],
  	"core-js/modules/es.date.to-iso-string": [
  	"es.date.to-iso-string"
  ],
  	"core-js/modules/es.date.to-json": [
  	"es.date.to-json"
  ],
  	"core-js/modules/es.date.to-primitive": [
  	"es.date.to-primitive"
  ],
  	"core-js/modules/es.date.to-string": [
  	"es.date.to-string"
  ],
  	"core-js/modules/es.error.cause": [
  	"es.error.cause"
  ],
  	"core-js/modules/es.error.to-string": [
  	"es.error.to-string"
  ],
  	"core-js/modules/es.escape": [
  	"es.escape"
  ],
  	"core-js/modules/es.function.bind": [
  	"es.function.bind"
  ],
  	"core-js/modules/es.function.has-instance": [
  	"es.function.has-instance"
  ],
  	"core-js/modules/es.function.name": [
  	"es.function.name"
  ],
  	"core-js/modules/es.global-this": [
  	"es.global-this"
  ],
  	"core-js/modules/es.json.stringify": [
  	"es.json.stringify"
  ],
  	"core-js/modules/es.json.to-string-tag": [
  	"es.json.to-string-tag"
  ],
  	"core-js/modules/es.map": [
  	"es.map"
  ],
  	"core-js/modules/es.map.constructor": [
  	"es.map.constructor"
  ],
  	"core-js/modules/es.map.group-by": [
  	"es.map.group-by"
  ],
  	"core-js/modules/es.math.acosh": [
  	"es.math.acosh"
  ],
  	"core-js/modules/es.math.asinh": [
  	"es.math.asinh"
  ],
  	"core-js/modules/es.math.atanh": [
  	"es.math.atanh"
  ],
  	"core-js/modules/es.math.cbrt": [
  	"es.math.cbrt"
  ],
  	"core-js/modules/es.math.clz32": [
  	"es.math.clz32"
  ],
  	"core-js/modules/es.math.cosh": [
  	"es.math.cosh"
  ],
  	"core-js/modules/es.math.expm1": [
  	"es.math.expm1"
  ],
  	"core-js/modules/es.math.fround": [
  	"es.math.fround"
  ],
  	"core-js/modules/es.math.hypot": [
  	"es.math.hypot"
  ],
  	"core-js/modules/es.math.imul": [
  	"es.math.imul"
  ],
  	"core-js/modules/es.math.log10": [
  	"es.math.log10"
  ],
  	"core-js/modules/es.math.log1p": [
  	"es.math.log1p"
  ],
  	"core-js/modules/es.math.log2": [
  	"es.math.log2"
  ],
  	"core-js/modules/es.math.sign": [
  	"es.math.sign"
  ],
  	"core-js/modules/es.math.sinh": [
  	"es.math.sinh"
  ],
  	"core-js/modules/es.math.tanh": [
  	"es.math.tanh"
  ],
  	"core-js/modules/es.math.to-string-tag": [
  	"es.math.to-string-tag"
  ],
  	"core-js/modules/es.math.trunc": [
  	"es.math.trunc"
  ],
  	"core-js/modules/es.number.constructor": [
  	"es.number.constructor"
  ],
  	"core-js/modules/es.number.epsilon": [
  	"es.number.epsilon"
  ],
  	"core-js/modules/es.number.is-finite": [
  	"es.number.is-finite"
  ],
  	"core-js/modules/es.number.is-integer": [
  	"es.number.is-integer"
  ],
  	"core-js/modules/es.number.is-nan": [
  	"es.number.is-nan"
  ],
  	"core-js/modules/es.number.is-safe-integer": [
  	"es.number.is-safe-integer"
  ],
  	"core-js/modules/es.number.max-safe-integer": [
  	"es.number.max-safe-integer"
  ],
  	"core-js/modules/es.number.min-safe-integer": [
  	"es.number.min-safe-integer"
  ],
  	"core-js/modules/es.number.parse-float": [
  	"es.number.parse-float"
  ],
  	"core-js/modules/es.number.parse-int": [
  	"es.number.parse-int"
  ],
  	"core-js/modules/es.number.to-exponential": [
  	"es.number.to-exponential"
  ],
  	"core-js/modules/es.number.to-fixed": [
  	"es.number.to-fixed"
  ],
  	"core-js/modules/es.number.to-precision": [
  	"es.number.to-precision"
  ],
  	"core-js/modules/es.object.assign": [
  	"es.object.assign"
  ],
  	"core-js/modules/es.object.create": [
  	"es.object.create"
  ],
  	"core-js/modules/es.object.define-getter": [
  	"es.object.define-getter"
  ],
  	"core-js/modules/es.object.define-properties": [
  	"es.object.define-properties"
  ],
  	"core-js/modules/es.object.define-property": [
  	"es.object.define-property"
  ],
  	"core-js/modules/es.object.define-setter": [
  	"es.object.define-setter"
  ],
  	"core-js/modules/es.object.entries": [
  	"es.object.entries"
  ],
  	"core-js/modules/es.object.freeze": [
  	"es.object.freeze"
  ],
  	"core-js/modules/es.object.from-entries": [
  	"es.object.from-entries"
  ],
  	"core-js/modules/es.object.get-own-property-descriptor": [
  	"es.object.get-own-property-descriptor"
  ],
  	"core-js/modules/es.object.get-own-property-descriptors": [
  	"es.object.get-own-property-descriptors"
  ],
  	"core-js/modules/es.object.get-own-property-names": [
  	"es.object.get-own-property-names"
  ],
  	"core-js/modules/es.object.get-own-property-symbols": [
  	"es.object.get-own-property-symbols"
  ],
  	"core-js/modules/es.object.get-prototype-of": [
  	"es.object.get-prototype-of"
  ],
  	"core-js/modules/es.object.group-by": [
  	"es.object.group-by"
  ],
  	"core-js/modules/es.object.has-own": [
  	"es.object.has-own"
  ],
  	"core-js/modules/es.object.is": [
  	"es.object.is"
  ],
  	"core-js/modules/es.object.is-extensible": [
  	"es.object.is-extensible"
  ],
  	"core-js/modules/es.object.is-frozen": [
  	"es.object.is-frozen"
  ],
  	"core-js/modules/es.object.is-sealed": [
  	"es.object.is-sealed"
  ],
  	"core-js/modules/es.object.keys": [
  	"es.object.keys"
  ],
  	"core-js/modules/es.object.lookup-getter": [
  	"es.object.lookup-getter"
  ],
  	"core-js/modules/es.object.lookup-setter": [
  	"es.object.lookup-setter"
  ],
  	"core-js/modules/es.object.prevent-extensions": [
  	"es.object.prevent-extensions"
  ],
  	"core-js/modules/es.object.proto": [
  	"es.object.proto"
  ],
  	"core-js/modules/es.object.seal": [
  	"es.object.seal"
  ],
  	"core-js/modules/es.object.set-prototype-of": [
  	"es.object.set-prototype-of"
  ],
  	"core-js/modules/es.object.to-string": [
  	"es.object.to-string"
  ],
  	"core-js/modules/es.object.values": [
  	"es.object.values"
  ],
  	"core-js/modules/es.parse-float": [
  	"es.parse-float"
  ],
  	"core-js/modules/es.parse-int": [
  	"es.parse-int"
  ],
  	"core-js/modules/es.promise": [
  	"es.promise"
  ],
  	"core-js/modules/es.promise.all": [
  	"es.promise.all"
  ],
  	"core-js/modules/es.promise.all-settled": [
  	"es.promise.all-settled"
  ],
  	"core-js/modules/es.promise.any": [
  	"es.promise.any"
  ],
  	"core-js/modules/es.promise.catch": [
  	"es.promise.catch"
  ],
  	"core-js/modules/es.promise.constructor": [
  	"es.promise.constructor"
  ],
  	"core-js/modules/es.promise.finally": [
  	"es.promise.finally"
  ],
  	"core-js/modules/es.promise.race": [
  	"es.promise.race"
  ],
  	"core-js/modules/es.promise.reject": [
  	"es.promise.reject"
  ],
  	"core-js/modules/es.promise.resolve": [
  	"es.promise.resolve"
  ],
  	"core-js/modules/es.promise.with-resolvers": [
  	"es.promise.with-resolvers"
  ],
  	"core-js/modules/es.reflect.apply": [
  	"es.reflect.apply"
  ],
  	"core-js/modules/es.reflect.construct": [
  	"es.reflect.construct"
  ],
  	"core-js/modules/es.reflect.define-property": [
  	"es.reflect.define-property"
  ],
  	"core-js/modules/es.reflect.delete-property": [
  	"es.reflect.delete-property"
  ],
  	"core-js/modules/es.reflect.get": [
  	"es.reflect.get"
  ],
  	"core-js/modules/es.reflect.get-own-property-descriptor": [
  	"es.reflect.get-own-property-descriptor"
  ],
  	"core-js/modules/es.reflect.get-prototype-of": [
  	"es.reflect.get-prototype-of"
  ],
  	"core-js/modules/es.reflect.has": [
  	"es.reflect.has"
  ],
  	"core-js/modules/es.reflect.is-extensible": [
  	"es.reflect.is-extensible"
  ],
  	"core-js/modules/es.reflect.own-keys": [
  	"es.reflect.own-keys"
  ],
  	"core-js/modules/es.reflect.prevent-extensions": [
  	"es.reflect.prevent-extensions"
  ],
  	"core-js/modules/es.reflect.set": [
  	"es.reflect.set"
  ],
  	"core-js/modules/es.reflect.set-prototype-of": [
  	"es.reflect.set-prototype-of"
  ],
  	"core-js/modules/es.reflect.to-string-tag": [
  	"es.reflect.to-string-tag"
  ],
  	"core-js/modules/es.regexp.constructor": [
  	"es.regexp.constructor"
  ],
  	"core-js/modules/es.regexp.dot-all": [
  	"es.regexp.dot-all"
  ],
  	"core-js/modules/es.regexp.exec": [
  	"es.regexp.exec"
  ],
  	"core-js/modules/es.regexp.flags": [
  	"es.regexp.flags"
  ],
  	"core-js/modules/es.regexp.sticky": [
  	"es.regexp.sticky"
  ],
  	"core-js/modules/es.regexp.test": [
  	"es.regexp.test"
  ],
  	"core-js/modules/es.regexp.to-string": [
  	"es.regexp.to-string"
  ],
  	"core-js/modules/es.set": [
  	"es.set"
  ],
  	"core-js/modules/es.set.constructor": [
  	"es.set.constructor"
  ],
  	"core-js/modules/es.set.difference.v2": [
  	"es.set.difference.v2"
  ],
  	"core-js/modules/es.set.intersection.v2": [
  	"es.set.intersection.v2"
  ],
  	"core-js/modules/es.set.is-disjoint-from.v2": [
  	"es.set.is-disjoint-from.v2"
  ],
  	"core-js/modules/es.set.is-subset-of.v2": [
  	"es.set.is-subset-of.v2"
  ],
  	"core-js/modules/es.set.is-superset-of.v2": [
  	"es.set.is-superset-of.v2"
  ],
  	"core-js/modules/es.set.symmetric-difference.v2": [
  	"es.set.symmetric-difference.v2"
  ],
  	"core-js/modules/es.set.union.v2": [
  	"es.set.union.v2"
  ],
  	"core-js/modules/es.string.anchor": [
  	"es.string.anchor"
  ],
  	"core-js/modules/es.string.at-alternative": [
  	"es.string.at-alternative"
  ],
  	"core-js/modules/es.string.big": [
  	"es.string.big"
  ],
  	"core-js/modules/es.string.blink": [
  	"es.string.blink"
  ],
  	"core-js/modules/es.string.bold": [
  	"es.string.bold"
  ],
  	"core-js/modules/es.string.code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/modules/es.string.ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/modules/es.string.fixed": [
  	"es.string.fixed"
  ],
  	"core-js/modules/es.string.fontcolor": [
  	"es.string.fontcolor"
  ],
  	"core-js/modules/es.string.fontsize": [
  	"es.string.fontsize"
  ],
  	"core-js/modules/es.string.from-code-point": [
  	"es.string.from-code-point"
  ],
  	"core-js/modules/es.string.includes": [
  	"es.string.includes"
  ],
  	"core-js/modules/es.string.is-well-formed": [
  	"es.string.is-well-formed"
  ],
  	"core-js/modules/es.string.italics": [
  	"es.string.italics"
  ],
  	"core-js/modules/es.string.iterator": [
  	"es.string.iterator"
  ],
  	"core-js/modules/es.string.link": [
  	"es.string.link"
  ],
  	"core-js/modules/es.string.match": [
  	"es.string.match"
  ],
  	"core-js/modules/es.string.match-all": [
  	"es.string.match-all"
  ],
  	"core-js/modules/es.string.pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/modules/es.string.pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/modules/es.string.raw": [
  	"es.string.raw"
  ],
  	"core-js/modules/es.string.repeat": [
  	"es.string.repeat"
  ],
  	"core-js/modules/es.string.replace": [
  	"es.string.replace"
  ],
  	"core-js/modules/es.string.replace-all": [
  	"es.string.replace-all"
  ],
  	"core-js/modules/es.string.search": [
  	"es.string.search"
  ],
  	"core-js/modules/es.string.small": [
  	"es.string.small"
  ],
  	"core-js/modules/es.string.split": [
  	"es.string.split"
  ],
  	"core-js/modules/es.string.starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/modules/es.string.strike": [
  	"es.string.strike"
  ],
  	"core-js/modules/es.string.sub": [
  	"es.string.sub"
  ],
  	"core-js/modules/es.string.substr": [
  	"es.string.substr"
  ],
  	"core-js/modules/es.string.sup": [
  	"es.string.sup"
  ],
  	"core-js/modules/es.string.to-well-formed": [
  	"es.string.to-well-formed"
  ],
  	"core-js/modules/es.string.trim": [
  	"es.string.trim"
  ],
  	"core-js/modules/es.string.trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/modules/es.string.trim-left": [
  	"es.string.trim-left"
  ],
  	"core-js/modules/es.string.trim-right": [
  	"es.string.trim-right"
  ],
  	"core-js/modules/es.string.trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/modules/es.symbol": [
  	"es.symbol"
  ],
  	"core-js/modules/es.symbol.async-iterator": [
  	"es.symbol.async-iterator"
  ],
  	"core-js/modules/es.symbol.constructor": [
  	"es.symbol.constructor"
  ],
  	"core-js/modules/es.symbol.description": [
  	"es.symbol.description"
  ],
  	"core-js/modules/es.symbol.for": [
  	"es.symbol.for"
  ],
  	"core-js/modules/es.symbol.has-instance": [
  	"es.symbol.has-instance"
  ],
  	"core-js/modules/es.symbol.is-concat-spreadable": [
  	"es.symbol.is-concat-spreadable"
  ],
  	"core-js/modules/es.symbol.iterator": [
  	"es.symbol.iterator"
  ],
  	"core-js/modules/es.symbol.key-for": [
  	"es.symbol.key-for"
  ],
  	"core-js/modules/es.symbol.match": [
  	"es.symbol.match"
  ],
  	"core-js/modules/es.symbol.match-all": [
  	"es.symbol.match-all"
  ],
  	"core-js/modules/es.symbol.replace": [
  	"es.symbol.replace"
  ],
  	"core-js/modules/es.symbol.search": [
  	"es.symbol.search"
  ],
  	"core-js/modules/es.symbol.species": [
  	"es.symbol.species"
  ],
  	"core-js/modules/es.symbol.split": [
  	"es.symbol.split"
  ],
  	"core-js/modules/es.symbol.to-primitive": [
  	"es.symbol.to-primitive"
  ],
  	"core-js/modules/es.symbol.to-string-tag": [
  	"es.symbol.to-string-tag"
  ],
  	"core-js/modules/es.symbol.unscopables": [
  	"es.symbol.unscopables"
  ],
  	"core-js/modules/es.typed-array.at": [
  	"es.typed-array.at"
  ],
  	"core-js/modules/es.typed-array.copy-within": [
  	"es.typed-array.copy-within"
  ],
  	"core-js/modules/es.typed-array.every": [
  	"es.typed-array.every"
  ],
  	"core-js/modules/es.typed-array.fill": [
  	"es.typed-array.fill"
  ],
  	"core-js/modules/es.typed-array.filter": [
  	"es.typed-array.filter"
  ],
  	"core-js/modules/es.typed-array.find": [
  	"es.typed-array.find"
  ],
  	"core-js/modules/es.typed-array.find-index": [
  	"es.typed-array.find-index"
  ],
  	"core-js/modules/es.typed-array.find-last": [
  	"es.typed-array.find-last"
  ],
  	"core-js/modules/es.typed-array.find-last-index": [
  	"es.typed-array.find-last-index"
  ],
  	"core-js/modules/es.typed-array.float32-array": [
  	"es.typed-array.float32-array"
  ],
  	"core-js/modules/es.typed-array.float64-array": [
  	"es.typed-array.float64-array"
  ],
  	"core-js/modules/es.typed-array.for-each": [
  	"es.typed-array.for-each"
  ],
  	"core-js/modules/es.typed-array.from": [
  	"es.typed-array.from"
  ],
  	"core-js/modules/es.typed-array.includes": [
  	"es.typed-array.includes"
  ],
  	"core-js/modules/es.typed-array.index-of": [
  	"es.typed-array.index-of"
  ],
  	"core-js/modules/es.typed-array.int16-array": [
  	"es.typed-array.int16-array"
  ],
  	"core-js/modules/es.typed-array.int32-array": [
  	"es.typed-array.int32-array"
  ],
  	"core-js/modules/es.typed-array.int8-array": [
  	"es.typed-array.int8-array"
  ],
  	"core-js/modules/es.typed-array.iterator": [
  	"es.typed-array.iterator"
  ],
  	"core-js/modules/es.typed-array.join": [
  	"es.typed-array.join"
  ],
  	"core-js/modules/es.typed-array.last-index-of": [
  	"es.typed-array.last-index-of"
  ],
  	"core-js/modules/es.typed-array.map": [
  	"es.typed-array.map"
  ],
  	"core-js/modules/es.typed-array.of": [
  	"es.typed-array.of"
  ],
  	"core-js/modules/es.typed-array.reduce": [
  	"es.typed-array.reduce"
  ],
  	"core-js/modules/es.typed-array.reduce-right": [
  	"es.typed-array.reduce-right"
  ],
  	"core-js/modules/es.typed-array.reverse": [
  	"es.typed-array.reverse"
  ],
  	"core-js/modules/es.typed-array.set": [
  	"es.typed-array.set"
  ],
  	"core-js/modules/es.typed-array.slice": [
  	"es.typed-array.slice"
  ],
  	"core-js/modules/es.typed-array.some": [
  	"es.typed-array.some"
  ],
  	"core-js/modules/es.typed-array.sort": [
  	"es.typed-array.sort"
  ],
  	"core-js/modules/es.typed-array.subarray": [
  	"es.typed-array.subarray"
  ],
  	"core-js/modules/es.typed-array.to-locale-string": [
  	"es.typed-array.to-locale-string"
  ],
  	"core-js/modules/es.typed-array.to-reversed": [
  	"es.typed-array.to-reversed"
  ],
  	"core-js/modules/es.typed-array.to-sorted": [
  	"es.typed-array.to-sorted"
  ],
  	"core-js/modules/es.typed-array.to-string": [
  	"es.typed-array.to-string"
  ],
  	"core-js/modules/es.typed-array.uint16-array": [
  	"es.typed-array.uint16-array"
  ],
  	"core-js/modules/es.typed-array.uint32-array": [
  	"es.typed-array.uint32-array"
  ],
  	"core-js/modules/es.typed-array.uint8-array": [
  	"es.typed-array.uint8-array"
  ],
  	"core-js/modules/es.typed-array.uint8-clamped-array": [
  	"es.typed-array.uint8-clamped-array"
  ],
  	"core-js/modules/es.typed-array.with": [
  	"es.typed-array.with"
  ],
  	"core-js/modules/es.unescape": [
  	"es.unescape"
  ],
  	"core-js/modules/es.weak-map": [
  	"es.weak-map"
  ],
  	"core-js/modules/es.weak-map.constructor": [
  	"es.weak-map.constructor"
  ],
  	"core-js/modules/es.weak-set": [
  	"es.weak-set"
  ],
  	"core-js/modules/es.weak-set.constructor": [
  	"es.weak-set.constructor"
  ],
  	"core-js/modules/esnext.aggregate-error": [
  	"esnext.aggregate-error"
  ],
  	"core-js/modules/esnext.array-buffer.detached": [
  	"esnext.array-buffer.detached"
  ],
  	"core-js/modules/esnext.array-buffer.transfer": [
  	"esnext.array-buffer.transfer"
  ],
  	"core-js/modules/esnext.array-buffer.transfer-to-fixed-length": [
  	"esnext.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/modules/esnext.array.at": [
  	"esnext.array.at"
  ],
  	"core-js/modules/esnext.array.filter-out": [
  	"esnext.array.filter-out"
  ],
  	"core-js/modules/esnext.array.filter-reject": [
  	"esnext.array.filter-reject"
  ],
  	"core-js/modules/esnext.array.find-last": [
  	"esnext.array.find-last"
  ],
  	"core-js/modules/esnext.array.find-last-index": [
  	"esnext.array.find-last-index"
  ],
  	"core-js/modules/esnext.array.from-async": [
  	"esnext.array.from-async"
  ],
  	"core-js/modules/esnext.array.group": [
  	"esnext.array.group"
  ],
  	"core-js/modules/esnext.array.group-by": [
  	"esnext.array.group-by"
  ],
  	"core-js/modules/esnext.array.group-by-to-map": [
  	"esnext.array.group-by-to-map"
  ],
  	"core-js/modules/esnext.array.group-to-map": [
  	"esnext.array.group-to-map"
  ],
  	"core-js/modules/esnext.array.is-template-object": [
  	"esnext.array.is-template-object"
  ],
  	"core-js/modules/esnext.array.last-index": [
  	"esnext.array.last-index"
  ],
  	"core-js/modules/esnext.array.last-item": [
  	"esnext.array.last-item"
  ],
  	"core-js/modules/esnext.array.to-reversed": [
  	"esnext.array.to-reversed"
  ],
  	"core-js/modules/esnext.array.to-sorted": [
  	"esnext.array.to-sorted"
  ],
  	"core-js/modules/esnext.array.to-spliced": [
  	"esnext.array.to-spliced"
  ],
  	"core-js/modules/esnext.array.unique-by": [
  	"esnext.array.unique-by"
  ],
  	"core-js/modules/esnext.array.with": [
  	"esnext.array.with"
  ],
  	"core-js/modules/esnext.async-disposable-stack.constructor": [
  	"esnext.async-disposable-stack.constructor"
  ],
  	"core-js/modules/esnext.async-iterator.as-indexed-pairs": [
  	"esnext.async-iterator.as-indexed-pairs"
  ],
  	"core-js/modules/esnext.async-iterator.async-dispose": [
  	"esnext.async-iterator.async-dispose"
  ],
  	"core-js/modules/esnext.async-iterator.constructor": [
  	"esnext.async-iterator.constructor"
  ],
  	"core-js/modules/esnext.async-iterator.drop": [
  	"esnext.async-iterator.drop"
  ],
  	"core-js/modules/esnext.async-iterator.every": [
  	"esnext.async-iterator.every"
  ],
  	"core-js/modules/esnext.async-iterator.filter": [
  	"esnext.async-iterator.filter"
  ],
  	"core-js/modules/esnext.async-iterator.find": [
  	"esnext.async-iterator.find"
  ],
  	"core-js/modules/esnext.async-iterator.flat-map": [
  	"esnext.async-iterator.flat-map"
  ],
  	"core-js/modules/esnext.async-iterator.for-each": [
  	"esnext.async-iterator.for-each"
  ],
  	"core-js/modules/esnext.async-iterator.from": [
  	"esnext.async-iterator.from"
  ],
  	"core-js/modules/esnext.async-iterator.indexed": [
  	"esnext.async-iterator.indexed"
  ],
  	"core-js/modules/esnext.async-iterator.map": [
  	"esnext.async-iterator.map"
  ],
  	"core-js/modules/esnext.async-iterator.reduce": [
  	"esnext.async-iterator.reduce"
  ],
  	"core-js/modules/esnext.async-iterator.some": [
  	"esnext.async-iterator.some"
  ],
  	"core-js/modules/esnext.async-iterator.take": [
  	"esnext.async-iterator.take"
  ],
  	"core-js/modules/esnext.async-iterator.to-array": [
  	"esnext.async-iterator.to-array"
  ],
  	"core-js/modules/esnext.bigint.range": [
  	"esnext.bigint.range"
  ],
  	"core-js/modules/esnext.composite-key": [
  	"esnext.composite-key"
  ],
  	"core-js/modules/esnext.composite-symbol": [
  	"esnext.composite-symbol"
  ],
  	"core-js/modules/esnext.data-view.get-float16": [
  	"esnext.data-view.get-float16"
  ],
  	"core-js/modules/esnext.data-view.get-uint8-clamped": [
  	"esnext.data-view.get-uint8-clamped"
  ],
  	"core-js/modules/esnext.data-view.set-float16": [
  	"esnext.data-view.set-float16"
  ],
  	"core-js/modules/esnext.data-view.set-uint8-clamped": [
  	"esnext.data-view.set-uint8-clamped"
  ],
  	"core-js/modules/esnext.disposable-stack.constructor": [
  	"esnext.disposable-stack.constructor"
  ],
  	"core-js/modules/esnext.function.demethodize": [
  	"esnext.function.demethodize"
  ],
  	"core-js/modules/esnext.function.is-callable": [
  	"esnext.function.is-callable"
  ],
  	"core-js/modules/esnext.function.is-constructor": [
  	"esnext.function.is-constructor"
  ],
  	"core-js/modules/esnext.function.metadata": [
  	"esnext.function.metadata"
  ],
  	"core-js/modules/esnext.function.un-this": [
  	"esnext.function.un-this"
  ],
  	"core-js/modules/esnext.global-this": [
  	"esnext.global-this"
  ],
  	"core-js/modules/esnext.iterator.as-indexed-pairs": [
  	"esnext.iterator.as-indexed-pairs"
  ],
  	"core-js/modules/esnext.iterator.constructor": [
  	"esnext.iterator.constructor"
  ],
  	"core-js/modules/esnext.iterator.dispose": [
  	"esnext.iterator.dispose"
  ],
  	"core-js/modules/esnext.iterator.drop": [
  	"esnext.iterator.drop"
  ],
  	"core-js/modules/esnext.iterator.every": [
  	"esnext.iterator.every"
  ],
  	"core-js/modules/esnext.iterator.filter": [
  	"esnext.iterator.filter"
  ],
  	"core-js/modules/esnext.iterator.find": [
  	"esnext.iterator.find"
  ],
  	"core-js/modules/esnext.iterator.flat-map": [
  	"esnext.iterator.flat-map"
  ],
  	"core-js/modules/esnext.iterator.for-each": [
  	"esnext.iterator.for-each"
  ],
  	"core-js/modules/esnext.iterator.from": [
  	"esnext.iterator.from"
  ],
  	"core-js/modules/esnext.iterator.indexed": [
  	"esnext.iterator.indexed"
  ],
  	"core-js/modules/esnext.iterator.map": [
  	"esnext.iterator.map"
  ],
  	"core-js/modules/esnext.iterator.range": [
  	"esnext.iterator.range"
  ],
  	"core-js/modules/esnext.iterator.reduce": [
  	"esnext.iterator.reduce"
  ],
  	"core-js/modules/esnext.iterator.some": [
  	"esnext.iterator.some"
  ],
  	"core-js/modules/esnext.iterator.take": [
  	"esnext.iterator.take"
  ],
  	"core-js/modules/esnext.iterator.to-array": [
  	"esnext.iterator.to-array"
  ],
  	"core-js/modules/esnext.iterator.to-async": [
  	"esnext.iterator.to-async"
  ],
  	"core-js/modules/esnext.json.is-raw-json": [
  	"esnext.json.is-raw-json"
  ],
  	"core-js/modules/esnext.json.parse": [
  	"esnext.json.parse"
  ],
  	"core-js/modules/esnext.json.raw-json": [
  	"esnext.json.raw-json"
  ],
  	"core-js/modules/esnext.map.delete-all": [
  	"esnext.map.delete-all"
  ],
  	"core-js/modules/esnext.map.emplace": [
  	"esnext.map.emplace"
  ],
  	"core-js/modules/esnext.map.every": [
  	"esnext.map.every"
  ],
  	"core-js/modules/esnext.map.filter": [
  	"esnext.map.filter"
  ],
  	"core-js/modules/esnext.map.find": [
  	"esnext.map.find"
  ],
  	"core-js/modules/esnext.map.find-key": [
  	"esnext.map.find-key"
  ],
  	"core-js/modules/esnext.map.from": [
  	"esnext.map.from"
  ],
  	"core-js/modules/esnext.map.group-by": [
  	"esnext.map.group-by"
  ],
  	"core-js/modules/esnext.map.includes": [
  	"esnext.map.includes"
  ],
  	"core-js/modules/esnext.map.key-by": [
  	"esnext.map.key-by"
  ],
  	"core-js/modules/esnext.map.key-of": [
  	"esnext.map.key-of"
  ],
  	"core-js/modules/esnext.map.map-keys": [
  	"esnext.map.map-keys"
  ],
  	"core-js/modules/esnext.map.map-values": [
  	"esnext.map.map-values"
  ],
  	"core-js/modules/esnext.map.merge": [
  	"esnext.map.merge"
  ],
  	"core-js/modules/esnext.map.of": [
  	"esnext.map.of"
  ],
  	"core-js/modules/esnext.map.reduce": [
  	"esnext.map.reduce"
  ],
  	"core-js/modules/esnext.map.some": [
  	"esnext.map.some"
  ],
  	"core-js/modules/esnext.map.update": [
  	"esnext.map.update"
  ],
  	"core-js/modules/esnext.map.update-or-insert": [
  	"esnext.map.update-or-insert"
  ],
  	"core-js/modules/esnext.map.upsert": [
  	"esnext.map.upsert"
  ],
  	"core-js/modules/esnext.math.clamp": [
  	"esnext.math.clamp"
  ],
  	"core-js/modules/esnext.math.deg-per-rad": [
  	"esnext.math.deg-per-rad"
  ],
  	"core-js/modules/esnext.math.degrees": [
  	"esnext.math.degrees"
  ],
  	"core-js/modules/esnext.math.f16round": [
  	"esnext.math.f16round"
  ],
  	"core-js/modules/esnext.math.fscale": [
  	"esnext.math.fscale"
  ],
  	"core-js/modules/esnext.math.iaddh": [
  	"esnext.math.iaddh"
  ],
  	"core-js/modules/esnext.math.imulh": [
  	"esnext.math.imulh"
  ],
  	"core-js/modules/esnext.math.isubh": [
  	"esnext.math.isubh"
  ],
  	"core-js/modules/esnext.math.rad-per-deg": [
  	"esnext.math.rad-per-deg"
  ],
  	"core-js/modules/esnext.math.radians": [
  	"esnext.math.radians"
  ],
  	"core-js/modules/esnext.math.scale": [
  	"esnext.math.scale"
  ],
  	"core-js/modules/esnext.math.seeded-prng": [
  	"esnext.math.seeded-prng"
  ],
  	"core-js/modules/esnext.math.signbit": [
  	"esnext.math.signbit"
  ],
  	"core-js/modules/esnext.math.sum-precise": [
  	"esnext.math.sum-precise"
  ],
  	"core-js/modules/esnext.math.umulh": [
  	"esnext.math.umulh"
  ],
  	"core-js/modules/esnext.number.from-string": [
  	"esnext.number.from-string"
  ],
  	"core-js/modules/esnext.number.range": [
  	"esnext.number.range"
  ],
  	"core-js/modules/esnext.object.group-by": [
  	"esnext.object.group-by"
  ],
  	"core-js/modules/esnext.object.has-own": [
  	"esnext.object.has-own"
  ],
  	"core-js/modules/esnext.object.iterate-entries": [
  	"esnext.object.iterate-entries"
  ],
  	"core-js/modules/esnext.object.iterate-keys": [
  	"esnext.object.iterate-keys"
  ],
  	"core-js/modules/esnext.object.iterate-values": [
  	"esnext.object.iterate-values"
  ],
  	"core-js/modules/esnext.observable": [
  	"esnext.observable"
  ],
  	"core-js/modules/esnext.observable.constructor": [
  	"esnext.observable.constructor"
  ],
  	"core-js/modules/esnext.observable.from": [
  	"esnext.observable.from"
  ],
  	"core-js/modules/esnext.observable.of": [
  	"esnext.observable.of"
  ],
  	"core-js/modules/esnext.promise.all-settled": [
  	"esnext.promise.all-settled"
  ],
  	"core-js/modules/esnext.promise.any": [
  	"esnext.promise.any"
  ],
  	"core-js/modules/esnext.promise.try": [
  	"esnext.promise.try"
  ],
  	"core-js/modules/esnext.promise.with-resolvers": [
  	"esnext.promise.with-resolvers"
  ],
  	"core-js/modules/esnext.reflect.define-metadata": [
  	"esnext.reflect.define-metadata"
  ],
  	"core-js/modules/esnext.reflect.delete-metadata": [
  	"esnext.reflect.delete-metadata"
  ],
  	"core-js/modules/esnext.reflect.get-metadata": [
  	"esnext.reflect.get-metadata"
  ],
  	"core-js/modules/esnext.reflect.get-metadata-keys": [
  	"esnext.reflect.get-metadata-keys"
  ],
  	"core-js/modules/esnext.reflect.get-own-metadata": [
  	"esnext.reflect.get-own-metadata"
  ],
  	"core-js/modules/esnext.reflect.get-own-metadata-keys": [
  	"esnext.reflect.get-own-metadata-keys"
  ],
  	"core-js/modules/esnext.reflect.has-metadata": [
  	"esnext.reflect.has-metadata"
  ],
  	"core-js/modules/esnext.reflect.has-own-metadata": [
  	"esnext.reflect.has-own-metadata"
  ],
  	"core-js/modules/esnext.reflect.metadata": [
  	"esnext.reflect.metadata"
  ],
  	"core-js/modules/esnext.regexp.escape": [
  	"esnext.regexp.escape"
  ],
  	"core-js/modules/esnext.set.add-all": [
  	"esnext.set.add-all"
  ],
  	"core-js/modules/esnext.set.delete-all": [
  	"esnext.set.delete-all"
  ],
  	"core-js/modules/esnext.set.difference": [
  	"esnext.set.difference"
  ],
  	"core-js/modules/esnext.set.difference.v2": [
  	"esnext.set.difference.v2"
  ],
  	"core-js/modules/esnext.set.every": [
  	"esnext.set.every"
  ],
  	"core-js/modules/esnext.set.filter": [
  	"esnext.set.filter"
  ],
  	"core-js/modules/esnext.set.find": [
  	"esnext.set.find"
  ],
  	"core-js/modules/esnext.set.from": [
  	"esnext.set.from"
  ],
  	"core-js/modules/esnext.set.intersection": [
  	"esnext.set.intersection"
  ],
  	"core-js/modules/esnext.set.intersection.v2": [
  	"esnext.set.intersection.v2"
  ],
  	"core-js/modules/esnext.set.is-disjoint-from": [
  	"esnext.set.is-disjoint-from"
  ],
  	"core-js/modules/esnext.set.is-disjoint-from.v2": [
  	"esnext.set.is-disjoint-from.v2"
  ],
  	"core-js/modules/esnext.set.is-subset-of": [
  	"esnext.set.is-subset-of"
  ],
  	"core-js/modules/esnext.set.is-subset-of.v2": [
  	"esnext.set.is-subset-of.v2"
  ],
  	"core-js/modules/esnext.set.is-superset-of": [
  	"esnext.set.is-superset-of"
  ],
  	"core-js/modules/esnext.set.is-superset-of.v2": [
  	"esnext.set.is-superset-of.v2"
  ],
  	"core-js/modules/esnext.set.join": [
  	"esnext.set.join"
  ],
  	"core-js/modules/esnext.set.map": [
  	"esnext.set.map"
  ],
  	"core-js/modules/esnext.set.of": [
  	"esnext.set.of"
  ],
  	"core-js/modules/esnext.set.reduce": [
  	"esnext.set.reduce"
  ],
  	"core-js/modules/esnext.set.some": [
  	"esnext.set.some"
  ],
  	"core-js/modules/esnext.set.symmetric-difference": [
  	"esnext.set.symmetric-difference"
  ],
  	"core-js/modules/esnext.set.symmetric-difference.v2": [
  	"esnext.set.symmetric-difference.v2"
  ],
  	"core-js/modules/esnext.set.union": [
  	"esnext.set.union"
  ],
  	"core-js/modules/esnext.set.union.v2": [
  	"esnext.set.union.v2"
  ],
  	"core-js/modules/esnext.string.at": [
  	"esnext.string.at"
  ],
  	"core-js/modules/esnext.string.at-alternative": [
  	"esnext.string.at-alternative"
  ],
  	"core-js/modules/esnext.string.code-points": [
  	"esnext.string.code-points"
  ],
  	"core-js/modules/esnext.string.cooked": [
  	"esnext.string.cooked"
  ],
  	"core-js/modules/esnext.string.dedent": [
  	"esnext.string.dedent"
  ],
  	"core-js/modules/esnext.string.is-well-formed": [
  	"esnext.string.is-well-formed"
  ],
  	"core-js/modules/esnext.string.match-all": [
  	"esnext.string.match-all"
  ],
  	"core-js/modules/esnext.string.replace-all": [
  	"esnext.string.replace-all"
  ],
  	"core-js/modules/esnext.string.to-well-formed": [
  	"esnext.string.to-well-formed"
  ],
  	"core-js/modules/esnext.suppressed-error.constructor": [
  	"esnext.suppressed-error.constructor"
  ],
  	"core-js/modules/esnext.symbol.async-dispose": [
  	"esnext.symbol.async-dispose"
  ],
  	"core-js/modules/esnext.symbol.custom-matcher": [
  	"esnext.symbol.custom-matcher"
  ],
  	"core-js/modules/esnext.symbol.dispose": [
  	"esnext.symbol.dispose"
  ],
  	"core-js/modules/esnext.symbol.is-registered": [
  	"esnext.symbol.is-registered"
  ],
  	"core-js/modules/esnext.symbol.is-registered-symbol": [
  	"esnext.symbol.is-registered-symbol"
  ],
  	"core-js/modules/esnext.symbol.is-well-known": [
  	"esnext.symbol.is-well-known"
  ],
  	"core-js/modules/esnext.symbol.is-well-known-symbol": [
  	"esnext.symbol.is-well-known-symbol"
  ],
  	"core-js/modules/esnext.symbol.matcher": [
  	"esnext.symbol.matcher"
  ],
  	"core-js/modules/esnext.symbol.metadata": [
  	"esnext.symbol.metadata"
  ],
  	"core-js/modules/esnext.symbol.metadata-key": [
  	"esnext.symbol.metadata-key"
  ],
  	"core-js/modules/esnext.symbol.observable": [
  	"esnext.symbol.observable"
  ],
  	"core-js/modules/esnext.symbol.pattern-match": [
  	"esnext.symbol.pattern-match"
  ],
  	"core-js/modules/esnext.symbol.replace-all": [
  	"esnext.symbol.replace-all"
  ],
  	"core-js/modules/esnext.typed-array.at": [
  	"esnext.typed-array.at"
  ],
  	"core-js/modules/esnext.typed-array.filter-out": [
  	"esnext.typed-array.filter-out"
  ],
  	"core-js/modules/esnext.typed-array.filter-reject": [
  	"esnext.typed-array.filter-reject"
  ],
  	"core-js/modules/esnext.typed-array.find-last": [
  	"esnext.typed-array.find-last"
  ],
  	"core-js/modules/esnext.typed-array.find-last-index": [
  	"esnext.typed-array.find-last-index"
  ],
  	"core-js/modules/esnext.typed-array.from-async": [
  	"esnext.typed-array.from-async"
  ],
  	"core-js/modules/esnext.typed-array.group-by": [
  	"esnext.typed-array.group-by"
  ],
  	"core-js/modules/esnext.typed-array.to-reversed": [
  	"esnext.typed-array.to-reversed"
  ],
  	"core-js/modules/esnext.typed-array.to-sorted": [
  	"esnext.typed-array.to-sorted"
  ],
  	"core-js/modules/esnext.typed-array.to-spliced": [
  	"esnext.typed-array.to-spliced"
  ],
  	"core-js/modules/esnext.typed-array.unique-by": [
  	"esnext.typed-array.unique-by"
  ],
  	"core-js/modules/esnext.typed-array.with": [
  	"esnext.typed-array.with"
  ],
  	"core-js/modules/esnext.uint8-array.from-base64": [
  	"esnext.uint8-array.from-base64"
  ],
  	"core-js/modules/esnext.uint8-array.from-hex": [
  	"esnext.uint8-array.from-hex"
  ],
  	"core-js/modules/esnext.uint8-array.set-from-base64": [
  	"esnext.uint8-array.set-from-base64"
  ],
  	"core-js/modules/esnext.uint8-array.set-from-hex": [
  	"esnext.uint8-array.set-from-hex"
  ],
  	"core-js/modules/esnext.uint8-array.to-base64": [
  	"esnext.uint8-array.to-base64"
  ],
  	"core-js/modules/esnext.uint8-array.to-hex": [
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/modules/esnext.weak-map.delete-all": [
  	"esnext.weak-map.delete-all"
  ],
  	"core-js/modules/esnext.weak-map.emplace": [
  	"esnext.weak-map.emplace"
  ],
  	"core-js/modules/esnext.weak-map.from": [
  	"esnext.weak-map.from"
  ],
  	"core-js/modules/esnext.weak-map.of": [
  	"esnext.weak-map.of"
  ],
  	"core-js/modules/esnext.weak-map.upsert": [
  	"esnext.weak-map.upsert"
  ],
  	"core-js/modules/esnext.weak-set.add-all": [
  	"esnext.weak-set.add-all"
  ],
  	"core-js/modules/esnext.weak-set.delete-all": [
  	"esnext.weak-set.delete-all"
  ],
  	"core-js/modules/esnext.weak-set.from": [
  	"esnext.weak-set.from"
  ],
  	"core-js/modules/esnext.weak-set.of": [
  	"esnext.weak-set.of"
  ],
  	"core-js/modules/web.atob": [
  	"web.atob"
  ],
  	"core-js/modules/web.btoa": [
  	"web.btoa"
  ],
  	"core-js/modules/web.clear-immediate": [
  	"web.clear-immediate"
  ],
  	"core-js/modules/web.dom-collections.for-each": [
  	"web.dom-collections.for-each"
  ],
  	"core-js/modules/web.dom-collections.iterator": [
  	"web.dom-collections.iterator"
  ],
  	"core-js/modules/web.dom-exception.constructor": [
  	"web.dom-exception.constructor"
  ],
  	"core-js/modules/web.dom-exception.stack": [
  	"web.dom-exception.stack"
  ],
  	"core-js/modules/web.dom-exception.to-string-tag": [
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/modules/web.immediate": [
  	"web.immediate"
  ],
  	"core-js/modules/web.queue-microtask": [
  	"web.queue-microtask"
  ],
  	"core-js/modules/web.self": [
  	"web.self"
  ],
  	"core-js/modules/web.set-immediate": [
  	"web.set-immediate"
  ],
  	"core-js/modules/web.set-interval": [
  	"web.set-interval"
  ],
  	"core-js/modules/web.set-timeout": [
  	"web.set-timeout"
  ],
  	"core-js/modules/web.structured-clone": [
  	"web.structured-clone"
  ],
  	"core-js/modules/web.timers": [
  	"web.timers"
  ],
  	"core-js/modules/web.url": [
  	"web.url"
  ],
  	"core-js/modules/web.url-search-params": [
  	"web.url-search-params"
  ],
  	"core-js/modules/web.url-search-params.constructor": [
  	"web.url-search-params.constructor"
  ],
  	"core-js/modules/web.url-search-params.delete": [
  	"web.url-search-params.delete"
  ],
  	"core-js/modules/web.url-search-params.has": [
  	"web.url-search-params.has"
  ],
  	"core-js/modules/web.url-search-params.size": [
  	"web.url-search-params.size"
  ],
  	"core-js/modules/web.url.can-parse": [
  	"web.url.can-parse"
  ],
  	"core-js/modules/web.url.constructor": [
  	"web.url.constructor"
  ],
  	"core-js/modules/web.url.parse": [
  	"web.url.parse"
  ],
  	"core-js/modules/web.url.to-json": [
  	"web.url.to-json"
  ],
  	"core-js/proposals": [
  	"es.map",
  	"es.string.at-alternative",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.bigint.range",
  	"esnext.composite-key",
  	"esnext.composite-symbol",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.demethodize",
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor",
  	"esnext.function.metadata",
  	"esnext.function.un-this",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.f16round",
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.sum-precise",
  	"esnext.math.umulh",
  	"esnext.number.from-string",
  	"esnext.number.range",
  	"esnext.object.has-own",
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values",
  	"esnext.object.group-by",
  	"esnext.observable",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.reflect.define-metadata",
  	"esnext.reflect.delete-metadata",
  	"esnext.reflect.get-metadata",
  	"esnext.reflect.get-metadata-keys",
  	"esnext.reflect.get-own-metadata",
  	"esnext.reflect.get-own-metadata-keys",
  	"esnext.reflect.has-metadata",
  	"esnext.reflect.has-own-metadata",
  	"esnext.reflect.metadata",
  	"esnext.regexp.escape",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"esnext.string.at",
  	"esnext.string.cooked",
  	"esnext.string.code-points",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.custom-matcher",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.symbol.replace-all",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of",
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/proposals/accessible-object-hasownproperty": [
  	"esnext.object.has-own"
  ],
  	"core-js/proposals/array-buffer-base64": [
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/proposals/array-buffer-transfer": [
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/proposals/array-filtering": [
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject"
  ],
  	"core-js/proposals/array-filtering-stage-1": [
  	"esnext.array.filter-reject",
  	"esnext.typed-array.filter-reject"
  ],
  	"core-js/proposals/array-find-from-last": [
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index"
  ],
  	"core-js/proposals/array-flat-map": [
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/proposals/array-from-async": [
  	"esnext.array.from-async",
  	"esnext.typed-array.from-async"
  ],
  	"core-js/proposals/array-from-async-stage-2": [
  	"esnext.array.from-async"
  ],
  	"core-js/proposals/array-grouping": [
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.typed-array.group-by"
  ],
  	"core-js/proposals/array-grouping-stage-3": [
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map"
  ],
  	"core-js/proposals/array-grouping-stage-3-2": [
  	"esnext.array.group",
  	"esnext.array.group-to-map"
  ],
  	"core-js/proposals/array-grouping-v2": [
  	"esnext.map.group-by",
  	"esnext.object.group-by"
  ],
  	"core-js/proposals/array-includes": [
  	"es.array.includes",
  	"es.typed-array.includes"
  ],
  	"core-js/proposals/array-is-template-object": [
  	"esnext.array.is-template-object"
  ],
  	"core-js/proposals/array-last": [
  	"esnext.array.last-index",
  	"esnext.array.last-item"
  ],
  	"core-js/proposals/array-unique": [
  	"es.map",
  	"esnext.array.unique-by",
  	"esnext.typed-array.unique-by"
  ],
  	"core-js/proposals/async-explicit-resource-management": [
  	"esnext.suppressed-error.constructor",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.symbol.async-dispose"
  ],
  	"core-js/proposals/async-iteration": [
  	"es.symbol.async-iterator"
  ],
  	"core-js/proposals/async-iterator-helpers": [
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.iterator.to-async"
  ],
  	"core-js/proposals/change-array-by-copy": [
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.with",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with"
  ],
  	"core-js/proposals/change-array-by-copy-stage-4": [
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.with",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.with"
  ],
  	"core-js/proposals/collection-methods": [
  	"esnext.map.delete-all",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all"
  ],
  	"core-js/proposals/collection-of-from": [
  	"esnext.map.from",
  	"esnext.map.of",
  	"esnext.set.from",
  	"esnext.set.of",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of"
  ],
  	"core-js/proposals/data-view-get-set-uint8-clamped": [
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-uint8-clamped"
  ],
  	"core-js/proposals/decorator-metadata": [
  	"esnext.symbol.metadata-key"
  ],
  	"core-js/proposals/decorator-metadata-v2": [
  	"esnext.function.metadata",
  	"esnext.symbol.metadata"
  ],
  	"core-js/proposals/decorators": [
  	"esnext.symbol.metadata"
  ],
  	"core-js/proposals/efficient-64-bit-arithmetic": [
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.umulh"
  ],
  	"core-js/proposals/error-cause": [
  	"es.error.cause",
  	"es.aggregate-error.cause"
  ],
  	"core-js/proposals/explicit-resource-management": [
  	"esnext.suppressed-error.constructor",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.disposable-stack.constructor",
  	"esnext.iterator.dispose",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.dispose"
  ],
  	"core-js/proposals/extractors": [
  	"esnext.symbol.custom-matcher"
  ],
  	"core-js/proposals/float16": [
  	"esnext.data-view.get-float16",
  	"esnext.data-view.set-float16",
  	"esnext.math.f16round"
  ],
  	"core-js/proposals/function-demethodize": [
  	"esnext.function.demethodize"
  ],
  	"core-js/proposals/function-is-callable-is-constructor": [
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor"
  ],
  	"core-js/proposals/function-un-this": [
  	"esnext.function.un-this"
  ],
  	"core-js/proposals/global-this": [
  	"esnext.global-this"
  ],
  	"core-js/proposals/iterator-helpers": [
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async"
  ],
  	"core-js/proposals/iterator-helpers-stage-3": [
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.iterator.constructor",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.map",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async"
  ],
  	"core-js/proposals/iterator-helpers-stage-3-2": [
  	"esnext.iterator.constructor",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.map",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array"
  ],
  	"core-js/proposals/iterator-range": [
  	"esnext.iterator.constructor",
  	"esnext.iterator.range"
  ],
  	"core-js/proposals/json-parse-with-source": [
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json"
  ],
  	"core-js/proposals/keys-composition": [
  	"esnext.composite-key",
  	"esnext.composite-symbol"
  ],
  	"core-js/proposals/map-update-or-insert": [
  	"esnext.map.emplace",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert"
  ],
  	"core-js/proposals/map-upsert": [
  	"esnext.map.emplace",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert"
  ],
  	"core-js/proposals/map-upsert-stage-2": [
  	"esnext.map.emplace",
  	"esnext.weak-map.emplace"
  ],
  	"core-js/proposals/math-extensions": [
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale"
  ],
  	"core-js/proposals/math-signbit": [
  	"esnext.math.signbit"
  ],
  	"core-js/proposals/math-sum": [
  	"esnext.math.sum-precise"
  ],
  	"core-js/proposals/number-from-string": [
  	"esnext.number.from-string"
  ],
  	"core-js/proposals/number-range": [
  	"esnext.bigint.range",
  	"esnext.number.range"
  ],
  	"core-js/proposals/object-from-entries": [
  	"es.object.from-entries"
  ],
  	"core-js/proposals/object-getownpropertydescriptors": [
  	"es.object.get-own-property-descriptors"
  ],
  	"core-js/proposals/object-iteration": [
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values"
  ],
  	"core-js/proposals/object-values-entries": [
  	"es.object.entries",
  	"es.object.values"
  ],
  	"core-js/proposals/observable": [
  	"esnext.observable",
  	"esnext.symbol.observable"
  ],
  	"core-js/proposals/pattern-matching": [
  	"esnext.symbol.matcher",
  	"esnext.symbol.pattern-match"
  ],
  	"core-js/proposals/pattern-matching-v2": [
  	"esnext.symbol.custom-matcher"
  ],
  	"core-js/proposals/promise-all-settled": [
  	"esnext.promise.all-settled"
  ],
  	"core-js/proposals/promise-any": [
  	"esnext.aggregate-error",
  	"esnext.promise.any"
  ],
  	"core-js/proposals/promise-finally": [
  	"es.promise.finally"
  ],
  	"core-js/proposals/promise-try": [
  	"esnext.promise.try"
  ],
  	"core-js/proposals/promise-with-resolvers": [
  	"esnext.promise.with-resolvers"
  ],
  	"core-js/proposals/reflect-metadata": [
  	"esnext.reflect.define-metadata",
  	"esnext.reflect.delete-metadata",
  	"esnext.reflect.get-metadata",
  	"esnext.reflect.get-metadata-keys",
  	"esnext.reflect.get-own-metadata",
  	"esnext.reflect.get-own-metadata-keys",
  	"esnext.reflect.has-metadata",
  	"esnext.reflect.has-own-metadata",
  	"esnext.reflect.metadata"
  ],
  	"core-js/proposals/regexp-dotall-flag": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags"
  ],
  	"core-js/proposals/regexp-escaping": [
  	"esnext.regexp.escape"
  ],
  	"core-js/proposals/regexp-named-groups": [
  	"es.regexp.constructor",
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/proposals/relative-indexing-method": [
  	"es.string.at-alternative",
  	"esnext.array.at",
  	"esnext.typed-array.at"
  ],
  	"core-js/proposals/seeded-random": [
  	"esnext.math.seeded-prng"
  ],
  	"core-js/proposals/set-methods": [
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union"
  ],
  	"core-js/proposals/set-methods-v2": [
  	"esnext.set.difference.v2",
  	"esnext.set.intersection.v2",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.union.v2"
  ],
  	"core-js/proposals/string-at": [
  	"esnext.string.at"
  ],
  	"core-js/proposals/string-code-points": [
  	"esnext.string.code-points"
  ],
  	"core-js/proposals/string-cooked": [
  	"esnext.string.cooked"
  ],
  	"core-js/proposals/string-dedent": [
  	"esnext.string.dedent"
  ],
  	"core-js/proposals/string-left-right-trim": [
  	"es.string.trim-end",
  	"es.string.trim-start"
  ],
  	"core-js/proposals/string-match-all": [
  	"esnext.string.match-all"
  ],
  	"core-js/proposals/string-padding": [
  	"es.string.pad-end",
  	"es.string.pad-start"
  ],
  	"core-js/proposals/string-replace-all": [
  	"esnext.string.replace-all",
  	"esnext.symbol.replace-all"
  ],
  	"core-js/proposals/string-replace-all-stage-4": [
  	"esnext.string.replace-all"
  ],
  	"core-js/proposals/symbol-description": [
  	"es.symbol.description"
  ],
  	"core-js/proposals/symbol-predicates": [
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known"
  ],
  	"core-js/proposals/symbol-predicates-v2": [
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-well-known-symbol"
  ],
  	"core-js/proposals/url": [
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/proposals/using-statement": [
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.dispose"
  ],
  	"core-js/proposals/well-formed-stringify": [
  	"es.json.stringify"
  ],
  	"core-js/proposals/well-formed-unicode-strings": [
  	"esnext.string.is-well-formed",
  	"esnext.string.to-well-formed"
  ],
  	"core-js/stable": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.error.cause",
  	"es.error.to-string",
  	"es.aggregate-error",
  	"es.aggregate-error.cause",
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string",
  	"es.escape",
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name",
  	"es.global-this",
  	"es.json.stringify",
  	"es.json.to-string-tag",
  	"es.map",
  	"es.map.group-by",
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc",
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.parse-float",
  	"es.parse-int",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag",
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with",
  	"es.unescape",
  	"es.weak-map",
  	"es.weak-set",
  	"web.atob",
  	"web.btoa",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.immediate",
  	"web.queue-microtask",
  	"web.self",
  	"web.structured-clone",
  	"web.timers",
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/stable/aggregate-error": [
  ],
  	"core-js/stable/array": [
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.from",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.is-array",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.of",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/stable/array-buffer": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.is-view",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.object.to-string"
  ],
  	"core-js/stable/array-buffer/constructor": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.array-buffer.detached",
  	"es.array-buffer.transfer",
  	"es.array-buffer.transfer-to-fixed-length",
  	"es.object.to-string"
  ],
  	"core-js/stable/array-buffer/detached": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.array-buffer.detached"
  ],
  	"core-js/stable/array-buffer/is-view": [
  	"es.array-buffer.is-view"
  ],
  	"core-js/stable/array-buffer/slice": [
  	"es.array-buffer.slice"
  ],
  	"core-js/stable/array-buffer/transfer": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.transfer"
  ],
  	"core-js/stable/array-buffer/transfer-to-fixed-length": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.array-buffer.transfer-to-fixed-length"
  ],
  	"core-js/stable/array/at": [
  	"es.array.at"
  ],
  	"core-js/stable/array/concat": [
  	"es.array.concat"
  ],
  	"core-js/stable/array/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/stable/array/entries": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/stable/array/every": [
  	"es.array.every"
  ],
  	"core-js/stable/array/fill": [
  	"es.array.fill"
  ],
  	"core-js/stable/array/filter": [
  	"es.array.filter"
  ],
  	"core-js/stable/array/find": [
  	"es.array.find"
  ],
  	"core-js/stable/array/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/stable/array/find-last": [
  	"es.array.find-last"
  ],
  	"core-js/stable/array/find-last-index": [
  	"es.array.find-last-index"
  ],
  	"core-js/stable/array/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/stable/array/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/stable/array/for-each": [
  	"es.array.for-each"
  ],
  	"core-js/stable/array/from": [
  	"es.array.from",
  	"es.string.iterator"
  ],
  	"core-js/stable/array/includes": [
  	"es.array.includes"
  ],
  	"core-js/stable/array/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/stable/array/is-array": [
  	"es.array.is-array"
  ],
  	"core-js/stable/array/iterator": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/stable/array/join": [
  	"es.array.join"
  ],
  	"core-js/stable/array/keys": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/stable/array/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/stable/array/map": [
  	"es.array.map"
  ],
  	"core-js/stable/array/of": [
  	"es.array.of"
  ],
  	"core-js/stable/array/push": [
  	"es.array.push"
  ],
  	"core-js/stable/array/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/stable/array/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/stable/array/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/stable/array/slice": [
  	"es.array.slice"
  ],
  	"core-js/stable/array/some": [
  	"es.array.some"
  ],
  	"core-js/stable/array/sort": [
  	"es.array.sort"
  ],
  	"core-js/stable/array/splice": [
  	"es.array.splice"
  ],
  	"core-js/stable/array/to-reversed": [
  	"es.array.to-reversed"
  ],
  	"core-js/stable/array/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted"
  ],
  	"core-js/stable/array/to-spliced": [
  	"es.array.to-spliced"
  ],
  	"core-js/stable/array/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/stable/array/values": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/stable/array/virtual": [
  	"es.array.at",
  	"es.array.concat",
  	"es.array.copy-within",
  	"es.array.every",
  	"es.array.fill",
  	"es.array.filter",
  	"es.array.find",
  	"es.array.find-index",
  	"es.array.find-last",
  	"es.array.find-last-index",
  	"es.array.flat",
  	"es.array.flat-map",
  	"es.array.for-each",
  	"es.array.includes",
  	"es.array.index-of",
  	"es.array.iterator",
  	"es.array.join",
  	"es.array.last-index-of",
  	"es.array.map",
  	"es.array.push",
  	"es.array.reduce",
  	"es.array.reduce-right",
  	"es.array.reverse",
  	"es.array.slice",
  	"es.array.some",
  	"es.array.sort",
  	"es.array.species",
  	"es.array.splice",
  	"es.array.to-reversed",
  	"es.array.to-sorted",
  	"es.array.to-spliced",
  	"es.array.unscopables.flat",
  	"es.array.unscopables.flat-map",
  	"es.array.unshift",
  	"es.array.with",
  	"es.object.to-string"
  ],
  	"core-js/stable/array/virtual/at": [
  	"es.array.at"
  ],
  	"core-js/stable/array/virtual/concat": [
  	"es.array.concat"
  ],
  	"core-js/stable/array/virtual/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/stable/array/virtual/entries": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/stable/array/virtual/every": [
  	"es.array.every"
  ],
  	"core-js/stable/array/virtual/fill": [
  	"es.array.fill"
  ],
  	"core-js/stable/array/virtual/filter": [
  	"es.array.filter"
  ],
  	"core-js/stable/array/virtual/find": [
  	"es.array.find"
  ],
  	"core-js/stable/array/virtual/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/stable/array/virtual/find-last": [
  	"es.array.find-last"
  ],
  	"core-js/stable/array/virtual/find-last-index": [
  	"es.array.find-last-index"
  ],
  	"core-js/stable/array/virtual/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/stable/array/virtual/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/stable/array/virtual/for-each": [
  	"es.array.for-each"
  ],
  	"core-js/stable/array/virtual/includes": [
  	"es.array.includes"
  ],
  	"core-js/stable/array/virtual/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/stable/array/virtual/iterator": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/stable/array/virtual/join": [
  	"es.array.join"
  ],
  	"core-js/stable/array/virtual/keys": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/stable/array/virtual/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/stable/array/virtual/map": [
  	"es.array.map"
  ],
  	"core-js/stable/array/virtual/push": [
  	"es.array.push"
  ],
  	"core-js/stable/array/virtual/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/stable/array/virtual/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/stable/array/virtual/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/stable/array/virtual/slice": [
  	"es.array.slice"
  ],
  	"core-js/stable/array/virtual/some": [
  	"es.array.some"
  ],
  	"core-js/stable/array/virtual/sort": [
  	"es.array.sort"
  ],
  	"core-js/stable/array/virtual/splice": [
  	"es.array.splice"
  ],
  	"core-js/stable/array/virtual/to-reversed": [
  	"es.array.to-reversed"
  ],
  	"core-js/stable/array/virtual/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted"
  ],
  	"core-js/stable/array/virtual/to-spliced": [
  	"es.array.to-spliced"
  ],
  	"core-js/stable/array/virtual/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/stable/array/virtual/values": [
  	"es.array.iterator",
  	"es.object.to-string"
  ],
  	"core-js/stable/array/virtual/with": [
  	"es.array.with"
  ],
  	"core-js/stable/array/with": [
  	"es.array.with"
  ],
  	"core-js/stable/atob": [
  	"es.error.to-string",
  	"es.object.to-string",
  	"web.atob",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/stable/btoa": [
  	"es.error.to-string",
  	"es.object.to-string",
  	"web.btoa",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/stable/clear-immediate": [
  	"web.immediate"
  ],
  	"core-js/stable/data-view": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.data-view",
  	"es.object.to-string"
  ],
  	"core-js/stable/date": [
  	"es.date.get-year",
  	"es.date.now",
  	"es.date.set-year",
  	"es.date.to-gmt-string",
  	"es.date.to-iso-string",
  	"es.date.to-json",
  	"es.date.to-primitive",
  	"es.date.to-string"
  ],
  	"core-js/stable/date/get-year": [
  	"es.date.get-year"
  ],
  	"core-js/stable/date/now": [
  	"es.date.now"
  ],
  	"core-js/stable/date/set-year": [
  	"es.date.set-year"
  ],
  	"core-js/stable/date/to-gmt-string": [
  	"es.date.to-gmt-string"
  ],
  	"core-js/stable/date/to-iso-string": [
  	"es.date.to-iso-string",
  	"es.date.to-json"
  ],
  	"core-js/stable/date/to-json": [
  	"es.date.to-json"
  ],
  	"core-js/stable/date/to-primitive": [
  	"es.date.to-primitive"
  ],
  	"core-js/stable/date/to-string": [
  	"es.date.to-string"
  ],
  	"core-js/stable/dom-collections": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/dom-collections/for-each": [
  	"web.dom-collections.for-each"
  ],
  	"core-js/stable/dom-collections/iterator": [
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/dom-exception": [
  	"es.error.to-string",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/stable/dom-exception/constructor": [
  	"es.error.to-string",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack"
  ],
  	"core-js/stable/dom-exception/to-string-tag": [
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/stable/error": [
  	"es.error.cause",
  	"es.error.to-string"
  ],
  	"core-js/stable/error/constructor": [
  	"es.error.cause"
  ],
  	"core-js/stable/error/to-string": [
  	"es.error.to-string"
  ],
  	"core-js/stable/escape": [
  	"es.escape"
  ],
  	"core-js/stable/function": [
  	"es.function.bind",
  	"es.function.has-instance",
  	"es.function.name"
  ],
  	"core-js/stable/function/bind": [
  	"es.function.bind"
  ],
  	"core-js/stable/function/has-instance": [
  	"es.function.has-instance"
  ],
  	"core-js/stable/function/name": [
  	"es.function.name"
  ],
  	"core-js/stable/function/virtual": [
  	"es.function.bind"
  ],
  	"core-js/stable/function/virtual/bind": [
  	"es.function.bind"
  ],
  	"core-js/stable/get-iterator": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/get-iterator-method": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/global-this": [
  	"es.global-this"
  ],
  	"core-js/stable/instance/at": [
  	"es.array.at",
  	"es.string.at-alternative"
  ],
  	"core-js/stable/instance/bind": [
  	"es.function.bind"
  ],
  	"core-js/stable/instance/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/stable/instance/concat": [
  	"es.array.concat"
  ],
  	"core-js/stable/instance/copy-within": [
  	"es.array.copy-within"
  ],
  	"core-js/stable/instance/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/stable/instance/entries": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/instance/every": [
  	"es.array.every"
  ],
  	"core-js/stable/instance/fill": [
  	"es.array.fill"
  ],
  	"core-js/stable/instance/filter": [
  	"es.array.filter"
  ],
  	"core-js/stable/instance/find": [
  	"es.array.find"
  ],
  	"core-js/stable/instance/find-index": [
  	"es.array.find-index"
  ],
  	"core-js/stable/instance/find-last": [
  	"es.array.find-last"
  ],
  	"core-js/stable/instance/find-last-index": [
  	"es.array.find-last-index"
  ],
  	"core-js/stable/instance/flags": [
  	"es.regexp.flags"
  ],
  	"core-js/stable/instance/flat": [
  	"es.array.flat",
  	"es.array.unscopables.flat"
  ],
  	"core-js/stable/instance/flat-map": [
  	"es.array.flat-map",
  	"es.array.unscopables.flat-map"
  ],
  	"core-js/stable/instance/for-each": [
  	"es.array.for-each",
  	"web.dom-collections.for-each"
  ],
  	"core-js/stable/instance/includes": [
  	"es.array.includes",
  	"es.string.includes"
  ],
  	"core-js/stable/instance/index-of": [
  	"es.array.index-of"
  ],
  	"core-js/stable/instance/is-well-formed": [
  	"es.string.is-well-formed"
  ],
  	"core-js/stable/instance/keys": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/instance/last-index-of": [
  	"es.array.last-index-of"
  ],
  	"core-js/stable/instance/map": [
  	"es.array.map"
  ],
  	"core-js/stable/instance/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/stable/instance/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/stable/instance/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/stable/instance/push": [
  	"es.array.push"
  ],
  	"core-js/stable/instance/reduce": [
  	"es.array.reduce"
  ],
  	"core-js/stable/instance/reduce-right": [
  	"es.array.reduce-right"
  ],
  	"core-js/stable/instance/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/stable/instance/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all"
  ],
  	"core-js/stable/instance/reverse": [
  	"es.array.reverse"
  ],
  	"core-js/stable/instance/slice": [
  	"es.array.slice"
  ],
  	"core-js/stable/instance/some": [
  	"es.array.some"
  ],
  	"core-js/stable/instance/sort": [
  	"es.array.sort"
  ],
  	"core-js/stable/instance/splice": [
  	"es.array.splice"
  ],
  	"core-js/stable/instance/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/stable/instance/to-reversed": [
  	"es.array.to-reversed"
  ],
  	"core-js/stable/instance/to-sorted": [
  	"es.array.sort",
  	"es.array.to-sorted"
  ],
  	"core-js/stable/instance/to-spliced": [
  	"es.array.to-spliced"
  ],
  	"core-js/stable/instance/to-well-formed": [
  	"es.string.to-well-formed"
  ],
  	"core-js/stable/instance/trim": [
  	"es.string.trim"
  ],
  	"core-js/stable/instance/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/stable/instance/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/stable/instance/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/stable/instance/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/stable/instance/unshift": [
  	"es.array.unshift"
  ],
  	"core-js/stable/instance/values": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/instance/with": [
  	"es.array.with"
  ],
  	"core-js/stable/is-iterable": [
  	"es.array.iterator",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/json": [
  	"es.date.to-json",
  	"es.json.stringify",
  	"es.json.to-string-tag"
  ],
  	"core-js/stable/json/stringify": [
  	"es.date.to-json",
  	"es.json.stringify"
  ],
  	"core-js/stable/json/to-string-tag": [
  	"es.json.to-string-tag"
  ],
  	"core-js/stable/map": [
  	"es.array.iterator",
  	"es.map",
  	"es.map.group-by",
  	"es.object.to-string",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/map/group-by": [
  	"es.map",
  	"es.map.group-by",
  	"es.object.to-string"
  ],
  	"core-js/stable/math": [
  	"es.math.acosh",
  	"es.math.asinh",
  	"es.math.atanh",
  	"es.math.cbrt",
  	"es.math.clz32",
  	"es.math.cosh",
  	"es.math.expm1",
  	"es.math.fround",
  	"es.math.hypot",
  	"es.math.imul",
  	"es.math.log10",
  	"es.math.log1p",
  	"es.math.log2",
  	"es.math.sign",
  	"es.math.sinh",
  	"es.math.tanh",
  	"es.math.to-string-tag",
  	"es.math.trunc"
  ],
  	"core-js/stable/math/acosh": [
  	"es.math.acosh"
  ],
  	"core-js/stable/math/asinh": [
  	"es.math.asinh"
  ],
  	"core-js/stable/math/atanh": [
  	"es.math.atanh"
  ],
  	"core-js/stable/math/cbrt": [
  	"es.math.cbrt"
  ],
  	"core-js/stable/math/clz32": [
  	"es.math.clz32"
  ],
  	"core-js/stable/math/cosh": [
  	"es.math.cosh"
  ],
  	"core-js/stable/math/expm1": [
  	"es.math.expm1"
  ],
  	"core-js/stable/math/fround": [
  	"es.math.fround"
  ],
  	"core-js/stable/math/hypot": [
  	"es.math.hypot"
  ],
  	"core-js/stable/math/imul": [
  	"es.math.imul"
  ],
  	"core-js/stable/math/log10": [
  	"es.math.log10"
  ],
  	"core-js/stable/math/log1p": [
  	"es.math.log1p"
  ],
  	"core-js/stable/math/log2": [
  	"es.math.log2"
  ],
  	"core-js/stable/math/sign": [
  	"es.math.sign"
  ],
  	"core-js/stable/math/sinh": [
  	"es.math.sinh"
  ],
  	"core-js/stable/math/tanh": [
  	"es.math.tanh"
  ],
  	"core-js/stable/math/to-string-tag": [
  	"es.math.to-string-tag"
  ],
  	"core-js/stable/math/trunc": [
  	"es.math.trunc"
  ],
  	"core-js/stable/number": [
  	"es.number.constructor",
  	"es.number.epsilon",
  	"es.number.is-finite",
  	"es.number.is-integer",
  	"es.number.is-nan",
  	"es.number.is-safe-integer",
  	"es.number.max-safe-integer",
  	"es.number.min-safe-integer",
  	"es.number.parse-float",
  	"es.number.parse-int",
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision"
  ],
  	"core-js/stable/number/constructor": [
  	"es.number.constructor"
  ],
  	"core-js/stable/number/epsilon": [
  	"es.number.epsilon"
  ],
  	"core-js/stable/number/is-finite": [
  	"es.number.is-finite"
  ],
  	"core-js/stable/number/is-integer": [
  	"es.number.is-integer"
  ],
  	"core-js/stable/number/is-nan": [
  	"es.number.is-nan"
  ],
  	"core-js/stable/number/is-safe-integer": [
  	"es.number.is-safe-integer"
  ],
  	"core-js/stable/number/max-safe-integer": [
  	"es.number.max-safe-integer"
  ],
  	"core-js/stable/number/min-safe-integer": [
  	"es.number.min-safe-integer"
  ],
  	"core-js/stable/number/parse-float": [
  	"es.number.parse-float"
  ],
  	"core-js/stable/number/parse-int": [
  	"es.number.parse-int"
  ],
  	"core-js/stable/number/to-exponential": [
  	"es.number.to-exponential"
  ],
  	"core-js/stable/number/to-fixed": [
  	"es.number.to-fixed"
  ],
  	"core-js/stable/number/to-precision": [
  	"es.number.to-precision"
  ],
  	"core-js/stable/number/virtual": [
  	"es.number.to-exponential",
  	"es.number.to-fixed",
  	"es.number.to-precision"
  ],
  	"core-js/stable/number/virtual/to-exponential": [
  	"es.number.to-exponential"
  ],
  	"core-js/stable/number/virtual/to-fixed": [
  	"es.number.to-fixed"
  ],
  	"core-js/stable/number/virtual/to-precision": [
  	"es.number.to-precision"
  ],
  	"core-js/stable/object": [
  	"es.symbol",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.assign",
  	"es.object.create",
  	"es.object.define-getter",
  	"es.object.define-properties",
  	"es.object.define-property",
  	"es.object.define-setter",
  	"es.object.entries",
  	"es.object.freeze",
  	"es.object.from-entries",
  	"es.object.get-own-property-descriptor",
  	"es.object.get-own-property-descriptors",
  	"es.object.get-own-property-names",
  	"es.object.get-prototype-of",
  	"es.object.group-by",
  	"es.object.has-own",
  	"es.object.is",
  	"es.object.is-extensible",
  	"es.object.is-frozen",
  	"es.object.is-sealed",
  	"es.object.keys",
  	"es.object.lookup-getter",
  	"es.object.lookup-setter",
  	"es.object.prevent-extensions",
  	"es.object.proto",
  	"es.object.seal",
  	"es.object.set-prototype-of",
  	"es.object.to-string",
  	"es.object.values",
  	"es.reflect.to-string-tag",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/object/assign": [
  	"es.object.assign"
  ],
  	"core-js/stable/object/create": [
  	"es.object.create"
  ],
  	"core-js/stable/object/define-getter": [
  	"es.object.define-getter"
  ],
  	"core-js/stable/object/define-properties": [
  	"es.object.define-properties"
  ],
  	"core-js/stable/object/define-property": [
  	"es.object.define-property"
  ],
  	"core-js/stable/object/define-setter": [
  	"es.object.define-setter"
  ],
  	"core-js/stable/object/entries": [
  	"es.object.entries"
  ],
  	"core-js/stable/object/freeze": [
  	"es.object.freeze"
  ],
  	"core-js/stable/object/from-entries": [
  	"es.array.iterator",
  	"es.object.from-entries",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/object/get-own-property-descriptor": [
  	"es.object.get-own-property-descriptor"
  ],
  	"core-js/stable/object/get-own-property-descriptors": [
  	"es.object.get-own-property-descriptors"
  ],
  	"core-js/stable/object/get-own-property-names": [
  	"es.object.get-own-property-names"
  ],
  	"core-js/stable/object/get-own-property-symbols": [
  	"es.symbol"
  ],
  	"core-js/stable/object/get-prototype-of": [
  	"es.object.get-prototype-of"
  ],
  	"core-js/stable/object/group-by": [
  	"es.object.create",
  	"es.object.group-by"
  ],
  	"core-js/stable/object/has-own": [
  	"es.object.has-own"
  ],
  	"core-js/stable/object/is": [
  	"es.object.is"
  ],
  	"core-js/stable/object/is-extensible": [
  	"es.object.is-extensible"
  ],
  	"core-js/stable/object/is-frozen": [
  	"es.object.is-frozen"
  ],
  	"core-js/stable/object/is-sealed": [
  	"es.object.is-sealed"
  ],
  	"core-js/stable/object/keys": [
  	"es.object.keys"
  ],
  	"core-js/stable/object/lookup-getter": [
  	"es.object.lookup-getter"
  ],
  	"core-js/stable/object/lookup-setter": [
  	"es.object.lookup-setter"
  ],
  	"core-js/stable/object/prevent-extensions": [
  	"es.object.prevent-extensions"
  ],
  	"core-js/stable/object/proto": [
  	"es.object.proto"
  ],
  	"core-js/stable/object/seal": [
  	"es.object.seal"
  ],
  	"core-js/stable/object/set-prototype-of": [
  	"es.object.set-prototype-of"
  ],
  	"core-js/stable/object/to-string": [
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/stable/object/values": [
  	"es.object.values"
  ],
  	"core-js/stable/parse-float": [
  	"es.parse-float"
  ],
  	"core-js/stable/parse-int": [
  	"es.parse-int"
  ],
  	"core-js/stable/promise": [
  	"es.aggregate-error",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.promise.any",
  	"es.promise.finally",
  	"es.promise.with-resolvers",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/promise/all-settled": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.all-settled",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/promise/any": [
  	"es.aggregate-error",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.any",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/promise/finally": [
  	"es.object.to-string",
  	"es.promise",
  	"es.promise.finally"
  ],
  	"core-js/stable/promise/with-resolvers": [
  	"es.promise",
  	"es.promise.with-resolvers"
  ],
  	"core-js/stable/queue-microtask": [
  	"web.queue-microtask"
  ],
  	"core-js/stable/reflect": [
  	"es.object.to-string",
  	"es.reflect.apply",
  	"es.reflect.construct",
  	"es.reflect.define-property",
  	"es.reflect.delete-property",
  	"es.reflect.get",
  	"es.reflect.get-own-property-descriptor",
  	"es.reflect.get-prototype-of",
  	"es.reflect.has",
  	"es.reflect.is-extensible",
  	"es.reflect.own-keys",
  	"es.reflect.prevent-extensions",
  	"es.reflect.set",
  	"es.reflect.set-prototype-of",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/stable/reflect/apply": [
  	"es.reflect.apply"
  ],
  	"core-js/stable/reflect/construct": [
  	"es.reflect.construct"
  ],
  	"core-js/stable/reflect/define-property": [
  	"es.reflect.define-property"
  ],
  	"core-js/stable/reflect/delete-property": [
  	"es.reflect.delete-property"
  ],
  	"core-js/stable/reflect/get": [
  	"es.reflect.get"
  ],
  	"core-js/stable/reflect/get-own-property-descriptor": [
  	"es.reflect.get-own-property-descriptor"
  ],
  	"core-js/stable/reflect/get-prototype-of": [
  	"es.reflect.get-prototype-of"
  ],
  	"core-js/stable/reflect/has": [
  	"es.reflect.has"
  ],
  	"core-js/stable/reflect/is-extensible": [
  	"es.reflect.is-extensible"
  ],
  	"core-js/stable/reflect/own-keys": [
  	"es.reflect.own-keys"
  ],
  	"core-js/stable/reflect/prevent-extensions": [
  	"es.reflect.prevent-extensions"
  ],
  	"core-js/stable/reflect/set": [
  	"es.reflect.set"
  ],
  	"core-js/stable/reflect/set-prototype-of": [
  	"es.reflect.set-prototype-of"
  ],
  	"core-js/stable/reflect/to-string-tag": [
  	"es.reflect.to-string-tag"
  ],
  	"core-js/stable/regexp": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.flags",
  	"es.regexp.sticky",
  	"es.regexp.test",
  	"es.regexp.to-string",
  	"es.string.match",
  	"es.string.replace",
  	"es.string.search",
  	"es.string.split"
  ],
  	"core-js/stable/regexp/constructor": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec",
  	"es.regexp.sticky"
  ],
  	"core-js/stable/regexp/dot-all": [
  	"es.regexp.constructor",
  	"es.regexp.dot-all",
  	"es.regexp.exec"
  ],
  	"core-js/stable/regexp/flags": [
  	"es.regexp.flags"
  ],
  	"core-js/stable/regexp/match": [
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/stable/regexp/replace": [
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/stable/regexp/search": [
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/stable/regexp/split": [
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/stable/regexp/sticky": [
  	"es.regexp.constructor",
  	"es.regexp.exec",
  	"es.regexp.sticky"
  ],
  	"core-js/stable/regexp/test": [
  	"es.regexp.exec",
  	"es.regexp.test"
  ],
  	"core-js/stable/regexp/to-string": [
  	"es.regexp.to-string"
  ],
  	"core-js/stable/self": [
  	"web.self"
  ],
  	"core-js/stable/set": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.set",
  	"es.set.difference.v2",
  	"es.set.intersection.v2",
  	"es.set.is-disjoint-from.v2",
  	"es.set.is-subset-of.v2",
  	"es.set.is-superset-of.v2",
  	"es.set.symmetric-difference.v2",
  	"es.set.union.v2",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/set-immediate": [
  	"web.immediate"
  ],
  	"core-js/stable/set-interval": [
  	"web.timers"
  ],
  	"core-js/stable/set-timeout": [
  	"web.timers"
  ],
  	"core-js/stable/set/difference": [
  	"es.set",
  	"es.set.difference.v2"
  ],
  	"core-js/stable/set/intersection": [
  	"es.set",
  	"es.set.intersection.v2"
  ],
  	"core-js/stable/set/is-disjoint-from": [
  	"es.set",
  	"es.set.is-disjoint-from.v2"
  ],
  	"core-js/stable/set/is-subset-of": [
  	"es.set",
  	"es.set.is-subset-of.v2"
  ],
  	"core-js/stable/set/is-superset-of": [
  	"es.set",
  	"es.set.is-superset-of.v2"
  ],
  	"core-js/stable/set/symmetric-difference": [
  	"es.set",
  	"es.set.symmetric-difference.v2"
  ],
  	"core-js/stable/set/union": [
  	"es.set",
  	"es.set.union.v2"
  ],
  	"core-js/stable/string": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.from-code-point",
  	"es.string.includes",
  	"es.string.is-well-formed",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.raw",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.to-well-formed",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup"
  ],
  	"core-js/stable/string/anchor": [
  	"es.string.anchor"
  ],
  	"core-js/stable/string/at": [
  	"es.string.at-alternative"
  ],
  	"core-js/stable/string/big": [
  	"es.string.big"
  ],
  	"core-js/stable/string/blink": [
  	"es.string.blink"
  ],
  	"core-js/stable/string/bold": [
  	"es.string.bold"
  ],
  	"core-js/stable/string/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/stable/string/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/stable/string/fixed": [
  	"es.string.fixed"
  ],
  	"core-js/stable/string/fontcolor": [
  	"es.string.fontcolor"
  ],
  	"core-js/stable/string/fontsize": [
  	"es.string.fontsize"
  ],
  	"core-js/stable/string/from-code-point": [
  	"es.string.from-code-point"
  ],
  	"core-js/stable/string/includes": [
  	"es.string.includes"
  ],
  	"core-js/stable/string/is-well-formed": [
  	"es.string.is-well-formed"
  ],
  	"core-js/stable/string/italics": [
  	"es.string.italics"
  ],
  	"core-js/stable/string/iterator": [
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/stable/string/link": [
  	"es.string.link"
  ],
  	"core-js/stable/string/match": [
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/stable/string/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/stable/string/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/stable/string/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/stable/string/raw": [
  	"es.string.raw"
  ],
  	"core-js/stable/string/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/stable/string/replace": [
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/stable/string/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all"
  ],
  	"core-js/stable/string/search": [
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/stable/string/small": [
  	"es.string.small"
  ],
  	"core-js/stable/string/split": [
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/stable/string/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/stable/string/strike": [
  	"es.string.strike"
  ],
  	"core-js/stable/string/sub": [
  	"es.string.sub"
  ],
  	"core-js/stable/string/substr": [
  	"es.string.substr"
  ],
  	"core-js/stable/string/sup": [
  	"es.string.sup"
  ],
  	"core-js/stable/string/to-well-formed": [
  	"es.string.to-well-formed"
  ],
  	"core-js/stable/string/trim": [
  	"es.string.trim"
  ],
  	"core-js/stable/string/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/stable/string/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/stable/string/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/stable/string/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/stable/string/virtual": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.at-alternative",
  	"es.string.code-point-at",
  	"es.string.ends-with",
  	"es.string.includes",
  	"es.string.iterator",
  	"es.string.match",
  	"es.string.match-all",
  	"es.string.pad-end",
  	"es.string.pad-start",
  	"es.string.repeat",
  	"es.string.replace",
  	"es.string.replace-all",
  	"es.string.search",
  	"es.string.split",
  	"es.string.starts-with",
  	"es.string.substr",
  	"es.string.trim",
  	"es.string.trim-end",
  	"es.string.trim-start",
  	"es.string.anchor",
  	"es.string.big",
  	"es.string.blink",
  	"es.string.bold",
  	"es.string.fixed",
  	"es.string.fontcolor",
  	"es.string.fontsize",
  	"es.string.italics",
  	"es.string.link",
  	"es.string.small",
  	"es.string.strike",
  	"es.string.sub",
  	"es.string.sup"
  ],
  	"core-js/stable/string/virtual/anchor": [
  	"es.string.anchor"
  ],
  	"core-js/stable/string/virtual/at": [
  	"es.string.at-alternative"
  ],
  	"core-js/stable/string/virtual/big": [
  	"es.string.big"
  ],
  	"core-js/stable/string/virtual/blink": [
  	"es.string.blink"
  ],
  	"core-js/stable/string/virtual/bold": [
  	"es.string.bold"
  ],
  	"core-js/stable/string/virtual/code-point-at": [
  	"es.string.code-point-at"
  ],
  	"core-js/stable/string/virtual/ends-with": [
  	"es.string.ends-with"
  ],
  	"core-js/stable/string/virtual/fixed": [
  	"es.string.fixed"
  ],
  	"core-js/stable/string/virtual/fontcolor": [
  	"es.string.fontcolor"
  ],
  	"core-js/stable/string/virtual/fontsize": [
  	"es.string.fontsize"
  ],
  	"core-js/stable/string/virtual/includes": [
  	"es.string.includes"
  ],
  	"core-js/stable/string/virtual/is-well-formed": [
  	"es.string.is-well-formed"
  ],
  	"core-js/stable/string/virtual/italics": [
  	"es.string.italics"
  ],
  	"core-js/stable/string/virtual/iterator": [
  	"es.object.to-string",
  	"es.string.iterator"
  ],
  	"core-js/stable/string/virtual/link": [
  	"es.string.link"
  ],
  	"core-js/stable/string/virtual/match-all": [
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/stable/string/virtual/pad-end": [
  	"es.string.pad-end"
  ],
  	"core-js/stable/string/virtual/pad-start": [
  	"es.string.pad-start"
  ],
  	"core-js/stable/string/virtual/repeat": [
  	"es.string.repeat"
  ],
  	"core-js/stable/string/virtual/replace-all": [
  	"es.regexp.exec",
  	"es.string.replace",
  	"es.string.replace-all"
  ],
  	"core-js/stable/string/virtual/small": [
  	"es.string.small"
  ],
  	"core-js/stable/string/virtual/starts-with": [
  	"es.string.starts-with"
  ],
  	"core-js/stable/string/virtual/strike": [
  	"es.string.strike"
  ],
  	"core-js/stable/string/virtual/sub": [
  	"es.string.sub"
  ],
  	"core-js/stable/string/virtual/substr": [
  	"es.string.substr"
  ],
  	"core-js/stable/string/virtual/sup": [
  	"es.string.sup"
  ],
  	"core-js/stable/string/virtual/to-well-formed": [
  	"es.string.to-well-formed"
  ],
  	"core-js/stable/string/virtual/trim": [
  	"es.string.trim"
  ],
  	"core-js/stable/string/virtual/trim-end": [
  	"es.string.trim-end"
  ],
  	"core-js/stable/string/virtual/trim-left": [
  	"es.string.trim-start"
  ],
  	"core-js/stable/string/virtual/trim-right": [
  	"es.string.trim-end"
  ],
  	"core-js/stable/string/virtual/trim-start": [
  	"es.string.trim-start"
  ],
  	"core-js/stable/structured-clone": [
  	"es.error.to-string",
  	"es.array.iterator",
  	"es.map",
  	"es.object.keys",
  	"es.object.to-string",
  	"es.set",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.structured-clone"
  ],
  	"core-js/stable/symbol": [
  	"es.symbol",
  	"es.symbol.description",
  	"es.symbol.async-iterator",
  	"es.symbol.has-instance",
  	"es.symbol.is-concat-spreadable",
  	"es.symbol.iterator",
  	"es.symbol.match",
  	"es.symbol.match-all",
  	"es.symbol.replace",
  	"es.symbol.search",
  	"es.symbol.species",
  	"es.symbol.split",
  	"es.symbol.to-primitive",
  	"es.symbol.to-string-tag",
  	"es.symbol.unscopables",
  	"es.array.concat",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/symbol/async-iterator": [
  	"es.symbol.async-iterator"
  ],
  	"core-js/stable/symbol/description": [
  	"es.symbol.description"
  ],
  	"core-js/stable/symbol/for": [
  	"es.symbol"
  ],
  	"core-js/stable/symbol/has-instance": [
  	"es.symbol.has-instance",
  	"es.function.has-instance"
  ],
  	"core-js/stable/symbol/is-concat-spreadable": [
  	"es.symbol.is-concat-spreadable",
  	"es.array.concat"
  ],
  	"core-js/stable/symbol/iterator": [
  	"es.symbol.iterator",
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.string.iterator",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/symbol/key-for": [
  	"es.symbol"
  ],
  	"core-js/stable/symbol/match": [
  	"es.symbol.match",
  	"es.regexp.exec",
  	"es.string.match"
  ],
  	"core-js/stable/symbol/match-all": [
  	"es.symbol.match-all",
  	"es.object.to-string",
  	"es.regexp.exec",
  	"es.string.match-all"
  ],
  	"core-js/stable/symbol/replace": [
  	"es.symbol.replace",
  	"es.regexp.exec",
  	"es.string.replace"
  ],
  	"core-js/stable/symbol/search": [
  	"es.symbol.search",
  	"es.regexp.exec",
  	"es.string.search"
  ],
  	"core-js/stable/symbol/species": [
  	"es.symbol.species"
  ],
  	"core-js/stable/symbol/split": [
  	"es.symbol.split",
  	"es.regexp.exec",
  	"es.string.split"
  ],
  	"core-js/stable/symbol/to-primitive": [
  	"es.symbol.to-primitive",
  	"es.date.to-primitive"
  ],
  	"core-js/stable/symbol/to-string-tag": [
  	"es.symbol.to-string-tag",
  	"es.json.to-string-tag",
  	"es.math.to-string-tag",
  	"es.object.to-string",
  	"es.reflect.to-string-tag"
  ],
  	"core-js/stable/symbol/unscopables": [
  	"es.symbol.unscopables"
  ],
  	"core-js/stable/typed-array": [
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.float32-array",
  	"es.typed-array.float64-array",
  	"es.typed-array.int8-array",
  	"es.typed-array.int16-array",
  	"es.typed-array.int32-array",
  	"es.typed-array.uint8-array",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.uint16-array",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/stable/typed-array/at": [
  	"es.typed-array.at"
  ],
  	"core-js/stable/typed-array/copy-within": [
  	"es.typed-array.copy-within"
  ],
  	"core-js/stable/typed-array/entries": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/stable/typed-array/every": [
  	"es.typed-array.every"
  ],
  	"core-js/stable/typed-array/fill": [
  	"es.typed-array.fill"
  ],
  	"core-js/stable/typed-array/filter": [
  	"es.typed-array.filter"
  ],
  	"core-js/stable/typed-array/find": [
  	"es.typed-array.find"
  ],
  	"core-js/stable/typed-array/find-index": [
  	"es.typed-array.find-index"
  ],
  	"core-js/stable/typed-array/find-last": [
  	"es.typed-array.find-last"
  ],
  	"core-js/stable/typed-array/find-last-index": [
  	"es.typed-array.find-last-index"
  ],
  	"core-js/stable/typed-array/float32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.float32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/stable/typed-array/float64-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.float64-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/stable/typed-array/for-each": [
  	"es.typed-array.for-each"
  ],
  	"core-js/stable/typed-array/from": [
  	"es.typed-array.from"
  ],
  	"core-js/stable/typed-array/includes": [
  	"es.typed-array.includes"
  ],
  	"core-js/stable/typed-array/index-of": [
  	"es.typed-array.index-of"
  ],
  	"core-js/stable/typed-array/int16-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.int16-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/stable/typed-array/int32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.int32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/stable/typed-array/int8-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.int8-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/stable/typed-array/iterator": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/stable/typed-array/join": [
  	"es.typed-array.join"
  ],
  	"core-js/stable/typed-array/keys": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/stable/typed-array/last-index-of": [
  	"es.typed-array.last-index-of"
  ],
  	"core-js/stable/typed-array/map": [
  	"es.typed-array.map"
  ],
  	"core-js/stable/typed-array/methods": [
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/stable/typed-array/of": [
  	"es.typed-array.of"
  ],
  	"core-js/stable/typed-array/reduce": [
  	"es.typed-array.reduce"
  ],
  	"core-js/stable/typed-array/reduce-right": [
  	"es.typed-array.reduce-right"
  ],
  	"core-js/stable/typed-array/reverse": [
  	"es.typed-array.reverse"
  ],
  	"core-js/stable/typed-array/set": [
  	"es.typed-array.set"
  ],
  	"core-js/stable/typed-array/slice": [
  	"es.typed-array.slice"
  ],
  	"core-js/stable/typed-array/some": [
  	"es.typed-array.some"
  ],
  	"core-js/stable/typed-array/sort": [
  	"es.typed-array.sort"
  ],
  	"core-js/stable/typed-array/subarray": [
  	"es.typed-array.subarray"
  ],
  	"core-js/stable/typed-array/to-locale-string": [
  	"es.typed-array.to-locale-string"
  ],
  	"core-js/stable/typed-array/to-reversed": [
  	"es.typed-array.to-reversed"
  ],
  	"core-js/stable/typed-array/to-sorted": [
  	"es.typed-array.sort",
  	"es.typed-array.to-sorted"
  ],
  	"core-js/stable/typed-array/to-string": [
  	"es.typed-array.to-string"
  ],
  	"core-js/stable/typed-array/uint16-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint16-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/stable/typed-array/uint32-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint32-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/stable/typed-array/uint8-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint8-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/stable/typed-array/uint8-clamped-array": [
  	"es.array-buffer.constructor",
  	"es.array-buffer.slice",
  	"es.object.to-string",
  	"es.string.iterator",
  	"es.typed-array.uint8-clamped-array",
  	"es.typed-array.at",
  	"es.typed-array.copy-within",
  	"es.typed-array.every",
  	"es.typed-array.fill",
  	"es.typed-array.filter",
  	"es.typed-array.find",
  	"es.typed-array.find-index",
  	"es.typed-array.find-last",
  	"es.typed-array.find-last-index",
  	"es.typed-array.for-each",
  	"es.typed-array.from",
  	"es.typed-array.includes",
  	"es.typed-array.index-of",
  	"es.typed-array.iterator",
  	"es.typed-array.join",
  	"es.typed-array.last-index-of",
  	"es.typed-array.map",
  	"es.typed-array.of",
  	"es.typed-array.reduce",
  	"es.typed-array.reduce-right",
  	"es.typed-array.reverse",
  	"es.typed-array.set",
  	"es.typed-array.slice",
  	"es.typed-array.some",
  	"es.typed-array.sort",
  	"es.typed-array.subarray",
  	"es.typed-array.to-locale-string",
  	"es.typed-array.to-reversed",
  	"es.typed-array.to-sorted",
  	"es.typed-array.to-string",
  	"es.typed-array.with"
  ],
  	"core-js/stable/typed-array/values": [
  	"es.object.to-string",
  	"es.typed-array.iterator"
  ],
  	"core-js/stable/typed-array/with": [
  	"es.typed-array.with"
  ],
  	"core-js/stable/unescape": [
  	"es.unescape"
  ],
  	"core-js/stable/url": [
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/stable/url-search-params": [
  	"web.dom-collections.iterator",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/stable/url/can-parse": [
  	"web.url",
  	"web.url.can-parse"
  ],
  	"core-js/stable/url/parse": [
  	"web.url",
  	"web.url.parse"
  ],
  	"core-js/stable/url/to-json": [
  	"web.url.to-json"
  ],
  	"core-js/stable/weak-map": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.weak-map",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stable/weak-set": [
  	"es.array.iterator",
  	"es.object.to-string",
  	"es.weak-set",
  	"web.dom-collections.iterator"
  ],
  	"core-js/stage": [
  	"es.map",
  	"es.string.at-alternative",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.bigint.range",
  	"esnext.composite-key",
  	"esnext.composite-symbol",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.demethodize",
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor",
  	"esnext.function.metadata",
  	"esnext.function.un-this",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.f16round",
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.sum-precise",
  	"esnext.math.umulh",
  	"esnext.number.from-string",
  	"esnext.number.range",
  	"esnext.object.has-own",
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values",
  	"esnext.object.group-by",
  	"esnext.observable",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.reflect.define-metadata",
  	"esnext.reflect.delete-metadata",
  	"esnext.reflect.get-metadata",
  	"esnext.reflect.get-metadata-keys",
  	"esnext.reflect.get-own-metadata",
  	"esnext.reflect.get-own-metadata-keys",
  	"esnext.reflect.has-metadata",
  	"esnext.reflect.has-own-metadata",
  	"esnext.reflect.metadata",
  	"esnext.regexp.escape",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"esnext.string.at",
  	"esnext.string.cooked",
  	"esnext.string.code-points",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.custom-matcher",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.symbol.replace-all",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of",
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/stage/0": [
  	"es.map",
  	"es.string.at-alternative",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.bigint.range",
  	"esnext.composite-key",
  	"esnext.composite-symbol",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.demethodize",
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor",
  	"esnext.function.metadata",
  	"esnext.function.un-this",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.f16round",
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.sum-precise",
  	"esnext.math.umulh",
  	"esnext.number.from-string",
  	"esnext.number.range",
  	"esnext.object.has-own",
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values",
  	"esnext.object.group-by",
  	"esnext.observable",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.regexp.escape",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"esnext.string.at",
  	"esnext.string.cooked",
  	"esnext.string.code-points",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.custom-matcher",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.symbol.replace-all",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of",
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/stage/1": [
  	"es.map",
  	"es.string.at-alternative",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.bigint.range",
  	"esnext.composite-key",
  	"esnext.composite-symbol",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.metadata",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.f16round",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.sum-precise",
  	"esnext.number.from-string",
  	"esnext.number.range",
  	"esnext.object.has-own",
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values",
  	"esnext.object.group-by",
  	"esnext.observable",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.regexp.escape",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"esnext.string.cooked",
  	"esnext.string.code-points",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.custom-matcher",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.symbol.replace-all",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of"
  ],
  	"core-js/stage/2": [
  	"es.string.at-alternative",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.set-float16",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.metadata",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.emplace",
  	"esnext.map.group-by",
  	"esnext.math.f16round",
  	"esnext.math.sum-precise",
  	"esnext.object.has-own",
  	"esnext.object.group-by",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.regexp.escape",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.typed-array.at",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex",
  	"esnext.weak-map.emplace"
  ],
  	"core-js/stage/2.7": [
  	"es.string.at-alternative",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.set-float16",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.metadata",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.map",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.group-by",
  	"esnext.math.f16round",
  	"esnext.math.sum-precise",
  	"esnext.object.has-own",
  	"esnext.object.group-by",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.regexp.escape",
  	"esnext.set.difference.v2",
  	"esnext.set.intersection.v2",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.union.v2",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.dispose",
  	"esnext.symbol.metadata",
  	"esnext.typed-array.at",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/stage/3": [
  	"es.string.at-alternative",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.set-float16",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.metadata",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.map",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.group-by",
  	"esnext.math.f16round",
  	"esnext.object.has-own",
  	"esnext.object.group-by",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.regexp.escape",
  	"esnext.set.difference.v2",
  	"esnext.set.intersection.v2",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.union.v2",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.dispose",
  	"esnext.symbol.metadata",
  	"esnext.typed-array.at",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex"
  ],
  	"core-js/stage/4": [
  	"es.string.at-alternative",
  	"esnext.aggregate-error",
  	"esnext.array.at",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.global-this",
  	"esnext.map.group-by",
  	"esnext.object.has-own",
  	"esnext.object.group-by",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.with-resolvers",
  	"esnext.set.difference.v2",
  	"esnext.set.intersection.v2",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.union.v2",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.typed-array.at",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.with"
  ],
  	"core-js/stage/pre": [
  	"es.map",
  	"es.string.at-alternative",
  	"esnext.aggregate-error",
  	"esnext.suppressed-error.constructor",
  	"esnext.array.from-async",
  	"esnext.array.at",
  	"esnext.array.filter-out",
  	"esnext.array.filter-reject",
  	"esnext.array.find-last",
  	"esnext.array.find-last-index",
  	"esnext.array.group",
  	"esnext.array.group-by",
  	"esnext.array.group-by-to-map",
  	"esnext.array.group-to-map",
  	"esnext.array.is-template-object",
  	"esnext.array.last-index",
  	"esnext.array.last-item",
  	"esnext.array.to-reversed",
  	"esnext.array.to-sorted",
  	"esnext.array.to-spliced",
  	"esnext.array.unique-by",
  	"esnext.array.with",
  	"esnext.array-buffer.detached",
  	"esnext.array-buffer.transfer",
  	"esnext.array-buffer.transfer-to-fixed-length",
  	"esnext.async-disposable-stack.constructor",
  	"esnext.async-iterator.constructor",
  	"esnext.async-iterator.as-indexed-pairs",
  	"esnext.async-iterator.async-dispose",
  	"esnext.async-iterator.drop",
  	"esnext.async-iterator.every",
  	"esnext.async-iterator.filter",
  	"esnext.async-iterator.find",
  	"esnext.async-iterator.flat-map",
  	"esnext.async-iterator.for-each",
  	"esnext.async-iterator.from",
  	"esnext.async-iterator.indexed",
  	"esnext.async-iterator.map",
  	"esnext.async-iterator.reduce",
  	"esnext.async-iterator.some",
  	"esnext.async-iterator.take",
  	"esnext.async-iterator.to-array",
  	"esnext.bigint.range",
  	"esnext.composite-key",
  	"esnext.composite-symbol",
  	"esnext.data-view.get-float16",
  	"esnext.data-view.get-uint8-clamped",
  	"esnext.data-view.set-float16",
  	"esnext.data-view.set-uint8-clamped",
  	"esnext.disposable-stack.constructor",
  	"esnext.function.demethodize",
  	"esnext.function.is-callable",
  	"esnext.function.is-constructor",
  	"esnext.function.metadata",
  	"esnext.function.un-this",
  	"esnext.global-this",
  	"esnext.iterator.constructor",
  	"esnext.iterator.as-indexed-pairs",
  	"esnext.iterator.dispose",
  	"esnext.iterator.drop",
  	"esnext.iterator.every",
  	"esnext.iterator.filter",
  	"esnext.iterator.find",
  	"esnext.iterator.flat-map",
  	"esnext.iterator.for-each",
  	"esnext.iterator.from",
  	"esnext.iterator.indexed",
  	"esnext.iterator.map",
  	"esnext.iterator.range",
  	"esnext.iterator.reduce",
  	"esnext.iterator.some",
  	"esnext.iterator.take",
  	"esnext.iterator.to-array",
  	"esnext.iterator.to-async",
  	"esnext.json.is-raw-json",
  	"esnext.json.parse",
  	"esnext.json.raw-json",
  	"esnext.map.delete-all",
  	"esnext.map.emplace",
  	"esnext.map.every",
  	"esnext.map.filter",
  	"esnext.map.find",
  	"esnext.map.find-key",
  	"esnext.map.from",
  	"esnext.map.group-by",
  	"esnext.map.includes",
  	"esnext.map.key-by",
  	"esnext.map.key-of",
  	"esnext.map.map-keys",
  	"esnext.map.map-values",
  	"esnext.map.merge",
  	"esnext.map.of",
  	"esnext.map.reduce",
  	"esnext.map.some",
  	"esnext.map.update",
  	"esnext.map.update-or-insert",
  	"esnext.map.upsert",
  	"esnext.math.clamp",
  	"esnext.math.deg-per-rad",
  	"esnext.math.degrees",
  	"esnext.math.fscale",
  	"esnext.math.f16round",
  	"esnext.math.iaddh",
  	"esnext.math.imulh",
  	"esnext.math.isubh",
  	"esnext.math.rad-per-deg",
  	"esnext.math.radians",
  	"esnext.math.scale",
  	"esnext.math.seeded-prng",
  	"esnext.math.signbit",
  	"esnext.math.sum-precise",
  	"esnext.math.umulh",
  	"esnext.number.from-string",
  	"esnext.number.range",
  	"esnext.object.has-own",
  	"esnext.object.iterate-entries",
  	"esnext.object.iterate-keys",
  	"esnext.object.iterate-values",
  	"esnext.object.group-by",
  	"esnext.observable",
  	"esnext.promise.all-settled",
  	"esnext.promise.any",
  	"esnext.promise.try",
  	"esnext.promise.with-resolvers",
  	"esnext.reflect.define-metadata",
  	"esnext.reflect.delete-metadata",
  	"esnext.reflect.get-metadata",
  	"esnext.reflect.get-metadata-keys",
  	"esnext.reflect.get-own-metadata",
  	"esnext.reflect.get-own-metadata-keys",
  	"esnext.reflect.has-metadata",
  	"esnext.reflect.has-own-metadata",
  	"esnext.reflect.metadata",
  	"esnext.regexp.escape",
  	"esnext.set.add-all",
  	"esnext.set.delete-all",
  	"esnext.set.difference.v2",
  	"esnext.set.difference",
  	"esnext.set.every",
  	"esnext.set.filter",
  	"esnext.set.find",
  	"esnext.set.from",
  	"esnext.set.intersection.v2",
  	"esnext.set.intersection",
  	"esnext.set.is-disjoint-from.v2",
  	"esnext.set.is-disjoint-from",
  	"esnext.set.is-subset-of.v2",
  	"esnext.set.is-subset-of",
  	"esnext.set.is-superset-of.v2",
  	"esnext.set.is-superset-of",
  	"esnext.set.join",
  	"esnext.set.map",
  	"esnext.set.of",
  	"esnext.set.reduce",
  	"esnext.set.some",
  	"esnext.set.symmetric-difference.v2",
  	"esnext.set.symmetric-difference",
  	"esnext.set.union.v2",
  	"esnext.set.union",
  	"esnext.string.at",
  	"esnext.string.cooked",
  	"esnext.string.code-points",
  	"esnext.string.dedent",
  	"esnext.string.is-well-formed",
  	"esnext.string.match-all",
  	"esnext.string.replace-all",
  	"esnext.string.to-well-formed",
  	"esnext.symbol.async-dispose",
  	"esnext.symbol.custom-matcher",
  	"esnext.symbol.dispose",
  	"esnext.symbol.is-registered-symbol",
  	"esnext.symbol.is-registered",
  	"esnext.symbol.is-well-known-symbol",
  	"esnext.symbol.is-well-known",
  	"esnext.symbol.matcher",
  	"esnext.symbol.metadata",
  	"esnext.symbol.metadata-key",
  	"esnext.symbol.observable",
  	"esnext.symbol.pattern-match",
  	"esnext.symbol.replace-all",
  	"esnext.typed-array.from-async",
  	"esnext.typed-array.at",
  	"esnext.typed-array.filter-out",
  	"esnext.typed-array.filter-reject",
  	"esnext.typed-array.find-last",
  	"esnext.typed-array.find-last-index",
  	"esnext.typed-array.group-by",
  	"esnext.typed-array.to-reversed",
  	"esnext.typed-array.to-sorted",
  	"esnext.typed-array.to-spliced",
  	"esnext.typed-array.unique-by",
  	"esnext.typed-array.with",
  	"esnext.uint8-array.from-base64",
  	"esnext.uint8-array.from-hex",
  	"esnext.uint8-array.set-from-base64",
  	"esnext.uint8-array.set-from-hex",
  	"esnext.uint8-array.to-base64",
  	"esnext.uint8-array.to-hex",
  	"esnext.weak-map.delete-all",
  	"esnext.weak-map.from",
  	"esnext.weak-map.of",
  	"esnext.weak-map.emplace",
  	"esnext.weak-map.upsert",
  	"esnext.weak-set.add-all",
  	"esnext.weak-set.delete-all",
  	"esnext.weak-set.from",
  	"esnext.weak-set.of",
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/web": [
  	"web.atob",
  	"web.btoa",
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag",
  	"web.immediate",
  	"web.queue-microtask",
  	"web.self",
  	"web.structured-clone",
  	"web.timers",
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/web/dom-collections": [
  	"web.dom-collections.for-each",
  	"web.dom-collections.iterator"
  ],
  	"core-js/web/dom-exception": [
  	"es.error.to-string",
  	"web.dom-exception.constructor",
  	"web.dom-exception.stack",
  	"web.dom-exception.to-string-tag"
  ],
  	"core-js/web/immediate": [
  	"web.immediate"
  ],
  	"core-js/web/queue-microtask": [
  	"web.queue-microtask"
  ],
  	"core-js/web/structured-clone": [
  	"es.array.iterator",
  	"es.map",
  	"es.object.to-string",
  	"es.set",
  	"web.structured-clone"
  ],
  	"core-js/web/timers": [
  	"web.timers"
  ],
  	"core-js/web/url": [
  	"web.url",
  	"web.url.can-parse",
  	"web.url.parse",
  	"web.url.to-json",
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ],
  	"core-js/web/url-search-params": [
  	"web.url-search-params",
  	"web.url-search-params.delete",
  	"web.url-search-params.has",
  	"web.url-search-params.size"
  ]
  };

var entries$1;
  var hasRequiredEntries;
  function requireEntries() {
    if (hasRequiredEntries) return entries$1;
    hasRequiredEntries = 1;
    entries$1 = require$$0$3;
    return entries$1;
  }

var hasRequiredUtils$2;
  function requireUtils$2() {
    if (hasRequiredUtils$2) return utils$2;
    hasRequiredUtils$2 = 1;
    utils$2.__esModule = true;
    utils$2.BABEL_RUNTIME = void 0;
    utils$2.callMethod = callMethod;
    utils$2.coreJSModule = coreJSModule;
    utils$2.coreJSPureHelper = coreJSPureHelper;
    utils$2.isCoreJSSource = isCoreJSSource;
    var _babel = _interopRequireWildcard(require$$5);
    var _entries = _interopRequireDefault(requireEntries());
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    var _ref = _babel["default"] || _babel,
      t = _ref.types;
    var BABEL_RUNTIME = "@babel/runtime-corejs3";
    utils$2.BABEL_RUNTIME = BABEL_RUNTIME;
    function callMethod(path, id) {
      var object = path.node.object;
      var context1, context2;
      if (t.isIdentifier(object)) {
        context1 = object;
        context2 = t.cloneNode(object);
      } else {
        context1 = path.scope.generateDeclaredUidIdentifier("context");
        context2 = t.assignmentExpression("=", t.cloneNode(context1), object);
      }
      path.replaceWith(t.memberExpression(t.callExpression(id, [context2]), t.identifier("call")));
      path.parentPath.unshiftContainer("arguments", context1);
    }
    function isCoreJSSource(source) {
      if (typeof source === "string") {
        source = source.replace(/\\/g, "/").replace(/(\/(index)?)?(\.js)?$/i, "").toLowerCase();
      }
      return Object.prototype.hasOwnProperty.call(_entries["default"], source) && _entries["default"][source];
    }
    function coreJSModule(name) {
      return "core-js/modules/" + name + ".js";
    }
    function coreJSPureHelper(name, useBabelRuntime, ext) {
      return useBabelRuntime ? BABEL_RUNTIME + "/core-js/" + name + ext : "core-js-pure/features/" + name + ".js";
    }
    return utils$2;
  }

var hasRequiredLib$4;
  function requireLib$4() {
    if (hasRequiredLib$4) return lib$4;
    hasRequiredLib$4 = 1;
    lib$4.__esModule = true;
    lib$4["default"] = void 0;
    var _data = _interopRequireDefault(requireData());
    var _shippedProposals = _interopRequireDefault(requireShippedProposals());
    var _getModulesListForTargetVersion = _interopRequireDefault(requireGetModulesListForTargetVersion());
    var _builtInDefinitions = requireBuiltInDefinitions$1();
    var BabelRuntimePaths = _interopRequireWildcard(requireBabelRuntimeCorejs3Paths());
    var _usageFilters = _interopRequireDefault(requireUsageFilters());
    var _babel = _interopRequireWildcard(require$$5);
    var _utils = requireUtils$2();
    var _helperDefinePolyfillProvider = _interopRequireDefault(requireLib$6());
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    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);
    }
    var _ref = _babel["default"] || _babel,
      t = _ref.types;
    var presetEnvCompat = "#__secret_key__@babel/preset-env__compatibility";
    var runtimeCompat = "#__secret_key__@babel/runtime__compatibility";
    var uniqueObjects = ["array", "string", "iterator", "async-iterator", "dom-collections"].map(function (v) {
      return new RegExp("[a-z]*\\." + v + "\\..*");
    });
    var esnextFallback = function esnextFallback(name, cb) {
      if (cb(name)) return true;
      if (!name.startsWith("es.")) return false;
      var fallback = "esnext." + name.slice(3);
      if (!_data["default"][fallback]) return false;
      return cb(fallback);
    };
    var _default = (0, _helperDefinePolyfillProvider["default"])(function (_ref2, _ref3) {
      var getUtils = _ref2.getUtils,
        method = _ref2.method,
        shouldInjectPolyfill = _ref2.shouldInjectPolyfill,
        createMetaResolver = _ref2.createMetaResolver,
        debug = _ref2.debug,
        babel = _ref2.babel;
      var _ref3$version = _ref3.version,
        version = _ref3$version === void 0 ? 3 : _ref3$version,
        proposals = _ref3.proposals,
        shippedProposals = _ref3.shippedProposals,
        _ref3$presetEnvCompat = _ref3[presetEnvCompat],
        _ref3$presetEnvCompat2 = _ref3$presetEnvCompat === void 0 ? {} : _ref3$presetEnvCompat,
        _ref3$presetEnvCompat3 = _ref3$presetEnvCompat2.noRuntimeName,
        noRuntimeName = _ref3$presetEnvCompat3 === void 0 ? false : _ref3$presetEnvCompat3,
        _ref3$runtimeCompat = _ref3[runtimeCompat],
        _ref3$runtimeCompat2 = _ref3$runtimeCompat === void 0 ? {} : _ref3$runtimeCompat,
        _ref3$runtimeCompat2$ = _ref3$runtimeCompat2.useBabelRuntime,
        useBabelRuntime = _ref3$runtimeCompat2$ === void 0 ? false : _ref3$runtimeCompat2$,
        _ref3$runtimeCompat2$2 = _ref3$runtimeCompat2.ext,
        ext = _ref3$runtimeCompat2$2 === void 0 ? ".js" : _ref3$runtimeCompat2$2;
      var isWebpack = babel.caller(function (caller) {
        return (caller == null ? void 0 : caller.name) === "babel-loader";
      });
      var resolve = createMetaResolver({
        global: _builtInDefinitions.BuiltIns,
        "static": _builtInDefinitions.StaticProperties,
        instance: _builtInDefinitions.InstanceProperties
      });
      var available = new Set((0, _getModulesListForTargetVersion["default"])(version));
      function getCoreJSPureBase(useProposalBase) {
        return useBabelRuntime ? useProposalBase ? _utils.BABEL_RUNTIME + "/core-js" : _utils.BABEL_RUNTIME + "/core-js-stable" : useProposalBase ? "core-js-pure/features" : "core-js-pure/stable";
      }
      function maybeInjectGlobalImpl(name, utils) {
        if (shouldInjectPolyfill(name)) {
          debug(name);
          utils.injectGlobalImport((0, _utils.coreJSModule)(name), name);
          return true;
        }
        return false;
      }
      function maybeInjectGlobal(names, utils, fallback) {
        if (fallback === void 0) {
          fallback = true;
        }
        for (var _iterator = _createForOfIteratorHelperLoose(names), _step; !(_step = _iterator()).done;) {
          var name = _step.value;
          if (fallback) {
            esnextFallback(name, function (name) {
              return maybeInjectGlobalImpl(name, utils);
            });
          } else {
            maybeInjectGlobalImpl(name, utils);
          }
        }
      }
      function maybeInjectPure(desc, hint, utils, object) {
        if (desc.pure && !(object && desc.exclude && desc.exclude.includes(object)) && esnextFallback(desc.name, shouldInjectPolyfill)) {
          var name = desc.name;
          var useProposalBase = false;
          if (proposals || shippedProposals && name.startsWith("esnext.")) {
            useProposalBase = true;
          } else if (name.startsWith("es.") && !available.has(name)) {
            useProposalBase = true;
          }
          if (useBabelRuntime && !(useProposalBase ? BabelRuntimePaths.proposals : BabelRuntimePaths.stable).has(desc.pure)) {
            return;
          }
          var coreJSPureBase = getCoreJSPureBase(useProposalBase);
          return utils.injectDefaultImport(coreJSPureBase + "/" + desc.pure + ext, hint);
        }
      }
      function isFeatureStable(name) {
        if (name.startsWith("esnext.")) {
          var esName = "es." + name.slice(7);
          return esName in _data["default"];
        }
        return true;
      }
      return {
        name: "corejs3",
        runtimeName: noRuntimeName ? null : _utils.BABEL_RUNTIME,
        polyfills: _data["default"],
        filterPolyfills: function filterPolyfills(name) {
          if (!available.has(name)) return false;
          if (proposals || method === "entry-global") return true;
          if (shippedProposals && _shippedProposals["default"].has(name)) {
            return true;
          }
          return isFeatureStable(name);
        },
        entryGlobal: function entryGlobal(meta, utils, path) {
          if (meta.kind !== "import") return;
          var modules = (0, _utils.isCoreJSSource)(meta.source);
          if (!modules) return;
          if (modules.length === 1 && meta.source === (0, _utils.coreJSModule)(modules[0]) && shouldInjectPolyfill(modules[0])) {
            debug(null);
            return;
          }
          var modulesSet = new Set(modules);
          var filteredModules = modules.filter(function (module) {
            if (!module.startsWith("esnext.")) return true;
            var stable = module.replace("esnext.", "es.");
            if (modulesSet.has(stable) && shouldInjectPolyfill(stable)) {
              return false;
            }
            return true;
          });
          maybeInjectGlobal(filteredModules, utils, false);
          path.remove();
        },
        usageGlobal: function usageGlobal(meta, utils, path) {
          var resolved = resolve(meta);
          if (!resolved) return;
          if ((0, _usageFilters["default"])(resolved.desc, path)) return;
          var deps = resolved.desc.global;
          if (resolved.kind !== "global" && "object" in meta && meta.object && meta.placement === "prototype") {
            var low = meta.object.toLowerCase();
            deps = deps.filter(function (m) {
              return uniqueObjects.some(function (v) {
                return v.test(m);
              }) ? m.includes(low) : true;
            });
          }
          maybeInjectGlobal(deps, utils);
          return true;
        },
        usagePure: function usagePure(meta, utils, path) {
          if (meta.kind === "in") {
            if (meta.key === "Symbol.iterator") {
              path.replaceWith(t.callExpression(utils.injectDefaultImport((0, _utils.coreJSPureHelper)("is-iterable", useBabelRuntime, ext), "isIterable"), [path.node.right]));
            }
            return;
          }
          if (path.parentPath.isUnaryExpression({
            operator: "delete"
          })) return;
          if (meta.kind === "property") {
            if (!path.isMemberExpression()) return;
            if (!path.isReferenced()) return;
            if (path.parentPath.isUpdateExpression()) return;
            if (t.isSuper(path.node.object)) {
              return;
            }
            if (meta.key === "Symbol.iterator") {
              if (!shouldInjectPolyfill("es.symbol.iterator")) return;
              var parent = path.parent,
                node = path.node;
              if (t.isCallExpression(parent, {
                callee: node
              })) {
                if (parent.arguments.length === 0) {
                  path.parentPath.replaceWith(t.callExpression(utils.injectDefaultImport((0, _utils.coreJSPureHelper)("get-iterator", useBabelRuntime, ext), "getIterator"), [node.object]));
                  path.skip();
                } else {
                  (0, _utils.callMethod)(path, utils.injectDefaultImport((0, _utils.coreJSPureHelper)("get-iterator-method", useBabelRuntime, ext), "getIteratorMethod"));
                }
              } else {
                path.replaceWith(t.callExpression(utils.injectDefaultImport((0, _utils.coreJSPureHelper)("get-iterator-method", useBabelRuntime, ext), "getIteratorMethod"), [path.node.object]));
              }
              return;
            }
          }
          var resolved = resolve(meta);
          if (!resolved) return;
          if ((0, _usageFilters["default"])(resolved.desc, path)) return;
          if (useBabelRuntime && resolved.desc.pure && resolved.desc.pure.slice(-6) === "/index") {
            resolved = _extends({}, resolved, {
              desc: _extends({}, resolved.desc, {
                pure: resolved.desc.pure.slice(0, -6)
              })
            });
          }
          if (resolved.kind === "global") {
            var id = maybeInjectPure(resolved.desc, resolved.name, utils);
            if (id) path.replaceWith(id);
          } else if (resolved.kind === "static") {
            var _id = maybeInjectPure(resolved.desc, resolved.name, utils, meta.object);
            if (_id) path.replaceWith(_id);
          } else if (resolved.kind === "instance") {
            var _id2 = maybeInjectPure(resolved.desc, resolved.name + "InstanceProperty", utils, meta.object);
            if (!_id2) return;
            var _node = path.node;
            if (t.isCallExpression(path.parent, {
              callee: _node
            })) {
              (0, _utils.callMethod)(path, _id2);
            } else {
              path.replaceWith(t.callExpression(_id2, [_node.object]));
            }
          }
        },
        visitor: method === "usage-global" && {
          CallExpression: function CallExpression(path) {
            if (path.get("callee").isImport()) {
              var utils = getUtils(path);
              if (isWebpack) {
                maybeInjectGlobal(_builtInDefinitions.PromiseDependenciesWithIterators, utils);
              } else {
                maybeInjectGlobal(_builtInDefinitions.PromiseDependencies, utils);
              }
            }
          },
          Function: function Function(path) {
            if (path.node.async) {
              maybeInjectGlobal(_builtInDefinitions.PromiseDependencies, getUtils(path));
            }
          },
          "ForOfStatement|ArrayPattern": function ForOfStatementArrayPattern(path) {
            maybeInjectGlobal(_builtInDefinitions.CommonIterators, getUtils(path));
          },
          SpreadElement: function SpreadElement(path) {
            if (!path.parentPath.isObjectExpression()) {
              maybeInjectGlobal(_builtInDefinitions.CommonIterators, getUtils(path));
            }
          },
          YieldExpression: function YieldExpression(path) {
            if (path.node.delegate) {
              maybeInjectGlobal(_builtInDefinitions.CommonIterators, getUtils(path));
            }
          },
          Class: function Class(path) {
            var _path$node$decorators;
            var hasDecorators = ((_path$node$decorators = path.node.decorators) == null ? void 0 : _path$node$decorators.length) || path.node.body.body.some(function (el) {
              var _decorators;
              return (_decorators = el.decorators) == null ? void 0 : _decorators.length;
            });
            if (hasDecorators) {
              maybeInjectGlobal(_builtInDefinitions.DecoratorMetadataDependencies, getUtils(path));
            }
          }
        }
      };
    });
    lib$4["default"] = _default;
    return lib$4;
  }

var lib$3 = {};

var hasRequiredLib$3;
  function requireLib$3() {
    if (hasRequiredLib$3) return lib$3;
    hasRequiredLib$3 = 1;
    lib$3.__esModule = true;
    lib$3["default"] = void 0;
    var _helperDefinePolyfillProvider = _interopRequireDefault(requireLib$6());
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    var runtimeCompat = "#__secret_key__@babel/runtime__compatibility";
    var _default = (0, _helperDefinePolyfillProvider["default"])(function (_ref2, options) {
      var debug = _ref2.debug,
        targets = _ref2.targets,
        babel = _ref2.babel;
      if (!shallowEqual(targets, babel.targets())) {
        throw new Error("This plugin does not use the targets option. Only preset-env's targets" + " or top-level targets need to be configured for this plugin to work." + " See https://github.com/babel/babel-polyfills/issues/36 for more" + " details.");
      }
      var _options$runtimeCompa = options[runtimeCompat],
        _options$runtimeCompa2 = _options$runtimeCompa === void 0 ? {} : _options$runtimeCompa,
        _options$runtimeCompa3 = _options$runtimeCompa2.moduleName,
        moduleName = _options$runtimeCompa3 === void 0 ? null : _options$runtimeCompa3,
        _options$runtimeCompa4 = _options$runtimeCompa2.useBabelRuntime,
        useBabelRuntime = _options$runtimeCompa4 === void 0 ? false : _options$runtimeCompa4;
      return {
        name: "regenerator",
        polyfills: ["regenerator-runtime"],
        usageGlobal: function usageGlobal(meta, utils) {
          if (isRegenerator(meta)) {
            debug("regenerator-runtime");
            utils.injectGlobalImport("regenerator-runtime/runtime.js");
          }
        },
        usagePure: function usagePure(meta, utils, path) {
          if (isRegenerator(meta)) {
            var pureName = "regenerator-runtime";
            if (useBabelRuntime) {
              var _ref;
              var runtimeName = (_ref = moduleName != null ? moduleName : path.hub.file.get("runtimeHelpersModuleName")) != null ? _ref : "@babel/runtime";
              pureName = runtimeName + "/regenerator";
            }
            path.replaceWith(utils.injectDefaultImport(pureName, "regenerator-runtime"));
          }
        }
      };
    });
    lib$3["default"] = _default;
    var isRegenerator = function isRegenerator(meta) {
      return meta.kind === "global" && meta.name === "regeneratorRuntime";
    };
    function shallowEqual(obj1, obj2) {
      return JSON.stringify(obj1) === JSON.stringify(obj2);
    }
    return lib$3;
  }

var babelPluginPolyfillRegenerator$1;
  var hasRequiredBabelPluginPolyfillRegenerator$1;
  function requireBabelPluginPolyfillRegenerator$1() {
    if (hasRequiredBabelPluginPolyfillRegenerator$1) return babelPluginPolyfillRegenerator$1;
    hasRequiredBabelPluginPolyfillRegenerator$1 = 1;
    function bool(value) {
      if (value == null) return false;
      return value && value !== "false" && value !== "0";
    }
    babelPluginPolyfillRegenerator$1 = bool(browser$1$1.env["BABEL_8_BREAKING"]) ? null : requireLib$3();
    return babelPluginPolyfillRegenerator$1;
  }

var polyfills;
  var hasRequiredPolyfills;
  function requirePolyfills() {
    if (hasRequiredPolyfills) return polyfills;
    hasRequiredPolyfills = 1;
    var pluginCorejs2 = requireBabelPluginPolyfillCorejs2$1()["default"];
    var pluginCorejs3 = requireLib$4()["default"];
    var pluginRegenerator = requireBabelPluginPolyfillRegenerator$1()["default"];
    var pluginsCompat = "#__secret_key__@babel/runtime__compatibility";
    function createCorejs2Plugin(options) {
      return function (api, _, filename) {
        return pluginCorejs2(api, options, filename);
      };
    }
    function createCorejs3Plugin(options) {
      return function (api, _, filename) {
        return pluginCorejs3(api, options, filename);
      };
    }
    function createRegeneratorPlugin(options, useRuntimeRegenerator, corejsPlugin) {
      if (!useRuntimeRegenerator) return corejsPlugin != null ? corejsPlugin : undefined;
      return function (api, _, filename) {
        return Object.assign({}, pluginRegenerator(api, options, filename), {
          inherits: corejsPlugin != null ? corejsPlugin : undefined
        });
      };
    }
    polyfills = function createBasePolyfillsPlugin(_ref, runtimeVersion, absoluteImports) {
      var _polyfillOpts;
      var corejs = _ref.corejs,
        _ref$regenerator = _ref.regenerator,
        regenerator = _ref$regenerator === void 0 ? true : _ref$regenerator,
        moduleName = _ref.moduleName;
      var proposals = false;
      var rawVersion;
      if (typeof corejs === "object" && corejs !== null) {
        rawVersion = corejs.version;
        proposals = Boolean(corejs.proposals);
      } else {
        rawVersion = corejs;
      }
      var corejsVersion = rawVersion ? Number(rawVersion) : false;
      if (![false, 2, 3].includes(corejsVersion)) {
        throw new Error("The `core-js` version must be false, 2 or 3, but got " + JSON.stringify(rawVersion) + ".");
      }
      if (proposals && (!corejsVersion || corejsVersion < 3)) {
        throw new Error("The 'proposals' option is only supported when using 'corejs: 3'");
      }
      if (typeof regenerator !== "boolean") {
        throw new Error("The 'regenerator' option must be undefined, or a boolean.");
      }
      var polyfillOpts = (_polyfillOpts = {
        method: "usage-pure",
        absoluteImports: absoluteImports,
        proposals: proposals
      }, _polyfillOpts[pluginsCompat] = {
        useBabelRuntime: true,
        runtimeVersion: runtimeVersion,
        ext: "",
        moduleName: moduleName
      }, _polyfillOpts);
      return createRegeneratorPlugin(polyfillOpts, regenerator, corejsVersion === 2 ? createCorejs2Plugin(polyfillOpts) : corejsVersion === 3 ? createCorejs3Plugin(polyfillOpts) : null);
    };
    return polyfills;
  }

(function (exports) {
    Object.defineProperty(exports, "createPolyfillPlugins", {
      get: function get() {
        return requirePolyfills();
      }
    });
  })(babel7);

var _templateObject$9;
  var _transformSpread = declare(function (api, options) {
    var _api$assumption, _options$allowArrayLi;
    api.assertVersion("*");
    var iterableIsArray = (_api$assumption = api.assumption("iterableIsArray")) != null ? _api$assumption : options.loose;
    var arrayLikeIsIterable = (_options$allowArrayLi = options.allowArrayLike) != null ? _options$allowArrayLi : api.assumption("arrayLikeIsIterable");
    function getSpreadLiteral(spread, scope) {
      if (iterableIsArray && !isIdentifier$e(spread.argument, {
        name: "arguments"
      })) {
        return spread.argument;
      } else {
        var node = spread.argument;
        if (isIdentifier$e(node)) {
          var binding = scope.getBinding(node.name);
          if (binding != null && binding.constant && binding.path.isGenericType("Array")) {
            return node;
          }
        }
        if (isArrayExpression$2(node)) {
          return node;
        }
        if (isIdentifier$e(node, {
          name: "arguments"
        })) {
          return template$1.expression.ast(_templateObject$9 || (_templateObject$9 = _taggedTemplateLiteralLoose(["\n          Array.prototype.slice.call(", ")\n        "])), node);
        }
        var args = [node];
        var helperName = "toConsumableArray";
        if (arrayLikeIsIterable) {
          args.unshift(scope.path.hub.addHelper(helperName));
          helperName = "maybeArrayLike";
        }
        return callExpression$c(scope.path.hub.addHelper(helperName), args);
      }
    }
    function hasHole(spread) {
      return spread.elements.includes(null);
    }
    function hasSpread(nodes) {
      for (var i = 0; i < nodes.length; i++) {
        if (isSpreadElement$1(nodes[i])) {
          return true;
        }
      }
      return false;
    }
    function push(_props, nodes) {
      if (!_props.length) return _props;
      nodes.push(arrayExpression$1(_props));
      return [];
    }
    function build(props, scope, file) {
      var nodes = [];
      var _props = [];
      for (var _iterator = _createForOfIteratorHelperLoose(props), _step; !(_step = _iterator()).done;) {
        var prop = _step.value;
        if (isSpreadElement$1(prop)) {
          _props = push(_props, nodes);
          var spreadLiteral = getSpreadLiteral(prop, scope);
          if (isArrayExpression$2(spreadLiteral) && hasHole(spreadLiteral)) {
            spreadLiteral = callExpression$c(file.addHelper("arrayWithoutHoles"), [spreadLiteral]);
          }
          nodes.push(spreadLiteral);
        } else {
          _props.push(prop);
        }
      }
      push(_props, nodes);
      return nodes;
    }
    return {
      name: "transform-spread",
      visitor: {
        ArrayExpression: function ArrayExpression(path) {
          var node = path.node,
            scope = path.scope;
          var elements = node.elements;
          if (!hasSpread(elements)) return;
          var nodes = build(elements, scope, this.file);
          var first = nodes[0];
          if (nodes.length === 1 && first !== elements[0].argument) {
            path.replaceWith(first);
            return;
          }
          if (!isArrayExpression$2(first)) {
            first = arrayExpression$1([]);
          } else {
            nodes.shift();
          }
          path.replaceWith(callExpression$c(memberExpression$9(first, identifier$d("concat")), nodes));
        },
        CallExpression: function CallExpression(path) {
          var node = path.node,
            scope = path.scope;
          var args = node.arguments;
          if (!hasSpread(args)) return;
          var calleePath = skipTransparentExprWrappers(path.get("callee"));
          if (calleePath.isSuper()) {
            throw path.buildCodeFrameError("It's not possible to compile spread arguments in `super()` without compiling classes.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
          }
          var contextLiteral = scope.buildUndefinedNode();
          node.arguments = [];
          var nodes;
          if (args.length === 1 && isIdentifier$e(args[0].argument, {
            name: "arguments"
          })) {
            nodes = [args[0].argument];
          } else {
            nodes = build(args, scope, this.file);
          }
          var first = nodes.shift();
          if (nodes.length) {
            node.arguments.push(callExpression$c(memberExpression$9(first, identifier$d("concat")), nodes));
          } else {
            node.arguments.push(first);
          }
          var callee = calleePath.node;
          if (isMemberExpression$7(callee)) {
            var temp = scope.maybeGenerateMemoised(callee.object);
            if (temp) {
              callee.object = assignmentExpression$8("=", temp, callee.object);
              contextLiteral = temp;
            } else {
              contextLiteral = cloneNode$e(callee.object);
            }
          }
          node.callee = memberExpression$9(node.callee, identifier$d("apply"));
          if (isSuper$2(contextLiteral)) {
            contextLiteral = thisExpression$4();
          }
          node.arguments.unshift(cloneNode$e(contextLiteral));
        },
        NewExpression: function NewExpression(path) {
          var node = path.node,
            scope = path.scope;
          if (!hasSpread(node.arguments)) return;
          var nodes = build(node.arguments, scope, this.file);
          var first = nodes.shift();
          var args;
          if (nodes.length) {
            args = callExpression$c(memberExpression$9(first, identifier$d("concat")), nodes);
          } else {
            args = first;
          }
          path.replaceWith(callExpression$c(path.hub.addHelper("construct"), [node.callee, args]));
        }
      }
    };
  });

var _templateObject$8;
  var _transformTemplateLiterals = declare(function (api, options) {
    var _api$assumption, _api$assumption2;
    api.assertVersion("*");
    var ignoreToPrimitiveHint = (_api$assumption = api.assumption("ignoreToPrimitiveHint")) != null ? _api$assumption : options.loose;
    var mutableTemplateObject = (_api$assumption2 = api.assumption("mutableTemplateObject")) != null ? _api$assumption2 : options.loose;
    var helperName = "taggedTemplateLiteral";
    if (mutableTemplateObject) helperName += "Loose";
    function buildConcatCallExpressions(items) {
      var avail = true;
      return items.reduce(function (left, right) {
        var canBeInserted = isLiteral$4(right);
        if (!canBeInserted && avail) {
          canBeInserted = true;
          avail = false;
        }
        if (canBeInserted && isCallExpression$8(left)) {
          left.arguments.push(right);
          return left;
        }
        return callExpression$c(memberExpression$9(left, identifier$d("concat")), [right]);
      });
    }
    return {
      name: "transform-template-literals",
      visitor: {
        TaggedTemplateExpression: function TaggedTemplateExpression(path) {
          var node = path.node;
          var quasi = node.quasi;
          var strings = [];
          var raws = [];
          var isStringsRawEqual = true;
          for (var _iterator = _createForOfIteratorHelperLoose(quasi.quasis), _step; !(_step = _iterator()).done;) {
            var elem = _step.value;
            var _elem$value = elem.value,
              raw = _elem$value.raw,
              cooked = _elem$value.cooked;
            var value = cooked == null ? path.scope.buildUndefinedNode() : stringLiteral$6(cooked);
            strings.push(value);
            raws.push(stringLiteral$6(raw));
            if (raw !== cooked) {
              isStringsRawEqual = false;
            }
          }
          var helperArgs = [arrayExpression$1(strings)];
          if (!isStringsRawEqual) {
            helperArgs.push(arrayExpression$1(raws));
          }
          var tmp = path.scope.generateUidIdentifier("templateObject");
          path.scope.getProgramParent().push({
            id: cloneNode$e(tmp)
          });
          path.replaceWith(callExpression$c(node.tag, [template$1.expression.ast(_templateObject$8 || (_templateObject$8 = _taggedTemplateLiteralLoose(["\n              ", " || (\n                ", " = ", "(", ")\n              )\n            "])), cloneNode$e(tmp), tmp, this.addHelper(helperName), helperArgs)].concat(_toConsumableArray(quasi.expressions))));
        },
        TemplateLiteral: function TemplateLiteral(path) {
          if (path.parent.type === "TSLiteralType") {
            return;
          }
          var nodes = [];
          var expressions = path.get("expressions");
          var index = 0;
          for (var _iterator2 = _createForOfIteratorHelperLoose(path.node.quasis), _step2; !(_step2 = _iterator2()).done;) {
            var elem = _step2.value;
            if (elem.value.cooked) {
              nodes.push(stringLiteral$6(elem.value.cooked));
            }
            if (index < expressions.length) {
              var expr = expressions[index++];
              var node = expr.node;
              if (!isStringLiteral$5(node, {
                value: ""
              })) {
                nodes.push(node);
              }
            }
          }
          if (!isStringLiteral$5(nodes[0]) && !(ignoreToPrimitiveHint && isStringLiteral$5(nodes[1]))) {
            nodes.unshift(stringLiteral$6(""));
          }
          var root = nodes[0];
          if (ignoreToPrimitiveHint) {
            for (var i = 1; i < nodes.length; i++) {
              root = binaryExpression$4("+", root, nodes[i]);
            }
          } else if (nodes.length > 1) {
            root = buildConcatCallExpressions(nodes);
          }
          path.replaceWith(root);
        }
      }
    };
  });

var GLOBAL_TYPES = new WeakMap();
  function isGlobalType(_ref, name) {
    var scope = _ref.scope;
    if (scope.hasBinding(name)) return false;
    if (GLOBAL_TYPES.get(scope).has(name)) return true;
    console.warn("The exported identifier \"" + name + "\" is not declared in Babel's scope tracker\n" + "as a JavaScript value binding, and \"@babel/plugin-transform-typescript\"\n" + "never encountered it as a TypeScript type declaration.\n" + "It will be treated as a JavaScript value.\n\n" + "This problem is likely caused by another plugin injecting\n" + ("\"" + name + "\" without registering it in the scope tracker. If you are the author\n") + " of that plugin, please use \"scope.registerDeclaration(declarationPath)\".");
    return false;
  }
  function registerGlobalType(programScope, name) {
    GLOBAL_TYPES.get(programScope).add(name);
  }

var _templateObject$7, _templateObject2$6;
  function getFirstIdentifier(node) {
    if (isIdentifier$e(node)) {
      return node;
    }
    return getFirstIdentifier(node.left);
  }
  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");
    }
    var name = getFirstIdentifier(path.node.id).name;
    var value = handleNested(path, path.node);
    if (value === null) {
      var program = path.findParent(function (p) {
        return p.isProgram();
      });
      registerGlobalType(program.scope, name);
      path.remove();
    } else if (path.scope.hasOwnBinding(name)) {
      path.replaceWith(value);
    } else {
      path.scope.registerDeclaration(path.replaceWithMultiple([getDeclaration(name), value])[0]);
    }
  }
  function getDeclaration(name) {
    return variableDeclaration$6("let", [variableDeclarator$6(identifier$d(name))]);
  }
  function getMemberExpression(name, itemName) {
    return memberExpression$9(identifier$d(name), identifier$d(itemName));
  }
  function handleVariableDeclaration(node, name, hub) {
    if (node.kind !== "const") {
      throw hub.file.buildCodeFrameError(node, "Namespaces exporting non-const are not supported by Babel." + " Change to const or see:" + " https://babeljs.io/docs/en/babel-plugin-transform-typescript");
    }
    var declarations = node.declarations;
    if (declarations.every(function (declarator) {
      return isIdentifier$e(declarator.id);
    })) {
      for (var _iterator = _createForOfIteratorHelperLoose(declarations), _step; !(_step = _iterator()).done;) {
        var declarator = _step.value;
        declarator.init = assignmentExpression$8("=", getMemberExpression(name, declarator.id.name), declarator.init);
      }
      return [node];
    }
    var bindingIdentifiers = getBindingIdentifiers$4(node);
    var assignments = [];
    for (var idName in bindingIdentifiers) {
      assignments.push(assignmentExpression$8("=", getMemberExpression(name, idName), cloneNode$e(bindingIdentifiers[idName])));
    }
    return [node, expressionStatement$7(sequenceExpression$6(assignments))];
  }
  function buildNestedAmbientModuleError(path, node) {
    return path.hub.buildError(node, "Ambient modules cannot be nested in other modules or namespaces.", Error);
  }
  function handleNested(path, node, parentExport) {
    var names = new Set();
    var realName = node.id;
    var name = path.scope.generateUid(realName.name);
    var body = node.body;
    node.id;
    var namespaceTopLevel;
    {
      namespaceTopLevel = isTSModuleBlock(body) ? body.body : [exportNamedDeclaration$2(body)];
    }
    var isEmpty = true;
    for (var i = 0; i < namespaceTopLevel.length; i++) {
      var subNode = namespaceTopLevel[i];
      switch (subNode.type) {
        case "TSModuleDeclaration":
          {
            if (!isIdentifier$e(subNode.id)) {
              throw buildNestedAmbientModuleError(path, subNode);
            }
            var transformed = handleNested(path, subNode);
            if (transformed !== null) {
              isEmpty = false;
              var 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":
          isEmpty = false;
          names.add(subNode.id.name);
          continue;
        case "VariableDeclaration":
          {
            isEmpty = false;
            for (var _name in getBindingIdentifiers$4(subNode)) {
              names.add(_name);
            }
            continue;
          }
        default:
          isEmpty && (isEmpty = isTypeScript(subNode));
          continue;
        case "ExportNamedDeclaration":
      }
      if ("declare" in subNode.declaration && subNode.declaration.declare) {
        continue;
      }
      switch (subNode.declaration.type) {
        case "TSEnumDeclaration":
          EXPORTED_CONST_ENUMS_IN_NAMESPACE.add(subNode.declaration);
        case "FunctionDeclaration":
        case "ClassDeclaration":
          {
            isEmpty = false;
            var itemName = subNode.declaration.id.name;
            names.add(itemName);
            namespaceTopLevel.splice(i++, 1, subNode.declaration, expressionStatement$7(assignmentExpression$8("=", getMemberExpression(name, itemName), identifier$d(itemName))));
            break;
          }
        case "VariableDeclaration":
          {
            var _namespaceTopLevel;
            isEmpty = false;
            var nodes = handleVariableDeclaration(subNode.declaration, name, path.hub);
            (_namespaceTopLevel = namespaceTopLevel).splice.apply(_namespaceTopLevel, [i, nodes.length].concat(_toConsumableArray(nodes)));
            i += nodes.length - 1;
            break;
          }
        case "TSModuleDeclaration":
          {
            if (!isIdentifier$e(subNode.declaration.id)) {
              throw buildNestedAmbientModuleError(path, subNode.declaration);
            }
            var _transformed = handleNested(path, subNode.declaration, identifier$d(name));
            if (_transformed !== null) {
              isEmpty = false;
              var _moduleName = subNode.declaration.id.name;
              if (names.has(_moduleName)) {
                namespaceTopLevel[i] = _transformed;
              } else {
                names.add(_moduleName);
                namespaceTopLevel.splice(i++, 1, getDeclaration(_moduleName), _transformed);
              }
            } else {
              namespaceTopLevel.splice(i, 1);
              i--;
            }
          }
      }
    }
    if (isEmpty) return null;
    var fallthroughValue = objectExpression$3([]);
    if (parentExport) {
      var memberExpr = memberExpression$9(parentExport, realName);
      fallthroughValue = template$1.expression.ast(_templateObject$7 || (_templateObject$7 = _taggedTemplateLiteralLoose(["\n      ", " ||\n        (", " = ", ")\n    "])), cloneNode$e(memberExpr), cloneNode$e(memberExpr), fallthroughValue);
    }
    return template$1.statement.ast(_templateObject2$6 || (_templateObject2$6 = _taggedTemplateLiteralLoose(["\n    (function (", ") {\n      ", "\n    })(", " || (", " = ", "));\n  "])), identifier$d(name), namespaceTopLevel, realName, cloneNode$e(realName), fallthroughValue);
  }

var _templateObject$6, _templateObject2$5;
  function isInType(path) {
    switch (path.parent.type) {
      case "TSTypeReference":
      case "TSExpressionWithTypeArguments":
      case "TSExpressionWithTypeArguments":
      case "TSTypeQuery":
        return true;
      case "TSQualifiedName":
        return (path.parentPath.findParent(function (path) {
            return path.type !== "TSQualifiedName";
          }).type !== "TSImportEqualsDeclaration"
        );
      case "ExportSpecifier":
        return (path.parent.exportKind === "type" || path.parentPath.parent.exportKind === "type"
        );
      default:
        return false;
    }
  }
  var NEEDS_EXPLICIT_ESM = new WeakMap();
  var PARSED_PARAMS = new WeakSet();
  function safeRemove(path) {
    var ids = path.getBindingIdentifiers();
    for (var _i = 0, _Object$keys = Object.keys(ids); _i < _Object$keys.length; _i++) {
      var name = _Object$keys[_i];
      var binding = path.scope.getBinding(name);
      if (binding && binding.identifier === ids[name]) {
        binding.scope.removeBinding(name);
      }
    }
    path.opts.noScope = true;
    path.remove();
    path.opts.noScope = false;
  }
  function assertCjsTransformEnabled(path, pass, wrong, suggestion, extra) {
    if (extra === void 0) {
      extra = "";
    }
    if (pass.file.get("@babel/plugin-transform-modules-*") !== "commonjs") {
      throw path.buildCodeFrameError("`" + wrong + "` is only supported when compiling modules to CommonJS.\n" + ("Please consider using `" + suggestion + "`" + extra + ", or add ") + "@babel/plugin-transform-modules-commonjs to your Babel config.");
    }
  }
  var transformTypeScript = declare(function (api, opts) {
    var _visitor;
    var t = api.types,
      template = api.template;
    api.assertVersion("*");
    var JSX_PRAGMA_REGEX = /\*?\s*@jsx((?:Frag)?)\s+(\S+)/;
    var _opts$allowNamespaces = opts.allowNamespaces,
      allowNamespaces = _opts$allowNamespaces === void 0 ? true : _opts$allowNamespaces,
      _opts$jsxPragma = opts.jsxPragma,
      jsxPragma = _opts$jsxPragma === void 0 ? "React.createElement" : _opts$jsxPragma,
      _opts$jsxPragmaFrag = opts.jsxPragmaFrag,
      jsxPragmaFrag = _opts$jsxPragmaFrag === void 0 ? "React.Fragment" : _opts$jsxPragmaFrag,
      _opts$onlyRemoveTypeI = opts.onlyRemoveTypeImports,
      onlyRemoveTypeImports = _opts$onlyRemoveTypeI === void 0 ? false : _opts$onlyRemoveTypeI,
      _opts$optimizeConstEn = opts.optimizeConstEnums,
      optimizeConstEnums = _opts$optimizeConstEn === void 0 ? false : _opts$optimizeConstEn;
    {
      var _opts$allowDeclareFie = opts.allowDeclareFields,
        allowDeclareFields = _opts$allowDeclareFie === void 0 ? false : _opts$allowDeclareFie;
    }
    var classMemberVisitors = {
      field: function field(path) {
        var node = path.node;
        {
          if (!allowDeclareFields && node.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 (node.declare) {
          if (node.value) {
            throw path.buildCodeFrameError("Fields with the 'declare' modifier cannot be initialized here, but only in the constructor");
          }
          if (!node.decorators) {
            path.remove();
          }
        } else if (node.definite) {
          if (node.value) {
            throw path.buildCodeFrameError("Definitely assigned fields cannot be initialized here, but only in the constructor");
          }
          {
            if (!allowDeclareFields && !node.decorators && !t.isClassPrivateProperty(node)) {
              path.remove();
            }
          }
        } else if (node["abstract"]) {
          path.remove();
        } else {
          if (!allowDeclareFields && !node.value && !node.decorators && !t.isClassPrivateProperty(node)) {
            path.remove();
          }
        }
        if (node.accessibility) node.accessibility = null;
        if (node["abstract"]) node["abstract"] = null;
        if (node.readonly) node.readonly = null;
        if (node.optional) node.optional = null;
        if (node.typeAnnotation) node.typeAnnotation = null;
        if (node.definite) node.definite = null;
        if (node.declare) node.declare = null;
        if (node.override) node.override = null;
      },
      method: function method(_ref) {
        var node = _ref.node;
        if (node.accessibility) node.accessibility = null;
        if (node["abstract"]) node["abstract"] = null;
        if (node.optional) node.optional = null;
        if (node.override) node.override = null;
      },
      constructor: function constructor(path, classPath) {
        if (path.node.accessibility) path.node.accessibility = null;
        var assigns = [];
        var scope = path.scope;
        for (var _iterator = _createForOfIteratorHelperLoose(path.get("params")), _step; !(_step = _iterator()).done;) {
          var paramPath = _step.value;
          var param = paramPath.node;
          if (param.type === "TSParameterProperty") {
            var parameter = param.parameter;
            if (PARSED_PARAMS.has(parameter)) continue;
            PARSED_PARAMS.add(parameter);
            var id = void 0;
            if (t.isIdentifier(parameter)) {
              id = parameter;
            } else if (t.isAssignmentPattern(parameter) && t.isIdentifier(parameter.left)) {
              id = parameter.left;
            } else {
              throw paramPath.buildCodeFrameError("Parameter properties can not be destructuring patterns.");
            }
            assigns.push(template.statement.ast(_templateObject$6 || (_templateObject$6 = _taggedTemplateLiteralLoose(["\n              this.", " = ", "\n            "])), t.cloneNode(id), t.cloneNode(id)));
            paramPath.replaceWith(paramPath.get("parameter"));
            scope.registerBinding("param", paramPath);
          }
        }
        injectInitialization(classPath, path, assigns);
      }
    };
    return {
      name: "transform-typescript",
      inherits: syntaxTypescript,
      visitor: (_visitor = {
        Pattern: visitPattern,
        Identifier: visitPattern,
        RestElement: visitPattern,
        Program: {
          enter: function enter(path, state) {
            var file = state.file;
            var fileJsxPragma = null;
            var fileJsxPragmaFrag = null;
            var programScope = path.scope;
            if (!GLOBAL_TYPES.has(programScope)) {
              GLOBAL_TYPES.set(programScope, new Set());
            }
            if (file.ast.comments) {
              for (var _iterator2 = _createForOfIteratorHelperLoose(file.ast.comments), _step2; !(_step2 = _iterator2()).done;) {
                var comment = _step2.value;
                var jsxMatches = JSX_PRAGMA_REGEX.exec(comment.value);
                if (jsxMatches) {
                  if (jsxMatches[1]) {
                    fileJsxPragmaFrag = jsxMatches[2];
                  } else {
                    fileJsxPragma = jsxMatches[2];
                  }
                }
              }
            }
            var pragmaImportName = fileJsxPragma || jsxPragma;
            if (pragmaImportName) {
              var _pragmaImportName$spl = pragmaImportName.split(".");
              var _pragmaImportName$spl2 = _slicedToArray(_pragmaImportName$spl, 1);
              pragmaImportName = _pragmaImportName$spl2[0];
            }
            var pragmaFragImportName = fileJsxPragmaFrag || jsxPragmaFrag;
            if (pragmaFragImportName) {
              var _pragmaFragImportName = pragmaFragImportName.split(".");
              var _pragmaFragImportName2 = _slicedToArray(_pragmaFragImportName, 1);
              pragmaFragImportName = _pragmaFragImportName2[0];
            }
            var _loop = function _loop() {
                var stmt = _step3.value;
                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 (var _iterator4 = _createForOfIteratorHelperLoose(stmt.node.specifiers), _step4; !(_step4 = _iterator4()).done;) {
                      var specifier = _step4.value;
                      registerGlobalType(programScope, specifier.local.name);
                    }
                    stmt.remove();
                    return 0;
                  }
                  var importsToRemove = new Set();
                  var specifiersLength = stmt.node.specifiers.length;
                  var isAllSpecifiersElided = function isAllSpecifiersElided() {
                    return specifiersLength > 0 && specifiersLength === importsToRemove.size;
                  };
                  for (var _iterator5 = _createForOfIteratorHelperLoose(stmt.node.specifiers), _step5; !(_step5 = _iterator5()).done;) {
                    var _specifier2 = _step5.value;
                    if (_specifier2.type === "ImportSpecifier" && _specifier2.importKind === "type") {
                      registerGlobalType(programScope, _specifier2.local.name);
                      var _binding = stmt.scope.getBinding(_specifier2.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);
                      return 0;
                    }
                    for (var _iterator6 = _createForOfIteratorHelperLoose(stmt.node.specifiers), _step6; !(_step6 = _iterator6()).done;) {
                      var _specifier = _step6.value;
                      var binding = stmt.scope.getBinding(_specifier.local.name);
                      if (binding && !importsToRemove.has(binding.path)) {
                        if (isImportTypeOnly({
                          binding: binding,
                          programPath: path,
                          pragmaImportName: pragmaImportName,
                          pragmaFragImportName: pragmaFragImportName
                        })) {
                          importsToRemove.add(binding.path);
                        } else {
                          NEEDS_EXPLICIT_ESM.set(path.node, false);
                        }
                      }
                    }
                  }
                  if (isAllSpecifiersElided() && !onlyRemoveTypeImports) {
                    stmt.remove();
                  } else {
                    for (var _iterator7 = _createForOfIteratorHelperLoose(importsToRemove), _step7; !(_step7 = _iterator7()).done;) {
                      var importPath = _step7.value;
                      importPath.remove();
                    }
                  }
                  return 0;
                }
                if (!onlyRemoveTypeImports && stmt.isTSImportEqualsDeclaration()) {
                  var _stmt$node = stmt.node,
                    id = _stmt$node.id,
                    isExport = _stmt$node.isExport;
                  var _binding2 = stmt.scope.getBinding(id.name);
                  if (_binding2 && !isExport && isImportTypeOnly({
                    binding: _binding2,
                    programPath: path,
                    pragmaImportName: pragmaImportName,
                    pragmaFragImportName: pragmaFragImportName
                  })) {
                    stmt.remove();
                    return 0;
                  }
                }
                if (stmt.isExportDeclaration()) {
                  stmt = stmt.get("declaration");
                }
                if (stmt.isVariableDeclaration({
                  declare: true
                })) {
                  for (var _i2 = 0, _Object$keys2 = Object.keys(stmt.getBindingIdentifiers()); _i2 < _Object$keys2.length; _i2++) {
                    var name = _Object$keys2[_i2];
                    registerGlobalType(programScope, name);
                  }
                } 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);
                }
              },
              _ret;
            for (var _iterator3 = _createForOfIteratorHelperLoose(path.get("body")), _step3; !(_step3 = _iterator3()).done;) {
              _ret = _loop();
              if (_ret === 0) continue;
            }
          },
          exit: function exit(path) {
            if (path.node.sourceType === "module" && NEEDS_EXPLICIT_ESM.get(path.node)) {
              path.pushContainer("body", t.exportNamedDeclaration());
            }
          }
        },
        ExportNamedDeclaration: function 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(function (specifier) {
            return specifier.type === "ExportSpecifier" && specifier.exportKind === "type";
          })) {
            path.remove();
            return;
          }
          if (!path.node.source && path.node.specifiers.length > 0 && path.node.specifiers.every(function (specifier) {
            return t.isExportSpecifier(specifier) && isGlobalType(path, specifier.local.name);
          })) {
            path.remove();
            return;
          }
          if (t.isTSModuleDeclaration(path.node.declaration)) {
            var namespace = path.node.declaration;
            if (!t.isStringLiteral(namespace.id)) {
              var id = getFirstIdentifier(namespace.id);
              if (path.scope.hasOwnBinding(id.name)) {
                path.replaceWith(namespace);
              } else {
                var _path$replaceWithMult = path.replaceWithMultiple([t.exportNamedDeclaration(t.variableDeclaration("let", [t.variableDeclarator(t.cloneNode(id))])), namespace]),
                  _path$replaceWithMult2 = _slicedToArray(_path$replaceWithMult, 1),
                  newExport = _path$replaceWithMult2[0];
                path.scope.registerDeclaration(newExport);
              }
            }
          }
          NEEDS_EXPLICIT_ESM.set(state.file.ast.program, false);
        },
        ExportAllDeclaration: function ExportAllDeclaration(path) {
          if (path.node.exportKind === "type") path.remove();
        },
        ExportSpecifier: function ExportSpecifier(path) {
          var parent = path.parent;
          if (!parent.source && isGlobalType(path, path.node.local.name) || path.node.exportKind === "type") {
            path.remove();
          }
        },
        ExportDefaultDeclaration: function ExportDefaultDeclaration(path, state) {
          if (!NEEDS_EXPLICIT_ESM.has(state.file.ast.program)) {
            NEEDS_EXPLICIT_ESM.set(state.file.ast.program, true);
          }
          if (t.isIdentifier(path.node.declaration) && isGlobalType(path, path.node.declaration.name)) {
            path.remove();
            return;
          }
          NEEDS_EXPLICIT_ESM.set(state.file.ast.program, false);
        },
        TSDeclareFunction: function TSDeclareFunction(path) {
          safeRemove(path);
        },
        TSDeclareMethod: function TSDeclareMethod(path) {
          safeRemove(path);
        },
        VariableDeclaration: function VariableDeclaration(path) {
          if (path.node.declare) {
            safeRemove(path);
          }
        },
        VariableDeclarator: function VariableDeclarator(_ref2) {
          var node = _ref2.node;
          if (node.definite) node.definite = null;
        },
        TSIndexSignature: function TSIndexSignature(path) {
          path.remove();
        },
        ClassDeclaration: function ClassDeclaration(path) {
          var node = path.node;
          if (node.declare) {
            safeRemove(path);
          }
        },
        Class: function Class(path) {
          var node = path.node;
          if (node.typeParameters) node.typeParameters = null;
          {
            if (node.superTypeParameters) node.superTypeParameters = null;
          }
          if (node["implements"]) node["implements"] = null;
          if (node["abstract"]) node["abstract"] = null;
          path.get("body.body").forEach(function (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: function Function(path) {
          var node = path.node;
          if (node.typeParameters) node.typeParameters = null;
          if (node.returnType) node.returnType = null;
          var params = node.params;
          if (params.length > 0 && t.isIdentifier(params[0], {
            name: "this"
          })) {
            params.shift();
          }
        },
        TSModuleDeclaration: function TSModuleDeclaration(path) {
          transpileNamespace(path, allowNamespaces);
        },
        TSInterfaceDeclaration: function TSInterfaceDeclaration(path) {
          path.remove();
        },
        TSTypeAliasDeclaration: function TSTypeAliasDeclaration(path) {
          path.remove();
        },
        TSEnumDeclaration: function TSEnumDeclaration(path) {
          if (optimizeConstEnums && path.node["const"]) {
            transpileConstEnum(path, t);
          } else {
            transpileEnum(path, t);
          }
        },
        TSImportEqualsDeclaration: function TSImportEqualsDeclaration(path, pass) {
          var _path$node = path.node,
            id = _path$node.id,
            moduleReference = _path$node.moduleReference,
            isExport = _path$node.isExport;
          var init;
          var varKind;
          if (t.isTSExternalModuleReference(moduleReference)) {
            assertCjsTransformEnabled(path, pass, "import " + id.name + " = require(...);", "import " + id.name + " from '...';", " alongside Typescript's --allowSyntheticDefaultImports option");
            init = t.callExpression(t.identifier("require"), [moduleReference.expression]);
            varKind = "const";
          } else {
            init = entityNameToExpr(moduleReference);
            varKind = "var";
          }
          var newNode = t.variableDeclaration(varKind, [t.variableDeclarator(id, init)]);
          path.replaceWith(isExport ? t.exportNamedDeclaration(newNode) : newNode);
          path.scope.registerDeclaration(path);
        },
        TSExportAssignment: function TSExportAssignment(path, pass) {
          assertCjsTransformEnabled(path, pass, "export = <value>;", "export default <value>;");
          path.replaceWith(template.statement.ast(_templateObject2$5 || (_templateObject2$5 = _taggedTemplateLiteralLoose(["module.exports = ", ""])), path.node.expression));
        },
        TSTypeAssertion: function TSTypeAssertion(path) {
          path.replaceWith(path.node.expression);
        }
      }, _visitor["TSAsExpression" + (t.tsSatisfiesExpression ? "|TSSatisfiesExpression" : "")] = function TSAsExpression(path) {
        var node = path.node;
        do {
          node = node.expression;
        } while (t.isTSAsExpression(node) || t.isTSSatisfiesExpression != null && t.isTSSatisfiesExpression(node));
        path.replaceWith(node);
      }, _visitor[api.types.tsInstantiationExpression ? "TSNonNullExpression|TSInstantiationExpression" : "TSNonNullExpression"] = function (path) {
        path.replaceWith(path.node.expression);
      }, _visitor.CallExpression = function CallExpression(path) {
        {
          path.node.typeParameters = null;
        }
      }, _visitor.OptionalCallExpression = function OptionalCallExpression(path) {
        {
          path.node.typeParameters = null;
        }
      }, _visitor.NewExpression = function NewExpression(path) {
        {
          path.node.typeParameters = null;
        }
      }, _visitor.JSXOpeningElement = function JSXOpeningElement(path) {
        {
          path.node.typeParameters = null;
        }
      }, _visitor.TaggedTemplateExpression = function TaggedTemplateExpression(path) {
        {
          path.node.typeParameters = null;
        }
      }, _visitor)
    };
    function entityNameToExpr(node) {
      if (t.isTSQualifiedName(node)) {
        return t.memberExpression(entityNameToExpr(node.left), node.right);
      }
      return node;
    }
    function visitPattern(_ref3) {
      var node = _ref3.node;
      if (node.typeAnnotation) node.typeAnnotation = null;
      if (t.isIdentifier(node) && node.optional) node.optional = null;
    }
    function isImportTypeOnly(_ref4) {
      var binding = _ref4.binding,
        programPath = _ref4.programPath,
        pragmaImportName = _ref4.pragmaImportName,
        pragmaFragImportName = _ref4.pragmaFragImportName;
      for (var _iterator8 = _createForOfIteratorHelperLoose(binding.referencePaths), _step8; !(_step8 = _iterator8()).done;) {
        var path = _step8.value;
        if (!isInType(path)) {
          return false;
        }
      }
      if (binding.identifier.name !== pragmaImportName && binding.identifier.name !== pragmaFragImportName) {
        return true;
      }
      var sourceFileHasJsx = false;
      programPath.traverse({
        "JSXElement|JSXFragment": function JSXElementJSXFragment(path) {
          sourceFileHasJsx = true;
          path.stop();
        }
      });
      return !sourceFileHasJsx;
    }
  });

var _transformUnicodeRegex = declare(function (api) {
    api.assertVersion("*");
    return createRegExpFeaturePlugin({
      name: "transform-unicode-regex",
      feature: "unicodeFlag"
    });
  });

var _templateObject$5, _templateObject2$4, _templateObject3$3;
  var proposalExplicitResourceManagement = declare(function (api) {
    api.assertVersion("*");
    var TOP_LEVEL_USING = new Map();
    function isUsingDeclaration(node) {
      if (!isVariableDeclaration$3(node)) return false;
      return node.kind === "using" || node.kind === "await using" || TOP_LEVEL_USING.has(node);
    }
    var transformUsingDeclarationsVisitor = {
      ForOfStatement: function ForOfStatement(path) {
        var left = path.node.left;
        if (!isUsingDeclaration(left)) return;
        var id = left.declarations[0].id;
        var tmpId = path.scope.generateUidIdentifierBasedOnNode(id);
        left.declarations[0].id = tmpId;
        left.kind = "const";
        path.ensureBlock();
        path.node.body.body.unshift(variableDeclaration$6("using", [variableDeclarator$6(id, cloneNode$e(tmpId))]));
      },
      "BlockStatement|StaticBlock": function BlockStatementStaticBlock(path, state) {
        if (state.availableHelper("usingCtx")) {
          var ctx = null;
          var needsAwait = false;
          for (var _iterator = _createForOfIteratorHelperLoose(path.node.body), _step; !(_step = _iterator()).done;) {
            var _ctx;
            var node = _step.value;
            if (!isUsingDeclaration(node)) continue;
            (_ctx = ctx) != null ? _ctx : ctx = path.scope.generateUidIdentifier("usingCtx");
            var isAwaitUsing = node.kind === "await using" || TOP_LEVEL_USING.get(node) === 1;
            needsAwait || (needsAwait = isAwaitUsing);
            if (!TOP_LEVEL_USING["delete"](node)) {
              node.kind = "const";
            }
            for (var _iterator2 = _createForOfIteratorHelperLoose(node.declarations), _step2; !(_step2 = _iterator2()).done;) {
              var decl = _step2.value;
              decl.init = callExpression$c(memberExpression$9(cloneNode$e(ctx), isAwaitUsing ? identifier$d("a") : identifier$d("u")), [decl.init]);
            }
          }
          if (!ctx) return;
          var disposeCall = callExpression$c(memberExpression$9(cloneNode$e(ctx), identifier$d("d")), []);
          var replacement = template$1.statement.ast(_templateObject$5 || (_templateObject$5 = _taggedTemplateLiteralLoose(["\n        try {\n          var ", " = ", "();\n          ", "\n        } catch (_) {\n          ", ".e = _;\n        } finally {\n          ", "\n        }\n      "])), cloneNode$e(ctx), state.addHelper("usingCtx"), path.node.body, cloneNode$e(ctx), needsAwait ? awaitExpression$1(disposeCall) : disposeCall);
          inherits$3(replacement, path.node);
          var parentPath = path.parentPath;
          if (parentPath.isFunction() || parentPath.isTryStatement() || parentPath.isCatchClause()) {
            path.replaceWith(blockStatement$6([replacement]));
          } else if (path.isStaticBlock()) {
            path.node.body = [replacement];
          } else {
            path.replaceWith(replacement);
          }
        } else {
          var stackId = null;
          var _needsAwait = false;
          var _loop = function _loop() {
            var _stackId;
            var node = _step3.value;
            if (!isUsingDeclaration(node)) return 1;
            (_stackId = stackId) != null ? _stackId : stackId = path.scope.generateUidIdentifier("stack");
            var isAwaitUsing = node.kind === "await using" || TOP_LEVEL_USING.get(node) === 1;
            _needsAwait || (_needsAwait = isAwaitUsing);
            if (!TOP_LEVEL_USING["delete"](node)) {
              node.kind = "const";
            }
            node.declarations.forEach(function (decl) {
              var args = [cloneNode$e(stackId), decl.init];
              if (isAwaitUsing) args.push(booleanLiteral$2(true));
              decl.init = callExpression$c(state.addHelper("using"), args);
            });
          };
          for (var _iterator3 = _createForOfIteratorHelperLoose(path.node.body), _step3; !(_step3 = _iterator3()).done;) {
            if (_loop()) continue;
          }
          if (!stackId) return;
          var errorId = path.scope.generateUidIdentifier("error");
          var hasErrorId = path.scope.generateUidIdentifier("hasError");
          var _disposeCall = callExpression$c(state.addHelper("dispose"), [cloneNode$e(stackId), cloneNode$e(errorId), cloneNode$e(hasErrorId)]);
          if (_needsAwait) _disposeCall = awaitExpression$1(_disposeCall);
          var _replacement = template$1.statement.ast(_templateObject2$4 || (_templateObject2$4 = _taggedTemplateLiteralLoose(["\n        try {\n          var ", " = [];\n          ", "\n        } catch (_) {\n          var ", " = _;\n          var ", " = true;\n        } finally {\n          ", "\n        }\n      "])), stackId, path.node.body, errorId, hasErrorId, _disposeCall);
          inherits$3(_replacement.block, path.node);
          var _parentPath = path.parentPath;
          if (_parentPath.isFunction() || _parentPath.isTryStatement() || _parentPath.isCatchClause()) {
            path.replaceWith(blockStatement$6([_replacement]));
          } else if (path.isStaticBlock()) {
            path.node.body = [_replacement];
          } else {
            path.replaceWith(_replacement);
          }
        }
      },
      SwitchStatement: function SwitchStatement(path, state) {
        var ctx = null;
        var needsAwait = false;
        var cases = path.node.cases;
        for (var _iterator4 = _createForOfIteratorHelperLoose(cases), _step4; !(_step4 = _iterator4()).done;) {
          var c = _step4.value;
          for (var _iterator5 = _createForOfIteratorHelperLoose(c.consequent), _step5; !(_step5 = _iterator5()).done;) {
            var stmt = _step5.value;
            if (isUsingDeclaration(stmt)) {
              var _ctx2;
              if (!state.availableHelper("usingCtx")) {
                path.traverse({
                  VariableDeclaration: function VariableDeclaration(path) {
                    var node = path.node;
                    if (!isUsingDeclaration(node)) return;
                    throw path.buildCodeFrameError("`using` declarations inside `switch` statements are not supported by your current `@babel/core` version, please update to a more recent one");
                  }
                });
              }
              (_ctx2 = ctx) != null ? _ctx2 : ctx = path.scope.generateUidIdentifier("usingCtx");
              var isAwaitUsing = stmt.kind === "await using";
              needsAwait || (needsAwait = isAwaitUsing);
              stmt.kind = "const";
              for (var _iterator6 = _createForOfIteratorHelperLoose(stmt.declarations), _step6; !(_step6 = _iterator6()).done;) {
                var decl = _step6.value;
                decl.init = callExpression$c(memberExpression$9(cloneNode$e(ctx), isAwaitUsing ? identifier$d("a") : identifier$d("u")), [decl.init]);
              }
            }
          }
        }
        if (!ctx) return;
        var disposeCall = callExpression$c(memberExpression$9(cloneNode$e(ctx), identifier$d("d")), []);
        var replacement = template$1.statement.ast(_templateObject3$3 || (_templateObject3$3 = _taggedTemplateLiteralLoose(["\n        try {\n          var ", " = ", "();\n          ", "\n        } catch (_) {\n          ", ".e = _;\n        } finally {\n          ", "\n        }\n      "])), cloneNode$e(ctx), state.addHelper("usingCtx"), path.node, cloneNode$e(ctx), needsAwait ? awaitExpression$1(disposeCall) : disposeCall);
        inherits$3(replacement, path.node);
        path.replaceWith(replacement);
      }
    };
    var transformUsingDeclarationsVisitorSkipFn = traverse.visitors.merge([transformUsingDeclarationsVisitor, {
      Function: function Function(path) {
        path.skip();
      }
    }]);
    return {
      name: "proposal-explicit-resource-management",
      manipulateOptions: function manipulateOptions(_, p) {
        return p.plugins.push("explicitResourceManagement");
      },
      visitor: traverse.visitors.merge([transformUsingDeclarationsVisitor, {
        Program: function Program(path) {
          TOP_LEVEL_USING.clear();
          if (path.node.sourceType !== "module") return;
          if (!path.node.body.some(isUsingDeclaration)) return;
          var innerBlockBody = [];
          for (var _iterator7 = _createForOfIteratorHelperLoose(path.get("body")), _step7; !(_step7 = _iterator7()).done;) {
            var stmt = _step7.value;
            if (stmt.isFunctionDeclaration() || stmt.isImportDeclaration()) {
              continue;
            }
            var node = stmt.node;
            var shouldRemove = true;
            if (stmt.isExportDefaultDeclaration()) {
              var _varId;
              var declaration = stmt.node.declaration;
              var varId = void 0;
              if (isClassDeclaration$2(declaration)) {
                varId = declaration.id;
                declaration.id = null;
                declaration = toExpression$1(declaration);
              } else if (!isExpression$5(declaration)) {
                continue;
              }
              (_varId = varId) != null ? _varId : varId = path.scope.generateUidIdentifier("_default");
              innerBlockBody.push(variableDeclaration$6("var", [variableDeclarator$6(varId, declaration)]));
              stmt.replaceWith(exportNamedDeclaration$2(null, [exportSpecifier$2(cloneNode$e(varId), identifier$d("default"))]));
              continue;
            }
            if (stmt.isExportNamedDeclaration()) {
              node = stmt.node.declaration;
              if (!node || isFunction$6(node)) continue;
              stmt.replaceWith(exportNamedDeclaration$2(null, Object.keys(getOuterBindingIdentifiers$1(node, false)).map(function (id) {
                return exportSpecifier$2(identifier$d(id), identifier$d(id));
              })));
              shouldRemove = false;
            } else if (stmt.isExportDeclaration()) {
              continue;
            }
            if (isClassDeclaration$2(node)) {
              var _node = node,
                id = _node.id;
              node.id = null;
              innerBlockBody.push(variableDeclaration$6("var", [variableDeclarator$6(id, toExpression$1(node))]));
            } else if (isVariableDeclaration$3(node)) {
              if (node.kind === "using") {
                TOP_LEVEL_USING.set(stmt.node, 0);
              } else if (node.kind === "await using") {
                TOP_LEVEL_USING.set(stmt.node, 1);
              }
              node.kind = "var";
              innerBlockBody.push(node);
            } else {
              innerBlockBody.push(stmt.node);
            }
            if (shouldRemove) stmt.remove();
          }
          path.pushContainer("body", blockStatement$6(innerBlockBody));
        },
        Function: function Function(path, state) {
          if (path.node.async) {
            path.traverse(transformUsingDeclarationsVisitorSkipFn, state);
          }
        }
      }])
    };
  });

var _templateObject$4, _templateObject2$3;
  var proposalImportDefer = declare(function (api) {
    api.assertVersion("*");
    var t = api.types;
    var template = api.template;
    function allReferencesAreProps(scope, node) {
      var specifier = node.specifiers[0];
      t.assertImportNamespaceSpecifier(specifier);
      var binding = scope.getOwnBinding(specifier.local.name);
      return !!(binding != null && binding.referencePaths.every(function (path) {
        return path.parentPath.isMemberExpression({
          object: path.node
        });
      }));
    }
    return {
      name: "proposal-import-defer",
      manipulateOptions: function manipulateOptions(_, p) {
        return p.plugins.push("deferredImportEvaluation");
      },
      pre: function pre() {
        var file = this.file;
        defineCommonJSHook(file, {
          name: "@babel/plugin-proposal-import-defer",
          version: "7.25.9",
          getWrapperPayload: function getWrapperPayload(source, metadata, importNodes) {
            var needsProxy = false;
            for (var _iterator = _createForOfIteratorHelperLoose(importNodes), _step; !(_step = _iterator()).done;) {
              var node = _step.value;
              if (!t.isImportDeclaration(node)) return null;
              if (node.phase !== "defer") return null;
              if (!allReferencesAreProps(file.scope, node)) needsProxy = true;
            }
            return needsProxy ? "defer/proxy" : "defer/function";
          },
          buildRequireWrapper: function buildRequireWrapper(name, init, payload, referenced) {
            if (payload === "defer/proxy") {
              if (!referenced) return false;
              return template.statement.ast(_templateObject$4 || (_templateObject$4 = _taggedTemplateLiteralLoose(["\n              var ", " = ", "(\n                () => ", "\n              )\n            "])), name, file.addHelper("importDeferProxy"), init);
            }
            if (payload === "defer/function") {
              if (!referenced) return false;
              return template.statement.ast(_templateObject2$3 || (_templateObject2$3 = _taggedTemplateLiteralLoose(["\n              function ", "(data) {\n                ", " = () => data;\n                return data = ", ";\n              }\n            "])), name, name, init);
            }
          },
          wrapReference: function wrapReference(ref, payload) {
            if (payload === "defer/function") return t.callExpression(ref, []);
          }
        });
      },
      visitor: {
        Program: function Program(path) {
          if (this.file.get("@babel/plugin-transform-modules-*") !== "commonjs") {
            throw new Error("@babel/plugin-proposal-import-defer can only be used when" + " transpiling modules to CommonJS.");
          }
          var eagerImports = new Set();
          for (var _iterator2 = _createForOfIteratorHelperLoose(path.get("body")), _step2; !(_step2 = _iterator2()).done;) {
            var child = _step2.value;
            if (child.isImportDeclaration() && child.node.phase == null || child.isExportNamedDeclaration() && child.node.source !== null || child.isExportAllDeclaration()) {
              var specifier = child.node.source.value;
              if (!eagerImports.has(specifier)) {
                eagerImports.add(specifier);
              }
            }
          }
          var importsToPush = [];
          for (var _iterator3 = _createForOfIteratorHelperLoose(path.get("body")), _step3; !(_step3 = _iterator3()).done;) {
            var _child = _step3.value;
            if (_child.isImportDeclaration({
              phase: "defer"
            })) {
              var _specifier = _child.node.source.value;
              if (!eagerImports.has(_specifier)) continue;
              _child.node.phase = null;
              importsToPush.push(_child.node);
              _child.remove();
            }
          }
          if (importsToPush.length) {
            path.pushContainer("body", importsToPush);
            path.scope.crawl();
          }
        }
      }
    };
  });

var syntaxAsyncGenerators = makeNoopPlugin(),
    syntaxClassProperties = makeNoopPlugin(),
    syntaxClassStaticBlock = makeNoopPlugin(),
    syntaxImportMeta = makeNoopPlugin(),
    syntaxObjectRestSpread = makeNoopPlugin(),
    syntaxOptionalCatchBinding = makeNoopPlugin(),
    syntaxTopLevelAwait = makeNoopPlugin();
  var all = {
    "syntax-async-generators": syntaxAsyncGenerators,
    "syntax-class-properties": syntaxClassProperties,
    "syntax-class-static-block": syntaxClassStaticBlock,
    "syntax-import-meta": syntaxImportMeta,
    "syntax-object-rest-spread": syntaxObjectRestSpread,
    "syntax-optional-catch-binding": syntaxOptionalCatchBinding,
    "syntax-top-level-await": syntaxTopLevelAwait,
    "external-helpers": externalHelpers,
    "syntax-decimal": lib$9,
    "syntax-decorators": syntaxDecorators,
    "syntax-destructuring-private": syntaxDestructuringPrivate,
    "syntax-do-expressions": syntaxDoExpressions,
    "syntax-explicit-resource-management": syntaxExplicitResourceManagement,
    "syntax-export-default-from": syntaxExportDefaultFrom,
    "syntax-flow": syntaxFlow,
    "syntax-function-bind": syntaxFunctionBind,
    "syntax-function-sent": syntaxFunctionSent,
    "syntax-import-assertions": syntaxImportAssertions,
    "syntax-import-attributes": syntaxImportAttributes,
    "syntax-import-reflection": lib$8,
    "syntax-jsx": syntaxJsx,
    "syntax-module-blocks": syntaxModuleBlocks,
    "syntax-optional-chaining-assign": syntaxOptionalChainingAssign,
    "syntax-pipeline-operator": syntaxPipelineOperator,
    "syntax-record-and-tuple": syntaxRecordAndTuple,
    "syntax-typescript": syntaxTypescript,
    "transform-async-generator-functions": _transformAsyncGeneratorFunctions,
    "transform-class-properties": _transformClassProperties,
    "transform-class-static-block": _transformClassStaticBlock,
    "proposal-decorators": proposalDecorators,
    "proposal-destructuring-private": proposalDestructuringPrivate,
    "proposal-do-expressions": proposalDoExpressions,
    "transform-duplicate-named-capturing-groups-regex": _transformDuplicateNamedCapturingGroupsRegex,
    "transform-dynamic-import": _transformDynamicImport,
    "proposal-export-default-from": proposalExportDefaultFrom,
    "transform-export-namespace-from": _transformExportNamespaceFrom,
    "proposal-function-bind": proposalFunctionBind,
    "proposal-function-sent": proposalFunctionSent,
    "transform-json-strings": _transformJsonStrings,
    "transform-logical-assignment-operators": _transformLogicalAssignmentOperators,
    "transform-nullish-coalescing-operator": _transformNullishCoalescingOperator,
    "transform-numeric-separator": _transformNumericSeparator,
    "transform-object-rest-spread": _transformObjectRestSpread,
    "transform-optional-catch-binding": _transformOptionalCatchBinding,
    "transform-optional-chaining": _transformOptionalChaining,
    "proposal-optional-chaining-assign": proposalOptionalChainingAssign,
    "proposal-pipeline-operator": proposalPipelineOperator,
    "transform-private-methods": _transformPrivateMethods,
    "transform-private-property-in-object": _transformPrivatePropertyInObject,
    "proposal-record-and-tuple": proposalRecordAndTuple,
    "transform-regexp-modifiers": transformRegExpModifiers,
    "proposal-throw-expressions": proposalThrowExpressions,
    "transform-unicode-property-regex": _transformUnicodePropertyRegex,
    "transform-unicode-sets-regex": _transformUnicodeSetsRegex,
    "transform-async-to-generator": _transformAsyncToGenerator,
    "transform-arrow-functions": _transformArrowFunctions,
    "transform-block-scoped-functions": _transformBlockScopedFunctions,
    "transform-block-scoping": _transformBlockScoping,
    "transform-classes": _transformClasses,
    "transform-computed-properties": _transformComputedProperties,
    "transform-destructuring": _transformDestructuring,
    "transform-dotall-regex": _transformDotallRegex,
    "transform-duplicate-keys": _transformDuplicateKeys,
    "transform-exponentiation-operator": transformExponentialOperator,
    "transform-flow-comments": transformFlowComments,
    "transform-flow-strip-types": transformFlowStripTypes,
    "transform-for-of": _transformForOf,
    "transform-function-name": _transformFunctionName,
    "transform-instanceof": transformInstanceof,
    "transform-jscript": transformJscript,
    "transform-json-modules": transformJsonModules,
    "transform-literals": _transformLiterals,
    "transform-member-expression-literals": _transformMemberExpressionLiterals,
    "transform-modules-amd": _transformModulesAmd,
    "transform-modules-commonjs": transformModulesCommonJS,
    "transform-modules-systemjs": _transformModulesSystemjs,
    "transform-modules-umd": _transformModulesUmd,
    "transform-named-capturing-groups-regex": _transformNamedCapturingGroupsRegex,
    "transform-new-target": _transformNewTarget,
    "transform-object-assign": transformObjectAssign,
    "transform-object-super": _transformObjectSuper,
    "transform-object-set-prototype-of-to-assign": transformObjectSetPrototypeOfToAssign,
    "transform-parameters": _transformParameters,
    "transform-property-literals": _transformPropertyLiterals,
    "transform-property-mutators": transformPropertyMutators,
    "transform-proto-to-assign": transformProtoToAssign,
    "transform-react-constant-elements": transformReactConstantElements,
    "transform-react-display-name": transformReactDisplayName,
    "transform-react-inline-elements": transformReactInlineElements,
    "transform-react-jsx": transformReactJSX,
    "transform-react-jsx-compat": transformReactJsxCompat,
    "transform-react-jsx-development": plugin,
    "transform-react-jsx-self": transformReactJsxSelf,
    "transform-react-jsx-source": transformReactJsxSource,
    "transform-regenerator": _transformRegenerator,
    "transform-reserved-words": _transformReservedWords,
    "transform-runtime": transformRuntime,
    "transform-shorthand-properties": _transformShorthandProperties,
    "transform-spread": _transformSpread,
    "transform-sticky-regex": _transformStickyRegex,
    "transform-strict-mode": transformStrictMode,
    "transform-template-literals": _transformTemplateLiterals,
    "transform-typeof-symbol": _transformTypeofSymbol,
    "transform-typescript": transformTypeScript,
    "transform-unicode-escapes": _transformUnicodeEscapes,
    "transform-unicode-regex": _transformUnicodeRegex,
    "proposal-explicit-resource-management": proposalExplicitResourceManagement,
    "proposal-import-defer": proposalImportDefer
  };

function bool(value) {
    if (value == null) return false;
    return value && value !== "false" && value !== "0";
  }
  var semver$1 = bool(browser$1$1.env["BABEL_8_BREAKING"]) ? requireSemver$2() : requireSemver$2();

var babel7AvailablePlugins = {exports: {}};

var require$$0$2 = /*@__PURE__*/getAugmentedNamespace(src$1);

var require$$1 = /*@__PURE__*/getAugmentedNamespace(src);

{
    var availablePlugins$2 = {
      "syntax-import-assertions": function syntaxImportAssertions() {
        return require$$0$2;
      },
      "syntax-import-attributes": function syntaxImportAttributes() {
        return require$$1;
      }
    };
    babel7AvailablePlugins.exports = availablePlugins$2;
  }
  var babel7AvailablePluginsExports = babel7AvailablePlugins.exports;

var transformAsyncArrowsInClass = {exports: {}};

(function (module, exports) {

exports.__esModule = true;
    exports["default"] = void 0;
    var OPTS = {
      allowInsertArrow: false,
      specCompliant: false
    };
    var _default = function _default(_ref) {
      var t = _ref.types;
      return {
        name: "transform-async-arrows-in-class",
        visitor: {
          ArrowFunctionExpression: function ArrowFunctionExpression(path) {
            if (path.node.async && path.findParent(t.isClassMethod)) {
              path.arrowFunctionToExpression(OPTS);
            }
          }
        }
      };
    };
    exports["default"] = _default;
    module.exports = exports["default"];
  })(transformAsyncArrowsInClass, transformAsyncArrowsInClass.exports);
  var transformAsyncArrowsInClassExports = transformAsyncArrowsInClass.exports;

var transformEdgeDefaultParameters = {exports: {}};

(function (module, exports) {

exports.__esModule = true;
    exports["default"] = void 0;
    var _default = function _default(_ref) {
      var t = _ref.types;
      var isArrowParent = function isArrowParent(p) {
        return p.parentKey === "params" && p.parentPath && t.isArrowFunctionExpression(p.parentPath);
      };
      return {
        name: "transform-edge-default-parameters",
        visitor: {
          AssignmentPattern: function AssignmentPattern(path) {
            var arrowArgParent = path.find(isArrowParent);
            if (arrowArgParent && path.parent.shorthand) {
              path.parent.shorthand = false;
              (path.parent.extra || {}).shorthand = false;
              path.scope.rename(path.parent.key.name);
            }
          }
        }
      };
    };
    exports["default"] = _default;
    module.exports = exports["default"];
  })(transformEdgeDefaultParameters, transformEdgeDefaultParameters.exports);
  var transformEdgeDefaultParametersExports = transformEdgeDefaultParameters.exports;

var transformEdgeFunctionName = {exports: {}};

(function (module, exports) {

exports.__esModule = true;
    exports["default"] = void 0;
    var _default = function _default(_ref) {
      var t = _ref.types;
      return {
        name: "transform-edge-function-name",
        visitor: {
          FunctionExpression: {
            exit: function exit(path) {
              if (!path.node.id && t.isIdentifier(path.parent.id)) {
                var id = t.cloneNode(path.parent.id);
                var binding = path.scope.getBinding(id.name);
                if (binding == null ? void 0 : binding.constantViolations.length) {
                  path.scope.rename(id.name);
                }
                path.node.id = id;
              }
            }
          }
        }
      };
    };
    exports["default"] = _default;
    module.exports = exports["default"];
  })(transformEdgeFunctionName, transformEdgeFunctionName.exports);
  var transformEdgeFunctionNameExports = transformEdgeFunctionName.exports;

var transformTaggedTemplateCaching = {exports: {}};

(function (module, exports) {

exports.__esModule = true;
    exports["default"] = void 0;
    var _default = function _default(_ref) {
      var t = _ref.types;
      return {
        name: "transform-tagged-template-caching",
        visitor: {
          TaggedTemplateExpression: function TaggedTemplateExpression(path, state) {
            var processed = state.get("processed");
            if (!processed) {
              processed = new WeakSet();
              state.set("processed", processed);
            }
            if (processed.has(path.node)) return path.skip();
            var expressions = path.node.quasi.expressions;
            var identity = state.get("identity");
            if (!identity) {
              identity = path.scope.getProgramParent().generateDeclaredUidIdentifier("_");
              state.set("identity", identity);
              var binding = path.scope.getBinding(identity.name);
              binding.path.get("init").replaceWith(t.arrowFunctionExpression([t.identifier("t")], t.identifier("t")));
            }
            var template = t.taggedTemplateExpression(t.cloneNode(identity), t.templateLiteral(path.node.quasi.quasis, expressions.map(function () {
              return t.numericLiteral(0);
            })));
            processed.add(template);
            var ident = path.scope.getProgramParent().generateDeclaredUidIdentifier("t");
            path.scope.getBinding(ident.name).path.parent.kind = "let";
            var inlineCache = t.logicalExpression("||", ident, t.assignmentExpression("=", t.cloneNode(ident), template));
            var node = t.callExpression(path.node.tag, [inlineCache].concat(_toConsumableArray(expressions)));
            path.replaceWith(node);
          }
        }
      };
    };
    exports["default"] = _default;
    module.exports = exports["default"];
  })(transformTaggedTemplateCaching, transformTaggedTemplateCaching.exports);
  var transformTaggedTemplateCachingExports = transformTaggedTemplateCaching.exports;

var transformSafariBlockShadowing = {exports: {}};

(function (module, exports) {

exports.__esModule = true;
    exports["default"] = _default;
    function _default(_ref) {
      var t = _ref.types;
      return {
        name: "transform-safari-block-shadowing",
        visitor: {
          VariableDeclarator: function VariableDeclarator(path) {
            var kind = path.parent.kind;
            if (kind !== "let" && kind !== "const") return;
            var block = path.scope.block;
            if (t.isFunction(block) || t.isProgram(block)) return;
            var bindings = t.getOuterBindingIdentifiers(path.node.id);
            for (var _i = 0, _Object$keys = Object.keys(bindings); _i < _Object$keys.length; _i++) {
              var name = _Object$keys[_i];
              var scope = path.scope;
              if (!scope.hasOwnBinding(name)) continue;
              while (scope = scope.parent) {
                if (scope.hasOwnBinding(name)) {
                  path.scope.rename(name);
                  break;
                }
                if (t.isFunction(scope.block) || t.isProgram(scope.block)) {
                  break;
                }
              }
            }
          }
        }
      };
    }
    module.exports = exports["default"];
  })(transformSafariBlockShadowing, transformSafariBlockShadowing.exports);
  var transformSafariBlockShadowingExports = transformSafariBlockShadowing.exports;

var transformSafariForShadowing = {exports: {}};

(function (module, exports) {

exports.__esModule = true;
    exports["default"] = void 0;
    function handle(declaration) {
      if (!declaration.isVariableDeclaration()) return;
      var fn = declaration.getFunctionParent();
      var name = declaration.node.declarations[0].id.name;
      if (fn && fn.scope.hasOwnBinding(name) && fn.scope.getOwnBinding(name).kind === "param") {
        declaration.scope.rename(name);
      }
    }
    var _default = function _default() {
      return {
        name: "transform-safari-for-shadowing",
        visitor: {
          ForXStatement: function ForXStatement(path) {
            handle(path.get("left"));
          },
          ForStatement: function ForStatement(path) {
            handle(path.get("init"));
          }
        }
      };
    };
    exports["default"] = _default;
    module.exports = exports["default"];
  })(transformSafariForShadowing, transformSafariForShadowing.exports);
  var transformSafariForShadowingExports = transformSafariForShadowing.exports;

var moduleTransformations = {
    amd: "transform-modules-amd",
    commonjs: "transform-modules-commonjs",
    cjs: "transform-modules-commonjs",
    systemjs: "transform-modules-systemjs",
    umd: "transform-modules-umd"
  };

var require$$0$1 = {
  	"bugfix/transform-async-arrows-in-class": {
  	chrome: "55",
  	opera: "42",
  	edge: "15",
  	firefox: "52",
  	safari: "11",
  	node: "7.6",
  	deno: "1",
  	ios: "11",
  	samsung: "6",
  	opera_mobile: "42",
  	electron: "1.6"
  },
  	"bugfix/transform-edge-default-parameters": {
  	chrome: "49",
  	opera: "36",
  	edge: "18",
  	firefox: "52",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"bugfix/transform-edge-function-name": {
  	chrome: "51",
  	opera: "38",
  	edge: "79",
  	firefox: "53",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"bugfix/transform-safari-block-shadowing": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "44",
  	safari: "11",
  	node: "6",
  	deno: "1",
  	ie: "11",
  	ios: "11",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"bugfix/transform-safari-for-shadowing": {
  	chrome: "49",
  	opera: "36",
  	edge: "12",
  	firefox: "4",
  	safari: "11",
  	node: "6",
  	deno: "1",
  	ie: "11",
  	ios: "11",
  	samsung: "5",
  	rhino: "1.7.13",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"bugfix/transform-safari-id-destructuring-collision-in-function-expression": {
  	chrome: "49",
  	opera: "36",
  	edge: "14",
  	firefox: "2",
  	safari: "16.3",
  	node: "6",
  	deno: "1",
  	ios: "16.3",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"bugfix/transform-tagged-template-caching": {
  	chrome: "41",
  	opera: "28",
  	edge: "12",
  	firefox: "34",
  	safari: "13",
  	node: "4",
  	deno: "1",
  	ios: "13",
  	samsung: "3.4",
  	rhino: "1.7.14",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"bugfix/transform-v8-spread-parameters-in-optional-chaining": {
  	chrome: "91",
  	opera: "77",
  	edge: "91",
  	firefox: "74",
  	safari: "13.1",
  	node: "16.9",
  	deno: "1.9",
  	ios: "13.4",
  	samsung: "16",
  	opera_mobile: "64",
  	electron: "13.0"
  },
  	"bugfix/transform-firefox-class-in-computed-class-key": {
  	chrome: "74",
  	opera: "62",
  	edge: "79",
  	safari: "16",
  	node: "12",
  	deno: "1",
  	ios: "16",
  	samsung: "11",
  	opera_mobile: "53",
  	electron: "6.0"
  },
  	"transform-optional-chaining": {
  	chrome: "80",
  	opera: "67",
  	edge: "80",
  	firefox: "74",
  	safari: "13.1",
  	node: "14",
  	deno: "1",
  	ios: "13.4",
  	samsung: "13",
  	opera_mobile: "57",
  	electron: "8.0"
  },
  	"proposal-optional-chaining": {
  	chrome: "80",
  	opera: "67",
  	edge: "80",
  	firefox: "74",
  	safari: "13.1",
  	node: "14",
  	deno: "1",
  	ios: "13.4",
  	samsung: "13",
  	opera_mobile: "57",
  	electron: "8.0"
  },
  	"transform-parameters": {
  	chrome: "49",
  	opera: "36",
  	edge: "15",
  	firefox: "53",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "36",
  	electron: "0.37"
  },
  	"transform-async-to-generator": {
  	chrome: "55",
  	opera: "42",
  	edge: "15",
  	firefox: "52",
  	safari: "10.1",
  	node: "7.6",
  	deno: "1",
  	ios: "10.3",
  	samsung: "6",
  	opera_mobile: "42",
  	electron: "1.6"
  },
  	"transform-template-literals": {
  	chrome: "41",
  	opera: "28",
  	edge: "13",
  	firefox: "34",
  	safari: "9",
  	node: "4",
  	deno: "1",
  	ios: "9",
  	samsung: "3.4",
  	opera_mobile: "28",
  	electron: "0.21"
  },
  	"transform-function-name": {
  	chrome: "51",
  	opera: "38",
  	edge: "14",
  	firefox: "53",
  	safari: "10",
  	node: "6.5",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "41",
  	electron: "1.2"
  },
  	"transform-block-scoping": {
  	chrome: "50",
  	opera: "37",
  	edge: "14",
  	firefox: "53",
  	safari: "10",
  	node: "6",
  	deno: "1",
  	ios: "10",
  	samsung: "5",
  	opera_mobile: "37",
  	electron: "1.1"
  }
  };

var pluginBugfixes = require$$0$1;

var require$$0 = {
  	"transform-async-to-generator": [
  	"bugfix/transform-async-arrows-in-class"
  ],
  	"transform-parameters": [
  	"bugfix/transform-edge-default-parameters",
  	"bugfix/transform-safari-id-destructuring-collision-in-function-expression"
  ],
  	"transform-function-name": [
  	"bugfix/transform-edge-function-name"
  ],
  	"transform-block-scoping": [
  	"bugfix/transform-safari-block-shadowing",
  	"bugfix/transform-safari-for-shadowing"
  ],
  	"transform-template-literals": [
  	"bugfix/transform-tagged-template-caching"
  ],
  	"transform-optional-chaining": [
  	"bugfix/transform-v8-spread-parameters-in-optional-chaining"
  ],
  	"proposal-optional-chaining": [
  	"bugfix/transform-v8-spread-parameters-in-optional-chaining"
  ],
  	"transform-class-properties": [
  	"bugfix/transform-v8-static-class-fields-redefine-readonly",
  	"bugfix/transform-firefox-class-in-computed-class-key",
  	"bugfix/transform-safari-class-field-initializer-scope"
  ],
  	"proposal-class-properties": [
  	"bugfix/transform-v8-static-class-fields-redefine-readonly",
  	"bugfix/transform-firefox-class-in-computed-class-key",
  	"bugfix/transform-safari-class-field-initializer-scope"
  ]
  };

var overlappingPlugins$1 = require$$0;

var babel7Plugins = {};

var lib$2 = {};

var builtInDefinitions = {};

var hasRequiredBuiltInDefinitions;
  function requireBuiltInDefinitions() {
    if (hasRequiredBuiltInDefinitions) return builtInDefinitions;
    hasRequiredBuiltInDefinitions = 1;
    builtInDefinitions.__esModule = true;
    builtInDefinitions.StaticProperties = builtInDefinitions.InstanceProperties = builtInDefinitions.CommonIterators = builtInDefinitions.BuiltIns = void 0;
    var _corejs2BuiltIns = _interopRequireDefault(requireCorejs2BuiltIns());
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    var define = function define(name, pure, global, meta) {
      if (global === void 0) {
        global = [];
      }
      return {
        name: name,
        pure: pure,
        global: global,
        meta: meta
      };
    };
    var pureAndGlobal = function pureAndGlobal(pure, global, minRuntimeVersion) {
      if (minRuntimeVersion === void 0) {
        minRuntimeVersion = null;
      }
      return define(global[0], pure, global, {
        minRuntimeVersion: minRuntimeVersion
      });
    };
    var globalOnly = function globalOnly(global) {
      return define(global[0], null, global);
    };
    var pureOnly = function pureOnly(pure, name) {
      return define(name, pure, []);
    };
    var ArrayNatureIterators = ["es6.object.to-string", "es6.array.iterator", "web.dom.iterable"];
    var CommonIterators = ["es6.string.iterator"].concat(ArrayNatureIterators);
    builtInDefinitions.CommonIterators = CommonIterators;
    var PromiseDependencies = ["es6.object.to-string", "es6.promise"];
    var BuiltIns = {
      DataView: globalOnly(["es6.typed.data-view"]),
      Float32Array: globalOnly(["es6.typed.float32-array"]),
      Float64Array: globalOnly(["es6.typed.float64-array"]),
      Int8Array: globalOnly(["es6.typed.int8-array"]),
      Int16Array: globalOnly(["es6.typed.int16-array"]),
      Int32Array: globalOnly(["es6.typed.int32-array"]),
      Map: pureAndGlobal("map", ["es6.map"].concat(_toConsumableArray(CommonIterators))),
      Number: globalOnly(["es6.number.constructor"]),
      Promise: pureAndGlobal("promise", PromiseDependencies),
      RegExp: globalOnly(["es6.regexp.constructor"]),
      Set: pureAndGlobal("set", ["es6.set"].concat(_toConsumableArray(CommonIterators))),
      Symbol: pureAndGlobal("symbol/index", ["es6.symbol"]),
      Uint8Array: globalOnly(["es6.typed.uint8-array"]),
      Uint8ClampedArray: globalOnly(["es6.typed.uint8-clamped-array"]),
      Uint16Array: globalOnly(["es6.typed.uint16-array"]),
      Uint32Array: globalOnly(["es6.typed.uint32-array"]),
      WeakMap: pureAndGlobal("weak-map", ["es6.weak-map"].concat(_toConsumableArray(CommonIterators))),
      WeakSet: pureAndGlobal("weak-set", ["es6.weak-set"].concat(_toConsumableArray(CommonIterators))),
      setImmediate: pureOnly("set-immediate", "web.immediate"),
      clearImmediate: pureOnly("clear-immediate", "web.immediate"),
      parseFloat: pureOnly("parse-float", "es6.parse-float"),
      parseInt: pureOnly("parse-int", "es6.parse-int")
    };
    builtInDefinitions.BuiltIns = BuiltIns;
    var InstanceProperties = {
      __defineGetter__: globalOnly(["es7.object.define-getter"]),
      __defineSetter__: globalOnly(["es7.object.define-setter"]),
      __lookupGetter__: globalOnly(["es7.object.lookup-getter"]),
      __lookupSetter__: globalOnly(["es7.object.lookup-setter"]),
      anchor: globalOnly(["es6.string.anchor"]),
      big: globalOnly(["es6.string.big"]),
      bind: globalOnly(["es6.function.bind"]),
      blink: globalOnly(["es6.string.blink"]),
      bold: globalOnly(["es6.string.bold"]),
      codePointAt: globalOnly(["es6.string.code-point-at"]),
      copyWithin: globalOnly(["es6.array.copy-within"]),
      endsWith: globalOnly(["es6.string.ends-with"]),
      entries: globalOnly(ArrayNatureIterators),
      every: globalOnly(["es6.array.every"]),
      fill: globalOnly(["es6.array.fill"]),
      filter: globalOnly(["es6.array.filter"]),
      "finally": globalOnly(["es7.promise.finally"].concat(PromiseDependencies)),
      find: globalOnly(["es6.array.find"]),
      findIndex: globalOnly(["es6.array.find-index"]),
      fixed: globalOnly(["es6.string.fixed"]),
      flags: globalOnly(["es6.regexp.flags"]),
      flatMap: globalOnly(["es7.array.flat-map"]),
      fontcolor: globalOnly(["es6.string.fontcolor"]),
      fontsize: globalOnly(["es6.string.fontsize"]),
      forEach: globalOnly(["es6.array.for-each"]),
      includes: globalOnly(["es6.string.includes", "es7.array.includes"]),
      indexOf: globalOnly(["es6.array.index-of"]),
      italics: globalOnly(["es6.string.italics"]),
      keys: globalOnly(ArrayNatureIterators),
      lastIndexOf: globalOnly(["es6.array.last-index-of"]),
      link: globalOnly(["es6.string.link"]),
      map: globalOnly(["es6.array.map"]),
      match: globalOnly(["es6.regexp.match"]),
      name: globalOnly(["es6.function.name"]),
      padStart: globalOnly(["es7.string.pad-start"]),
      padEnd: globalOnly(["es7.string.pad-end"]),
      reduce: globalOnly(["es6.array.reduce"]),
      reduceRight: globalOnly(["es6.array.reduce-right"]),
      repeat: globalOnly(["es6.string.repeat"]),
      replace: globalOnly(["es6.regexp.replace"]),
      search: globalOnly(["es6.regexp.search"]),
      small: globalOnly(["es6.string.small"]),
      some: globalOnly(["es6.array.some"]),
      sort: globalOnly(["es6.array.sort"]),
      split: globalOnly(["es6.regexp.split"]),
      startsWith: globalOnly(["es6.string.starts-with"]),
      strike: globalOnly(["es6.string.strike"]),
      sub: globalOnly(["es6.string.sub"]),
      sup: globalOnly(["es6.string.sup"]),
      toISOString: globalOnly(["es6.date.to-iso-string"]),
      toJSON: globalOnly(["es6.date.to-json"]),
      toString: globalOnly(["es6.object.to-string", "es6.date.to-string", "es6.regexp.to-string"]),
      trim: globalOnly(["es6.string.trim"]),
      trimEnd: globalOnly(["es7.string.trim-right"]),
      trimLeft: globalOnly(["es7.string.trim-left"]),
      trimRight: globalOnly(["es7.string.trim-right"]),
      trimStart: globalOnly(["es7.string.trim-left"]),
      values: globalOnly(ArrayNatureIterators)
    };
    builtInDefinitions.InstanceProperties = InstanceProperties;
    if ("es6.array.slice" in _corejs2BuiltIns["default"]) {
      InstanceProperties.slice = globalOnly(["es6.array.slice"]);
    }
    var StaticProperties = {
      Array: {
        from: pureAndGlobal("array/from", ["es6.symbol", "es6.array.from"].concat(_toConsumableArray(CommonIterators))),
        isArray: pureAndGlobal("array/is-array", ["es6.array.is-array"]),
        of: pureAndGlobal("array/of", ["es6.array.of"])
      },
      Date: {
        now: pureAndGlobal("date/now", ["es6.date.now"])
      },
      JSON: {
        stringify: pureOnly("json/stringify", "es6.symbol")
      },
      Math: {
        acosh: pureAndGlobal("math/acosh", ["es6.math.acosh"], "7.0.1"),
        asinh: pureAndGlobal("math/asinh", ["es6.math.asinh"], "7.0.1"),
        atanh: pureAndGlobal("math/atanh", ["es6.math.atanh"], "7.0.1"),
        cbrt: pureAndGlobal("math/cbrt", ["es6.math.cbrt"], "7.0.1"),
        clz32: pureAndGlobal("math/clz32", ["es6.math.clz32"], "7.0.1"),
        cosh: pureAndGlobal("math/cosh", ["es6.math.cosh"], "7.0.1"),
        expm1: pureAndGlobal("math/expm1", ["es6.math.expm1"], "7.0.1"),
        fround: pureAndGlobal("math/fround", ["es6.math.fround"], "7.0.1"),
        hypot: pureAndGlobal("math/hypot", ["es6.math.hypot"], "7.0.1"),
        imul: pureAndGlobal("math/imul", ["es6.math.imul"], "7.0.1"),
        log1p: pureAndGlobal("math/log1p", ["es6.math.log1p"], "7.0.1"),
        log10: pureAndGlobal("math/log10", ["es6.math.log10"], "7.0.1"),
        log2: pureAndGlobal("math/log2", ["es6.math.log2"], "7.0.1"),
        sign: pureAndGlobal("math/sign", ["es6.math.sign"], "7.0.1"),
        sinh: pureAndGlobal("math/sinh", ["es6.math.sinh"], "7.0.1"),
        tanh: pureAndGlobal("math/tanh", ["es6.math.tanh"], "7.0.1"),
        trunc: pureAndGlobal("math/trunc", ["es6.math.trunc"], "7.0.1")
      },
      Number: {
        EPSILON: pureAndGlobal("number/epsilon", ["es6.number.epsilon"]),
        MIN_SAFE_INTEGER: pureAndGlobal("number/min-safe-integer", ["es6.number.min-safe-integer"]),
        MAX_SAFE_INTEGER: pureAndGlobal("number/max-safe-integer", ["es6.number.max-safe-integer"]),
        isFinite: pureAndGlobal("number/is-finite", ["es6.number.is-finite"]),
        isInteger: pureAndGlobal("number/is-integer", ["es6.number.is-integer"]),
        isSafeInteger: pureAndGlobal("number/is-safe-integer", ["es6.number.is-safe-integer"]),
        isNaN: pureAndGlobal("number/is-nan", ["es6.number.is-nan"]),
        parseFloat: pureAndGlobal("number/parse-float", ["es6.number.parse-float"]),
        parseInt: pureAndGlobal("number/parse-int", ["es6.number.parse-int"])
      },
      Object: {
        assign: pureAndGlobal("object/assign", ["es6.object.assign"]),
        create: pureAndGlobal("object/create", ["es6.object.create"]),
        defineProperties: pureAndGlobal("object/define-properties", ["es6.object.define-properties"]),
        defineProperty: pureAndGlobal("object/define-property", ["es6.object.define-property"]),
        entries: pureAndGlobal("object/entries", ["es7.object.entries"]),
        freeze: pureAndGlobal("object/freeze", ["es6.object.freeze"]),
        getOwnPropertyDescriptor: pureAndGlobal("object/get-own-property-descriptor", ["es6.object.get-own-property-descriptor"]),
        getOwnPropertyDescriptors: pureAndGlobal("object/get-own-property-descriptors", ["es7.object.get-own-property-descriptors"]),
        getOwnPropertyNames: pureAndGlobal("object/get-own-property-names", ["es6.object.get-own-property-names"]),
        getOwnPropertySymbols: pureAndGlobal("object/get-own-property-symbols", ["es6.symbol"]),
        getPrototypeOf: pureAndGlobal("object/get-prototype-of", ["es6.object.get-prototype-of"]),
        is: pureAndGlobal("object/is", ["es6.object.is"]),
        isExtensible: pureAndGlobal("object/is-extensible", ["es6.object.is-extensible"]),
        isFrozen: pureAndGlobal("object/is-frozen", ["es6.object.is-frozen"]),
        isSealed: pureAndGlobal("object/is-sealed", ["es6.object.is-sealed"]),
        keys: pureAndGlobal("object/keys", ["es6.object.keys"]),
        preventExtensions: pureAndGlobal("object/prevent-extensions", ["es6.object.prevent-extensions"]),
        seal: pureAndGlobal("object/seal", ["es6.object.seal"]),
        setPrototypeOf: pureAndGlobal("object/set-prototype-of", ["es6.object.set-prototype-of"]),
        values: pureAndGlobal("object/values", ["es7.object.values"])
      },
      Promise: {
        all: globalOnly(CommonIterators),
        race: globalOnly(CommonIterators)
      },
      Reflect: {
        apply: pureAndGlobal("reflect/apply", ["es6.reflect.apply"]),
        construct: pureAndGlobal("reflect/construct", ["es6.reflect.construct"]),
        defineProperty: pureAndGlobal("reflect/define-property", ["es6.reflect.define-property"]),
        deleteProperty: pureAndGlobal("reflect/delete-property", ["es6.reflect.delete-property"]),
        get: pureAndGlobal("reflect/get", ["es6.reflect.get"]),
        getOwnPropertyDescriptor: pureAndGlobal("reflect/get-own-property-descriptor", ["es6.reflect.get-own-property-descriptor"]),
        getPrototypeOf: pureAndGlobal("reflect/get-prototype-of", ["es6.reflect.get-prototype-of"]),
        has: pureAndGlobal("reflect/has", ["es6.reflect.has"]),
        isExtensible: pureAndGlobal("reflect/is-extensible", ["es6.reflect.is-extensible"]),
        ownKeys: pureAndGlobal("reflect/own-keys", ["es6.reflect.own-keys"]),
        preventExtensions: pureAndGlobal("reflect/prevent-extensions", ["es6.reflect.prevent-extensions"]),
        set: pureAndGlobal("reflect/set", ["es6.reflect.set"]),
        setPrototypeOf: pureAndGlobal("reflect/set-prototype-of", ["es6.reflect.set-prototype-of"])
      },
      String: {
        at: pureOnly("string/at", "es7.string.at"),
        fromCodePoint: pureAndGlobal("string/from-code-point", ["es6.string.from-code-point"]),
        raw: pureAndGlobal("string/raw", ["es6.string.raw"])
      },
      Symbol: {
        asyncIterator: globalOnly(["es6.symbol", "es7.symbol.async-iterator"]),
        "for": pureOnly("symbol/for", "es6.symbol"),
        hasInstance: pureOnly("symbol/has-instance", "es6.symbol"),
        isConcatSpreadable: pureOnly("symbol/is-concat-spreadable", "es6.symbol"),
        iterator: define("es6.symbol", "symbol/iterator", CommonIterators),
        keyFor: pureOnly("symbol/key-for", "es6.symbol"),
        match: pureAndGlobal("symbol/match", ["es6.regexp.match"]),
        replace: pureOnly("symbol/replace", "es6.symbol"),
        search: pureOnly("symbol/search", "es6.symbol"),
        species: pureOnly("symbol/species", "es6.symbol"),
        split: pureOnly("symbol/split", "es6.symbol"),
        toPrimitive: pureOnly("symbol/to-primitive", "es6.symbol"),
        toStringTag: pureOnly("symbol/to-string-tag", "es6.symbol"),
        unscopables: pureOnly("symbol/unscopables", "es6.symbol")
      }
    };
    builtInDefinitions.StaticProperties = StaticProperties;
    return builtInDefinitions;
  }

var addPlatformSpecificPolyfills = {};

var hasRequiredAddPlatformSpecificPolyfills;
  function requireAddPlatformSpecificPolyfills() {
    if (hasRequiredAddPlatformSpecificPolyfills) return addPlatformSpecificPolyfills;
    hasRequiredAddPlatformSpecificPolyfills = 1;
    addPlatformSpecificPolyfills.__esModule = true;
    addPlatformSpecificPolyfills["default"] = _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);
    }
    var webPolyfills = {
      "web.timers": {},
      "web.immediate": {},
      "web.dom.iterable": {}
    };
    var purePolyfills = {
      "es6.parse-float": {},
      "es6.parse-int": {},
      "es7.string.at": {}
    };
    function _default(targets, method, polyfills) {
      var targetNames = Object.keys(targets);
      var isAnyTarget = !targetNames.length;
      var isWebTarget = targetNames.some(function (name) {
        return name !== "node";
      });
      return _extends({}, polyfills, method === "usage-pure" ? purePolyfills : null, isAnyTarget || isWebTarget ? webPolyfills : null);
    }
    return addPlatformSpecificPolyfills;
  }

var helpers = {};

var semver = {exports: {}};

var hasRequiredSemver;
  function requireSemver() {
    if (hasRequiredSemver) return semver.exports;
    hasRequiredSemver = 1;
    (function (module, exports) {
      exports = module.exports = SemVer;
      var debug;
      if (typeof browser$1$1 === 'object' && browser$1$1.env && browser$1$1.env.NODE_DEBUG && /\bsemver\b/i.test(browser$1$1.env.NODE_DEBUG)) {
        debug = function debug() {
          var args = Array.prototype.slice.call(arguments, 0);
          args.unshift('SEMVER');
          console.log.apply(console, args);
        };
      } else {
        debug = function debug() {};
      }
      exports.SEMVER_SPEC_VERSION = '2.0.0';
      var MAX_LENGTH = 256;
      var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
      var MAX_SAFE_COMPONENT_LENGTH = 16;
      var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
      var re = exports.re = [];
      var safeRe = exports.safeRe = [];
      var src = exports.src = [];
      var t = exports.tokens = {};
      var R = 0;
      function tok(n) {
        t[n] = R++;
      }
      var LETTERDASHNUMBER = '[a-zA-Z0-9-]';
      var safeRegexReplacements = [['\\s', 1], ['\\d', MAX_LENGTH], [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]];
      function makeSafeRe(value) {
        for (var i = 0; i < safeRegexReplacements.length; i++) {
          var token = safeRegexReplacements[i][0];
          var max = safeRegexReplacements[i][1];
          value = value.split(token + '*').join(token + '{0,' + max + '}').split(token + '+').join(token + '{1,' + max + '}');
        }
        return value;
      }
      tok('NUMERICIDENTIFIER');
      src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*';
      tok('NUMERICIDENTIFIERLOOSE');
      src[t.NUMERICIDENTIFIERLOOSE] = '\\d+';
      tok('NONNUMERICIDENTIFIER');
      src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-]' + LETTERDASHNUMBER + '*';
      tok('MAINVERSION');
      src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')';
      tok('MAINVERSIONLOOSE');
      src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')';
      tok('PRERELEASEIDENTIFIER');
      src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + '|' + src[t.NONNUMERICIDENTIFIER] + ')';
      tok('PRERELEASEIDENTIFIERLOOSE');
      src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + '|' + src[t.NONNUMERICIDENTIFIER] + ')';
      tok('PRERELEASE');
      src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))';
      tok('PRERELEASELOOSE');
      src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))';
      tok('BUILDIDENTIFIER');
      src[t.BUILDIDENTIFIER] = LETTERDASHNUMBER + '+';
      tok('BUILD');
      src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] + '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))';
      tok('FULL');
      tok('FULLPLAIN');
      src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + src[t.PRERELEASE] + '?' + src[t.BUILD] + '?';
      src[t.FULL] = '^' + src[t.FULLPLAIN] + '$';
      tok('LOOSEPLAIN');
      src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + src[t.PRERELEASELOOSE] + '?' + src[t.BUILD] + '?';
      tok('LOOSE');
      src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$';
      tok('GTLT');
      src[t.GTLT] = '((?:<|>)?=?)';
      tok('XRANGEIDENTIFIERLOOSE');
      src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*';
      tok('XRANGEIDENTIFIER');
      src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*';
      tok('XRANGEPLAIN');
      src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:' + src[t.PRERELEASE] + ')?' + src[t.BUILD] + '?' + ')?)?';
      tok('XRANGEPLAINLOOSE');
      src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:' + src[t.PRERELEASELOOSE] + ')?' + src[t.BUILD] + '?' + ')?)?';
      tok('XRANGE');
      src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$';
      tok('XRANGELOOSE');
      src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$';
      tok('COERCE');
      src[t.COERCE] = '(^|[^\\d])' + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:$|[^\\d])';
      tok('COERCERTL');
      re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g');
      safeRe[t.COERCERTL] = new RegExp(makeSafeRe(src[t.COERCE]), 'g');
      tok('LONETILDE');
      src[t.LONETILDE] = '(?:~>?)';
      tok('TILDETRIM');
      src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+';
      re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g');
      safeRe[t.TILDETRIM] = new RegExp(makeSafeRe(src[t.TILDETRIM]), 'g');
      var tildeTrimReplace = '$1~';
      tok('TILDE');
      src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$';
      tok('TILDELOOSE');
      src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$';
      tok('LONECARET');
      src[t.LONECARET] = '(?:\\^)';
      tok('CARETTRIM');
      src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+';
      re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g');
      safeRe[t.CARETTRIM] = new RegExp(makeSafeRe(src[t.CARETTRIM]), 'g');
      var caretTrimReplace = '$1^';
      tok('CARET');
      src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$';
      tok('CARETLOOSE');
      src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$';
      tok('COMPARATORLOOSE');
      src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$';
      tok('COMPARATOR');
      src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$';
      tok('COMPARATORTRIM');
      src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')';
      re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g');
      safeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(src[t.COMPARATORTRIM]), 'g');
      var comparatorTrimReplace = '$1$2$3';
      tok('HYPHENRANGE');
      src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAIN] + ')' + '\\s*$';
      tok('HYPHENRANGELOOSE');
      src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s*$';
      tok('STAR');
      src[t.STAR] = '(<|>)?=?\\s*\\*';
      for (var i = 0; i < R; i++) {
        debug(i, src[i]);
        if (!re[i]) {
          re[i] = new RegExp(src[i]);
          safeRe[i] = new RegExp(makeSafeRe(src[i]));
        }
      }
      exports.parse = parse;
      function parse(version, options) {
        if (!options || typeof options !== 'object') {
          options = {
            loose: !!options,
            includePrerelease: false
          };
        }
        if (version instanceof SemVer) {
          return version;
        }
        if (typeof version !== 'string') {
          return null;
        }
        if (version.length > MAX_LENGTH) {
          return null;
        }
        var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL];
        if (!r.test(version)) {
          return null;
        }
        try {
          return new SemVer(version, options);
        } catch (er) {
          return null;
        }
      }
      exports.valid = valid;
      function valid(version, options) {
        var v = parse(version, options);
        return v ? v.version : null;
      }
      exports.clean = clean;
      function clean(version, options) {
        var s = parse(version.trim().replace(/^[=v]+/, ''), options);
        return s ? s.version : null;
      }
      exports.SemVer = SemVer;
      function SemVer(version, options) {
        if (!options || typeof options !== 'object') {
          options = {
            loose: !!options,
            includePrerelease: false
          };
        }
        if (version instanceof SemVer) {
          if (version.loose === options.loose) {
            return version;
          } else {
            version = version.version;
          }
        } else if (typeof version !== 'string') {
          throw new TypeError('Invalid Version: ' + version);
        }
        if (version.length > MAX_LENGTH) {
          throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters');
        }
        if (!(this instanceof SemVer)) {
          return new SemVer(version, options);
        }
        debug('SemVer', version, options);
        this.options = options;
        this.loose = !!options.loose;
        var m = version.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]);
        if (!m) {
          throw new TypeError('Invalid Version: ' + version);
        }
        this.raw = version;
        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 i = 0;
        do {
          var a = this.prerelease[i];
          var b = other.prerelease[i];
          debug('prerelease compare', i, a, b);
          if (a === undefined && b === undefined) {
            return 0;
          } else if (b === undefined) {
            return 1;
          } else if (a === undefined) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      };
      SemVer.prototype.compareBuild = function (other) {
        if (!(other instanceof SemVer)) {
          other = new SemVer(other, this.options);
        }
        var i = 0;
        do {
          var a = this.build[i];
          var b = other.build[i];
          debug('prerelease compare', i, a, b);
          if (a === undefined && b === undefined) {
            return 0;
          } else if (b === undefined) {
            return 1;
          } else if (a === undefined) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      };
      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 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 (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(version, release, loose, identifier) {
        if (typeof loose === 'string') {
          identifier = loose;
          loose = undefined;
        }
        try {
          return new SemVer(version, loose).inc(release, identifier).version;
        } catch (er) {
          return null;
        }
      }
      exports.diff = diff;
      function diff(version1, version2) {
        if (eq(version1, version2)) {
          return null;
        } else {
          var v1 = parse(version1);
          var v2 = parse(version2);
          var prefix = '';
          if (v1.prerelease.length || v2.prerelease.length) {
            prefix = 'pre';
            var defaultResult = 'prerelease';
          }
          for (var key in v1) {
            if (key === 'major' || key === 'minor' || key === 'patch') {
              if (v1[key] !== v2[key]) {
                return prefix + key;
              }
            }
          }
          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 = patch;
      function patch(a, loose) {
        return new SemVer(a, loose).patch;
      }
      exports.compare = compare;
      function compare(a, b, loose) {
        return new SemVer(a, loose).compare(new SemVer(b, loose));
      }
      exports.compareLoose = compareLoose;
      function compareLoose(a, b) {
        return compare(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 compare(b, a, loose);
      }
      exports.sort = sort;
      function sort(list, loose) {
        return list.sort(function (a, b) {
          return exports.compareBuild(a, b, loose);
        });
      }
      exports.rsort = rsort;
      function rsort(list, loose) {
        return list.sort(function (a, b) {
          return exports.compareBuild(b, a, loose);
        });
      }
      exports.gt = gt;
      function gt(a, b, loose) {
        return compare(a, b, loose) > 0;
      }
      exports.lt = lt;
      function lt(a, b, loose) {
        return compare(a, b, loose) < 0;
      }
      exports.eq = eq;
      function eq(a, b, loose) {
        return compare(a, b, loose) === 0;
      }
      exports.neq = neq;
      function neq(a, b, loose) {
        return compare(a, b, loose) !== 0;
      }
      exports.gte = gte;
      function gte(a, b, loose) {
        return compare(a, b, loose) >= 0;
      }
      exports.lte = lte;
      function lte(a, b, loose) {
        return compare(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);
        }
        comp = comp.trim().split(/\s+/).join(' ');
        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 ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];
        var m = comp.match(r);
        if (!m) {
          throw new TypeError('Invalid comparator: ' + comp);
        }
        this.operator = m[1] !== undefined ? 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 (version) {
        debug('Comparator.test', version, this.options.loose);
        if (this.semver === ANY || version === ANY) {
          return true;
        }
        if (typeof version === 'string') {
          try {
            version = new SemVer(version, this.options);
          } catch (er) {
            return false;
          }
        }
        return cmp(version, 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.trim().split(/\s+/).join(' ');
        this.set = this.raw.split('||').map(function (range) {
          return this.parseRange(range.trim());
        }, this).filter(function (c) {
          return c.length;
        });
        if (!this.set.length) {
          throw new TypeError('Invalid SemVer Range: ' + this.raw);
        }
        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;
        var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE];
        range = range.replace(hr, hyphenReplace);
        debug('hyphen replace', range);
        range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace);
        debug('comparator trim', range, safeRe[t.COMPARATORTRIM]);
        range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace);
        range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace);
        range = range.split(/\s+/).join(' ');
        var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.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 (c) {
            return c.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 (comp) {
          return replaceTilde(comp, options);
        }).join(' ');
      }
      function replaceTilde(comp, options) {
        var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.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 (comp) {
          return replaceCaret(comp, options);
        }).join(' ');
      }
      function replaceCaret(comp, options) {
        debug('caret', comp, options);
        var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.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 (comp) {
          return replaceXRange(comp, options);
        }).join(' ');
      }
      function replaceXRange(comp, options) {
        comp = comp.trim();
        var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.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(safeRe[t.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 (version) {
        if (!version) {
          return false;
        }
        if (typeof version === 'string') {
          try {
            version = new SemVer(version, this.options);
          } catch (er) {
            return false;
          }
        }
        for (var i = 0; i < this.set.length; i++) {
          if (testSet(this.set[i], version, this.options)) {
            return true;
          }
        }
        return false;
      };
      function testSet(set, version, options) {
        for (var i = 0; i < set.length; i++) {
          if (!set[i].test(version)) {
            return false;
          }
        }
        if (version.prerelease.length && !options.includePrerelease) {
          for (i = 0; i < set.length; i++) {
            debug(set[i].semver);
            if (set[i].semver === ANY) {
              continue;
            }
            if (set[i].semver.prerelease.length > 0) {
              var allowed = set[i].semver;
              if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
                return true;
              }
            }
          }
          return false;
        }
        return true;
      }
      exports.satisfies = satisfies;
      function satisfies(version, range, options) {
        try {
          range = new Range(range, options);
        } catch (er) {
          return false;
        }
        return range.test(version);
      }
      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 i = 0; i < range.set.length; ++i) {
          var comparators = range.set[i];
          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(version, range, options) {
        return outside(version, range, '<', options);
      }
      exports.gtr = gtr;
      function gtr(version, range, options) {
        return outside(version, range, '>', options);
      }
      exports.outside = outside;
      function outside(version, range, hilo, options) {
        version = new SemVer(version, 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(version, range, options)) {
          return false;
        }
        for (var i = 0; i < range.set.length; ++i) {
          var comparators = range.set[i];
          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(version, low.semver)) {
            return false;
          } else if (low.operator === ecomp && ltfn(version, low.semver)) {
            return false;
          }
        }
        return true;
      }
      exports.prerelease = prerelease;
      function prerelease(version, options) {
        var parsed = parse(version, 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(version, options) {
        if (version instanceof SemVer) {
          return version;
        }
        if (typeof version === 'number') {
          version = String(version);
        }
        if (typeof version !== 'string') {
          return null;
        }
        options = options || {};
        var match = null;
        if (!options.rtl) {
          match = version.match(safeRe[t.COERCE]);
        } else {
          var next;
          while ((next = safeRe[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
            if (!match || next.index + next[0].length !== match.index + match[0].length) {
              match = next;
            }
            safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
          }
          safeRe[t.COERCERTL].lastIndex = -1;
        }
        if (match === null) {
          return null;
        }
        return parse(match[2] + '.' + (match[3] || '0') + '.' + (match[4] || '0'), options);
      }
    })(semver, semver.exports);
    return semver.exports;
  }

var hasRequiredHelpers;
  function requireHelpers() {
    if (hasRequiredHelpers) return helpers;
    hasRequiredHelpers = 1;
    helpers.__esModule = true;
    helpers.hasMinVersion = hasMinVersion;
    var _semver = _interopRequireDefault(requireSemver());
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    function hasMinVersion(minVersion, runtimeVersion) {
      if (!runtimeVersion || !minVersion) return true;
      runtimeVersion = String(runtimeVersion);
      if (_semver["default"].valid(runtimeVersion)) runtimeVersion = "^" + runtimeVersion;
      return !_semver["default"].intersects("<" + minVersion, runtimeVersion) && !_semver["default"].intersects(">=8.0.0", runtimeVersion);
    }
    return helpers;
  }

var lib$1 = {};

var utils$1 = {};

var _templateObject$3, _templateObject2$2, _templateObject3$2;
  var hasRequiredUtils$1;
  function requireUtils$1() {
    if (hasRequiredUtils$1) return utils$1;
    hasRequiredUtils$1 = 1;
    utils$1.__esModule = true;
    utils$1.createUtilsGetter = createUtilsGetter;
    utils$1.getImportSource = getImportSource;
    utils$1.getRequireSource = getRequireSource;
    utils$1.has = has;
    utils$1.intersection = intersection;
    utils$1.resolveKey = resolveKey;
    utils$1.resolveSource = resolveSource;
    var _babel = _interopRequireWildcard(require$$5);
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    var _ref = _babel["default"] || _babel,
      t = _ref.types,
      template = _ref.template;
    function intersection(a, b) {
      var result = new Set();
      a.forEach(function (v) {
        return b.has(v) && result.add(v);
      });
      return result;
    }
    function has(object, key) {
      return Object.prototype.hasOwnProperty.call(object, key);
    }
    function getType(target) {
      return Object.prototype.toString.call(target).slice(8, -1);
    }
    function resolveId(path) {
      if (path.isIdentifier() && !path.scope.hasBinding(path.node.name, true)) {
        return path.node.name;
      }
      if (path.isPure()) {
        var _path$evaluate = path.evaluate(),
          deopt = _path$evaluate.deopt;
        if (deopt && deopt.isIdentifier()) {
          return deopt.node.name;
        }
      }
    }
    function resolveKey(path, computed) {
      if (computed === void 0) {
        computed = false;
      }
      var scope = path.scope;
      if (path.isStringLiteral()) return path.node.value;
      var isIdentifier = path.isIdentifier();
      if (isIdentifier && !(computed || path.parent.computed)) {
        return path.node.name;
      }
      if (computed && path.isMemberExpression() && path.get("object").isIdentifier({
        name: "Symbol"
      }) && !scope.hasBinding("Symbol", true)) {
        var sym = resolveKey(path.get("property"), path.node.computed);
        if (sym) return "Symbol." + sym;
      }
      if (isIdentifier ? scope.hasBinding(path.node.name, true) : path.isPure()) {
        var _path$evaluate2 = path.evaluate(),
          value = _path$evaluate2.value;
        if (typeof value === "string") return value;
      }
    }
    function resolveSource(obj) {
      if (obj.isMemberExpression() && obj.get("property").isIdentifier({
        name: "prototype"
      })) {
        var _id = resolveId(obj.get("object"));
        if (_id) {
          return {
            id: _id,
            placement: "prototype"
          };
        }
        return {
          id: null,
          placement: null
        };
      }
      var id = resolveId(obj);
      if (id) {
        return {
          id: id,
          placement: "static"
        };
      }
      if (obj.isRegExpLiteral()) {
        return {
          id: "RegExp",
          placement: "prototype"
        };
      } else if (obj.isFunction()) {
        return {
          id: "Function",
          placement: "prototype"
        };
      } else if (obj.isPure()) {
        var _obj$evaluate = obj.evaluate(),
          value = _obj$evaluate.value;
        if (value !== undefined) {
          return {
            id: getType(value),
            placement: "prototype"
          };
        }
      }
      return {
        id: null,
        placement: null
      };
    }
    function getImportSource(_ref2) {
      var node = _ref2.node;
      if (node.specifiers.length === 0) return node.source.value;
    }
    function getRequireSource(_ref3) {
      var node = _ref3.node;
      if (!t.isExpressionStatement(node)) return;
      var expression = node.expression;
      if (t.isCallExpression(expression) && t.isIdentifier(expression.callee) && expression.callee.name === "require" && expression.arguments.length === 1 && t.isStringLiteral(expression.arguments[0])) {
        return expression.arguments[0].value;
      }
    }
    function hoist(node) {
      node._blockHoist = 3;
      return node;
    }
    function createUtilsGetter(cache) {
      return function (path) {
        var prog = path.findParent(function (p) {
          return p.isProgram();
        });
        return {
          injectGlobalImport: function injectGlobalImport(url, moduleName) {
            cache.storeAnonymous(prog, url, moduleName, function (isScript, source) {
              return isScript ? template.statement.ast(_templateObject$3 || (_templateObject$3 = _taggedTemplateLiteralLoose(["require(", ")"])), source) : t.importDeclaration([], source);
            });
          },
          injectNamedImport: function injectNamedImport(url, name, hint, moduleName) {
            if (hint === void 0) {
              hint = name;
            }
            return cache.storeNamed(prog, url, name, moduleName, function (isScript, source, name) {
              var id = prog.scope.generateUidIdentifier(hint);
              return {
                node: isScript ? hoist(template.statement.ast(_templateObject2$2 || (_templateObject2$2 = _taggedTemplateLiteralLoose(["\n                  var ", " = require(", ").", "\n                "])), id, source, name)) : t.importDeclaration([t.importSpecifier(id, name)], source),
                name: id.name
              };
            });
          },
          injectDefaultImport: function injectDefaultImport(url, hint, moduleName) {
            if (hint === void 0) {
              hint = url;
            }
            return cache.storeNamed(prog, url, "default", moduleName, function (isScript, source) {
              var id = prog.scope.generateUidIdentifier(hint);
              return {
                node: isScript ? hoist(template.statement.ast(_templateObject3$2 || (_templateObject3$2 = _taggedTemplateLiteralLoose(["var ", " = require(", ")"])), id, source)) : t.importDeclaration([t.importDefaultSpecifier(id)], source),
                name: id.name
              };
            });
          }
        };
      };
    }
    return utils$1;
  }

var importsInjector = {};

var hasRequiredImportsInjector;
  function requireImportsInjector() {
    if (hasRequiredImportsInjector) return importsInjector;
    hasRequiredImportsInjector = 1;
    importsInjector.__esModule = true;
    importsInjector["default"] = void 0;
    var _babel = _interopRequireWildcard(require$$5);
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    var _ref = _babel["default"] || _babel,
      t = _ref.types;
    var ImportsCachedInjector = function () {
      function ImportsCachedInjector(resolver, getPreferredIndex) {
        this._imports = new WeakMap();
        this._anonymousImports = new WeakMap();
        this._lastImports = new WeakMap();
        this._resolver = resolver;
        this._getPreferredIndex = getPreferredIndex;
      }
      var _proto = ImportsCachedInjector.prototype;
      _proto.storeAnonymous = function storeAnonymous(programPath, url, moduleName, getVal) {
        var key = this._normalizeKey(programPath, url);
        var imports = this._ensure(this._anonymousImports, programPath, Set);
        if (imports.has(key)) return;
        var node = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)));
        imports.add(key);
        this._injectImport(programPath, node, moduleName);
      };
      _proto.storeNamed = function storeNamed(programPath, url, name, moduleName, getVal) {
        var key = this._normalizeKey(programPath, url, name);
        var imports = this._ensure(this._imports, programPath, Map);
        if (!imports.has(key)) {
          var _getVal = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)), t.identifier(name)),
            node = _getVal.node,
            id = _getVal.name;
          imports.set(key, id);
          this._injectImport(programPath, node, moduleName);
        }
        return t.identifier(imports.get(key));
      };
      _proto._injectImport = function _injectImport(programPath, node, moduleName) {
        var _this$_lastImports$ge;
        var newIndex = this._getPreferredIndex(moduleName);
        var lastImports = (_this$_lastImports$ge = this._lastImports.get(programPath)) != null ? _this$_lastImports$ge : [];
        var isPathStillValid = function isPathStillValid(path) {
          return path.node && path.parent === programPath.node && path.container === programPath.node.body;
        };
        var last;
        if (newIndex === Infinity) {
          if (lastImports.length > 0) {
            last = lastImports[lastImports.length - 1].path;
            if (!isPathStillValid(last)) last = undefined;
          }
        } else {
          for (var _iterator = _createForOfIteratorHelperLoose(lastImports.entries()), _step; !(_step = _iterator()).done;) {
            var _step$value = _slicedToArray(_step.value, 2),
              i = _step$value[0],
              data = _step$value[1];
            var path = data.path,
              index = data.index;
            if (isPathStillValid(path)) {
              if (newIndex < index) {
                var _path$insertBefore = path.insertBefore(node),
                  _path$insertBefore2 = _slicedToArray(_path$insertBefore, 1),
                  newPath = _path$insertBefore2[0];
                lastImports.splice(i, 0, {
                  path: newPath,
                  index: newIndex
                });
                return;
              }
              last = path;
            }
          }
        }
        if (last) {
          var _last$insertAfter = last.insertAfter(node),
            _last$insertAfter2 = _slicedToArray(_last$insertAfter, 1),
            _newPath = _last$insertAfter2[0];
          lastImports.push({
            path: _newPath,
            index: newIndex
          });
        } else {
          var _programPath$unshiftC = programPath.unshiftContainer("body", node),
            _programPath$unshiftC2 = _slicedToArray(_programPath$unshiftC, 1),
            _newPath2 = _programPath$unshiftC2[0];
          this._lastImports.set(programPath, [{
            path: _newPath2,
            index: newIndex
          }]);
        }
      };
      _proto._ensure = function _ensure(map, programPath, Collection) {
        var collection = map.get(programPath);
        if (!collection) {
          collection = new Collection();
          map.set(programPath, collection);
        }
        return collection;
      };
      _proto._normalizeKey = function _normalizeKey(programPath, url, name) {
        if (name === void 0) {
          name = "";
        }
        var sourceType = programPath.node.sourceType;
        return (name && sourceType) + "::" + url + "::" + name;
      };
      return _createClass(ImportsCachedInjector);
    }();
    importsInjector["default"] = ImportsCachedInjector;
    return importsInjector;
  }

var debugUtils = {};

var hasRequiredDebugUtils;
  function requireDebugUtils() {
    if (hasRequiredDebugUtils) return debugUtils;
    hasRequiredDebugUtils = 1;
    debugUtils.__esModule = true;
    debugUtils.presetEnvSilentDebugHeader = void 0;
    debugUtils.stringifyTargets = stringifyTargets;
    debugUtils.stringifyTargetsMultiline = stringifyTargetsMultiline;
    var _helperCompilationTargets = require$$1$2;
    var presetEnvSilentDebugHeader = "#__secret_key__@babel/preset-env__don't_log_debug_header_and_resolved_targets";
    debugUtils.presetEnvSilentDebugHeader = presetEnvSilentDebugHeader;
    function stringifyTargetsMultiline(targets) {
      return JSON.stringify((0, _helperCompilationTargets.prettifyTargets)(targets), null, 2);
    }
    function stringifyTargets(targets) {
      return JSON.stringify(targets).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');
    }
    return debugUtils;
  }

var normalizeOptions$4 = {};

var hasRequiredNormalizeOptions;
  function requireNormalizeOptions() {
    if (hasRequiredNormalizeOptions) return normalizeOptions$4;
    hasRequiredNormalizeOptions = 1;
    normalizeOptions$4.__esModule = true;
    normalizeOptions$4.applyMissingDependenciesDefaults = applyMissingDependenciesDefaults;
    normalizeOptions$4.validateIncludeExclude = validateIncludeExclude;
    var _utils = requireUtils$1();
    function patternToRegExp(pattern) {
      if (pattern instanceof RegExp) return pattern;
      try {
        return new RegExp("^" + pattern + "$");
      } catch (_unused) {
        return null;
      }
    }
    function buildUnusedError(label, unused) {
      if (!unused.length) return "";
      return "  - The following \"" + label + "\" patterns didn't match any polyfill:\n" + unused.map(function (original) {
        return "    " + String(original) + "\n";
      }).join("");
    }
    function buldDuplicatesError(duplicates) {
      if (!duplicates.size) return "";
      return "  - The following polyfills were matched both by \"include\" and \"exclude\" patterns:\n" + Array.from(duplicates, function (name) {
        return "    " + name + "\n";
      }).join("");
    }
    function validateIncludeExclude(provider, polyfills, includePatterns, excludePatterns) {
      var current;
      var filter = function filter(pattern) {
        var regexp = patternToRegExp(pattern);
        if (!regexp) return false;
        var matched = false;
        for (var _iterator = _createForOfIteratorHelperLoose(polyfills.keys()), _step; !(_step = _iterator()).done;) {
          var polyfill = _step.value;
          if (regexp.test(polyfill)) {
            matched = true;
            current.add(polyfill);
          }
        }
        return !matched;
      };
      var include = current = new Set();
      var unusedInclude = Array.from(includePatterns).filter(filter);
      var exclude = current = new Set();
      var unusedExclude = Array.from(excludePatterns).filter(filter);
      var duplicates = (0, _utils.intersection)(include, exclude);
      if (duplicates.size > 0 || unusedInclude.length > 0 || unusedExclude.length > 0) {
        throw new Error("Error while validating the \"" + provider + "\" provider options:\n" + buildUnusedError("include", unusedInclude) + buildUnusedError("exclude", unusedExclude) + buldDuplicatesError(duplicates));
      }
      return {
        include: include,
        exclude: exclude
      };
    }
    function applyMissingDependenciesDefaults(options, babelApi) {
      var _options$missingDepen = options.missingDependencies,
        missingDependencies = _options$missingDepen === void 0 ? {} : _options$missingDepen;
      if (missingDependencies === false) return false;
      var caller = babelApi.caller(function (caller) {
        return caller == null ? void 0 : caller.name;
      });
      var _missingDependencies$ = missingDependencies.log,
        log = _missingDependencies$ === void 0 ? "deferred" : _missingDependencies$,
        _missingDependencies$2 = missingDependencies.inject,
        inject = _missingDependencies$2 === void 0 ? caller === "rollup-plugin-babel" ? "throw" : "import" : _missingDependencies$2,
        _missingDependencies$3 = missingDependencies.all,
        all = _missingDependencies$3 === void 0 ? false : _missingDependencies$3;
      return {
        log: log,
        inject: inject,
        all: all
      };
    }
    return normalizeOptions$4;
  }

var visitors = {};

var usage$1 = {};

var hasRequiredUsage;
  function requireUsage() {
    if (hasRequiredUsage) return usage$1;
    hasRequiredUsage = 1;
    usage$1.__esModule = true;
    usage$1["default"] = void 0;
    var _utils = requireUtils$1();
    function isRemoved(path) {
      if (path.removed) return true;
      if (!path.parentPath) return false;
      if (path.listKey) {
        var _path$parentPath$node;
        if (!((_path$parentPath$node = path.parentPath.node) != null && (_path$parentPath$node = _path$parentPath$node[path.listKey]) != null && _path$parentPath$node.includes(path.node))) return true;
      } else {
        if (path.parentPath.node[path.key] !== path.node) return true;
      }
      return isRemoved(path.parentPath);
    }
    var _default = function _default(callProvider) {
      function property(object, key, placement, path) {
        return callProvider({
          kind: "property",
          object: object,
          key: key,
          placement: placement
        }, path);
      }
      function handleReferencedIdentifier(path) {
        var name = path.node.name,
          scope = path.scope;
        if (scope.getBindingIdentifier(name)) return;
        callProvider({
          kind: "global",
          name: name
        }, path);
      }
      function analyzeMemberExpression(path) {
        var key = (0, _utils.resolveKey)(path.get("property"), path.node.computed);
        return {
          key: key,
          handleAsMemberExpression: !!key && key !== "prototype"
        };
      }
      return {
        ReferencedIdentifier: function ReferencedIdentifier(path) {
          var parentPath = path.parentPath;
          if (parentPath.isMemberExpression({
            object: path.node
          }) && analyzeMemberExpression(parentPath).handleAsMemberExpression) {
            return;
          }
          handleReferencedIdentifier(path);
        },
        MemberExpression: function MemberExpression(path) {
          var _analyzeMemberExpress = analyzeMemberExpression(path),
            key = _analyzeMemberExpress.key,
            handleAsMemberExpression = _analyzeMemberExpress.handleAsMemberExpression;
          if (!handleAsMemberExpression) return;
          var object = path.get("object");
          var objectIsGlobalIdentifier = object.isIdentifier();
          if (objectIsGlobalIdentifier) {
            var binding = object.scope.getBinding(object.node.name);
            if (binding) {
              if (binding.path.isImportNamespaceSpecifier()) return;
              objectIsGlobalIdentifier = false;
            }
          }
          var source = (0, _utils.resolveSource)(object);
          var skipObject = property(source.id, key, source.placement, path);
          skipObject || (skipObject = !objectIsGlobalIdentifier || path.shouldSkip || object.shouldSkip || isRemoved(object));
          if (!skipObject) handleReferencedIdentifier(object);
        },
        ObjectPattern: function ObjectPattern(path) {
          var parentPath = path.parentPath,
            parent = path.parent;
          var obj;
          if (parentPath.isVariableDeclarator()) {
            obj = parentPath.get("init");
          } else if (parentPath.isAssignmentExpression()) {
            obj = parentPath.get("right");
          } else if (parentPath.isFunction()) {
            var grand = parentPath.parentPath;
            if (grand.isCallExpression() || grand.isNewExpression()) {
              if (grand.node.callee === parent) {
                obj = grand.get("arguments")[path.key];
              }
            }
          }
          var id = null;
          var placement = null;
          if (obj) {
            var _ref = (0, _utils.resolveSource)(obj);
            id = _ref.id;
            placement = _ref.placement;
          }
          for (var _iterator = _createForOfIteratorHelperLoose(path.get("properties")), _step; !(_step = _iterator()).done;) {
            var prop = _step.value;
            if (prop.isObjectProperty()) {
              var key = (0, _utils.resolveKey)(prop.get("key"));
              if (key) property(id, key, placement, prop);
            }
          }
        },
        BinaryExpression: function BinaryExpression(path) {
          if (path.node.operator !== "in") return;
          var source = (0, _utils.resolveSource)(path.get("right"));
          var key = (0, _utils.resolveKey)(path.get("left"), true);
          if (!key) return;
          callProvider({
            kind: "in",
            object: source.id,
            key: key,
            placement: source.placement
          }, path);
        }
      };
    };
    usage$1["default"] = _default;
    return usage$1;
  }

var entry$1 = {};

var hasRequiredEntry;
  function requireEntry() {
    if (hasRequiredEntry) return entry$1;
    hasRequiredEntry = 1;
    entry$1.__esModule = true;
    entry$1["default"] = void 0;
    var _utils = requireUtils$1();
    var _default = function _default(callProvider) {
      return {
        ImportDeclaration: function ImportDeclaration(path) {
          var source = (0, _utils.getImportSource)(path);
          if (!source) return;
          callProvider({
            kind: "import",
            source: source
          }, path);
        },
        Program: function Program(path) {
          path.get("body").forEach(function (bodyPath) {
            var source = (0, _utils.getRequireSource)(bodyPath);
            if (!source) return;
            callProvider({
              kind: "import",
              source: source
            }, bodyPath);
          });
        }
      };
    };
    entry$1["default"] = _default;
    return entry$1;
  }

var hasRequiredVisitors;
  function requireVisitors() {
    if (hasRequiredVisitors) return visitors;
    hasRequiredVisitors = 1;
    visitors.__esModule = true;
    visitors.usage = visitors.entry = void 0;
    var _usage = _interopRequireDefault(requireUsage());
    visitors.usage = _usage["default"];
    var _entry = _interopRequireDefault(requireEntry());
    visitors.entry = _entry["default"];
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    return visitors;
  }

var dependencies = {};

var hasRequiredDependencies;
  function requireDependencies() {
    if (hasRequiredDependencies) return dependencies;
    hasRequiredDependencies = 1;
    dependencies.__esModule = true;
    dependencies.has = has;
    dependencies.laterLogMissing = laterLogMissing;
    dependencies.logMissing = logMissing;
    dependencies.resolve = resolve;
    function resolve(dirname, moduleName, absoluteImports) {
      if (absoluteImports === false) return moduleName;
      throw new Error("\"absoluteImports\" is not supported in bundles prepared for the browser.");
    }
    function has(basedir, name) {
      return true;
    }
    function logMissing(missingDeps) {}
    function laterLogMissing(missingDeps) {}
    return dependencies;
  }

var metaResolver = {};

var hasRequiredMetaResolver;
  function requireMetaResolver() {
    if (hasRequiredMetaResolver) return metaResolver;
    hasRequiredMetaResolver = 1;
    metaResolver.__esModule = true;
    metaResolver["default"] = createMetaResolver;
    var _utils = requireUtils$1();
    var PossibleGlobalObjects = new Set(["global", "globalThis", "self", "window"]);
    function createMetaResolver(polyfills) {
      var staticP = polyfills["static"],
        instanceP = polyfills.instance,
        globalP = polyfills.global;
      return function (meta) {
        if (meta.kind === "global" && globalP && (0, _utils.has)(globalP, meta.name)) {
          return {
            kind: "global",
            desc: globalP[meta.name],
            name: meta.name
          };
        }
        if (meta.kind === "property" || meta.kind === "in") {
          var placement = meta.placement,
            object = meta.object,
            key = meta.key;
          if (object && placement === "static") {
            if (globalP && PossibleGlobalObjects.has(object) && (0, _utils.has)(globalP, key)) {
              return {
                kind: "global",
                desc: globalP[key],
                name: key
              };
            }
            if (staticP && (0, _utils.has)(staticP, object) && (0, _utils.has)(staticP[object], key)) {
              return {
                kind: "static",
                desc: staticP[object][key],
                name: object + "$" + key
              };
            }
          }
          if (instanceP && (0, _utils.has)(instanceP, key)) {
            return {
              kind: "instance",
              desc: instanceP[key],
              name: "" + key
            };
          }
        }
      };
    }
    return metaResolver;
  }

var hasRequiredLib$2;
  function requireLib$2() {
    if (hasRequiredLib$2) return lib$1;
    hasRequiredLib$2 = 1;
    lib$1.__esModule = true;
    lib$1["default"] = definePolyfillProvider;
    var _helperPluginUtils = require$$0$6;
    var _helperCompilationTargets = _interopRequireWildcard(require$$1$2);
    var _utils = requireUtils$1();
    var _importsInjector = _interopRequireDefault(requireImportsInjector());
    var _debugUtils = requireDebugUtils();
    var _normalizeOptions = requireNormalizeOptions();
    var v = _interopRequireWildcard(requireVisitors());
    var deps = _interopRequireWildcard(requireDependencies());
    var _metaResolver = _interopRequireDefault(requireMetaResolver());
    var _excluded = ["method", "targets", "ignoreBrowserslistConfig", "configPath", "debug", "shouldInjectPolyfill", "absoluteImports"];
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    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;
    }
    var getTargets = _helperCompilationTargets["default"]["default"] || _helperCompilationTargets["default"];
    function resolveOptions(options, babelApi) {
      var method = options.method,
        targetsOption = options.targets,
        ignoreBrowserslistConfig = options.ignoreBrowserslistConfig,
        configPath = options.configPath,
        debug = options.debug,
        shouldInjectPolyfill = options.shouldInjectPolyfill,
        absoluteImports = options.absoluteImports,
        providerOptions = _objectWithoutPropertiesLoose(options, _excluded);
      if (isEmpty(options)) {
        throw new Error("This plugin requires options, for example:\n    {\n      \"plugins\": [\n        [\"<plugin name>\", { method: \"usage-pure\" }]\n      ]\n    }\n\nSee more options at https://github.com/babel/babel-polyfills/blob/main/docs/usage.md");
      }
      var methodName;
      if (method === "usage-global") methodName = "usageGlobal";else if (method === "entry-global") methodName = "entryGlobal";else if (method === "usage-pure") methodName = "usagePure";else if (typeof method !== "string") {
        throw new Error(".method must be a string");
      } else {
        throw new Error(".method must be one of \"entry-global\", \"usage-global\"" + (" or \"usage-pure\" (received " + JSON.stringify(method) + ")"));
      }
      if (typeof shouldInjectPolyfill === "function") {
        if (options.include || options.exclude) {
          throw new Error(".include and .exclude are not supported when using the" + " .shouldInjectPolyfill function.");
        }
      } else if (shouldInjectPolyfill != null) {
        throw new Error(".shouldInjectPolyfill must be a function, or undefined" + (" (received " + JSON.stringify(shouldInjectPolyfill) + ")"));
      }
      if (absoluteImports != null && typeof absoluteImports !== "boolean" && typeof absoluteImports !== "string") {
        throw new Error(".absoluteImports must be a boolean, a string, or undefined" + (" (received " + JSON.stringify(absoluteImports) + ")"));
      }
      var targets;
      if (targetsOption || configPath || ignoreBrowserslistConfig) {
        var targetsObj = typeof targetsOption === "string" || Array.isArray(targetsOption) ? {
          browsers: targetsOption
        } : targetsOption;
        targets = getTargets(targetsObj, {
          ignoreBrowserslistConfig: ignoreBrowserslistConfig,
          configPath: configPath
        });
      } else {
        targets = babelApi.targets();
      }
      return {
        method: method,
        methodName: methodName,
        targets: targets,
        absoluteImports: absoluteImports != null ? absoluteImports : false,
        shouldInjectPolyfill: shouldInjectPolyfill,
        debug: !!debug,
        providerOptions: providerOptions
      };
    }
    function instantiateProvider(factory, options, missingDependencies, dirname, debugLog, babelApi) {
      var _resolveOptions = resolveOptions(options, babelApi),
        method = _resolveOptions.method,
        methodName = _resolveOptions.methodName,
        targets = _resolveOptions.targets,
        _debug = _resolveOptions.debug,
        _shouldInjectPolyfill = _resolveOptions.shouldInjectPolyfill,
        providerOptions = _resolveOptions.providerOptions,
        absoluteImports = _resolveOptions.absoluteImports;
      var include, exclude;
      var polyfillsSupport;
      var polyfillsNames;
      var filterPolyfills;
      var getUtils = (0, _utils.createUtilsGetter)(new _importsInjector["default"](function (moduleName) {
        return deps.resolve(dirname, moduleName, absoluteImports);
      }, function (name) {
        var _polyfillsNames$get, _polyfillsNames;
        return (_polyfillsNames$get = (_polyfillsNames = polyfillsNames) == null ? void 0 : _polyfillsNames.get(name)) != null ? _polyfillsNames$get : Infinity;
      }));
      var depsCache = new Map();
      var api = {
        babel: babelApi,
        getUtils: getUtils,
        method: options.method,
        targets: targets,
        createMetaResolver: _metaResolver["default"],
        shouldInjectPolyfill: function shouldInjectPolyfill(name) {
          if (polyfillsNames === undefined) {
            throw new Error("Internal error in the " + factory.name + " provider: " + "shouldInjectPolyfill() can't be called during initialization.");
          }
          if (!polyfillsNames.has(name)) {
            console.warn("Internal error in the " + providerName + " provider: " + ("unknown polyfill \"" + name + "\"."));
          }
          if (filterPolyfills && !filterPolyfills(name)) return false;
          var shouldInject = (0, _helperCompilationTargets.isRequired)(name, targets, {
            compatData: polyfillsSupport,
            includes: include,
            excludes: exclude
          });
          if (_shouldInjectPolyfill) {
            shouldInject = _shouldInjectPolyfill(name, shouldInject);
            if (typeof shouldInject !== "boolean") {
              throw new Error(".shouldInjectPolyfill must return a boolean.");
            }
          }
          return shouldInject;
        },
        debug: function debug(name) {
          var _debugLog, _debugLog$polyfillsSu;
          debugLog().found = true;
          if (!_debug || !name) return;
          if (debugLog().polyfills.has(providerName)) return;
          debugLog().polyfills.add(name);
          (_debugLog$polyfillsSu = (_debugLog = debugLog()).polyfillsSupport) != null ? _debugLog$polyfillsSu : _debugLog.polyfillsSupport = polyfillsSupport;
        },
        assertDependency: function assertDependency(name, version) {
          if (version === void 0) {
            version = "*";
          }
          if (missingDependencies === false) return;
          if (absoluteImports) {
            return;
          }
          var dep = version === "*" ? name : name + "@^" + version;
          var found = missingDependencies.all ? false : mapGetOr(depsCache, name + " :: " + dirname, function () {
            return deps.has(dirname, name);
          });
          if (!found) {
            debugLog().missingDeps.add(dep);
          }
        }
      };
      var provider = factory(api, providerOptions, dirname);
      var providerName = provider.name || factory.name;
      if (typeof provider[methodName] !== "function") {
        throw new Error("The \"" + providerName + "\" provider doesn't support the \"" + method + "\" polyfilling method.");
      }
      if (Array.isArray(provider.polyfills)) {
        polyfillsNames = new Map(provider.polyfills.map(function (name, index) {
          return [name, index];
        }));
        filterPolyfills = provider.filterPolyfills;
      } else if (provider.polyfills) {
        polyfillsNames = new Map(Object.keys(provider.polyfills).map(function (name, index) {
          return [name, index];
        }));
        polyfillsSupport = provider.polyfills;
        filterPolyfills = provider.filterPolyfills;
      } else {
        polyfillsNames = new Map();
      }
      var _ref2 = (0, _normalizeOptions.validateIncludeExclude)(providerName, polyfillsNames, providerOptions.include || [], providerOptions.exclude || []);
      include = _ref2.include;
      exclude = _ref2.exclude;
      var callProvider;
      if (methodName === "usageGlobal") {
        callProvider = function callProvider(payload, path) {
          var _ref;
          var utils = getUtils(path);
          return (_ref = provider[methodName](payload, utils, path)) != null ? _ref : false;
        };
      } else {
        callProvider = function callProvider(payload, path) {
          var utils = getUtils(path);
          provider[methodName](payload, utils, path);
          return false;
        };
      }
      return {
        debug: _debug,
        method: method,
        targets: targets,
        provider: provider,
        providerName: providerName,
        callProvider: callProvider
      };
    }
    function definePolyfillProvider(factory) {
      return (0, _helperPluginUtils.declare)(function (babelApi, options, dirname) {
        babelApi.assertVersion("^7.0.0 || ^8.0.0-alpha.0");
        var traverse = babelApi.traverse;
        var debugLog;
        var missingDependencies = (0, _normalizeOptions.applyMissingDependenciesDefaults)(options, babelApi);
        var _instantiateProvider = instantiateProvider(factory, options, missingDependencies, dirname, function () {
            return debugLog;
          }, babelApi),
          debug = _instantiateProvider.debug,
          method = _instantiateProvider.method,
          targets = _instantiateProvider.targets,
          provider = _instantiateProvider.provider,
          providerName = _instantiateProvider.providerName,
          callProvider = _instantiateProvider.callProvider;
        var createVisitor = method === "entry-global" ? v.entry : v.usage;
        var visitor = provider.visitor ? traverse.visitors.merge([createVisitor(callProvider), provider.visitor]) : createVisitor(callProvider);
        if (debug && debug !== _debugUtils.presetEnvSilentDebugHeader) {
          console.log(providerName + ": `DEBUG` option");
          console.log("\nUsing targets: " + (0, _debugUtils.stringifyTargetsMultiline)(targets));
          console.log("\nUsing polyfills with `" + method + "` method:");
        }
        var runtimeName = provider.runtimeName;
        return {
          name: "inject-polyfills",
          visitor: visitor,
          pre: function pre(file) {
            var _provider$pre;
            if (runtimeName) {
              if (file.get("runtimeHelpersModuleName") && file.get("runtimeHelpersModuleName") !== runtimeName) {
                console.warn("Two different polyfill providers" + (" (" + file.get("runtimeHelpersModuleProvider")) + (" and " + providerName + ") are trying to define two") + " conflicting @babel/runtime alternatives:" + (" " + file.get("runtimeHelpersModuleName") + " and " + runtimeName + ".") + " The second one will be ignored.");
              } else {
                file.set("runtimeHelpersModuleName", runtimeName);
                file.set("runtimeHelpersModuleProvider", providerName);
              }
            }
            debugLog = {
              polyfills: new Set(),
              polyfillsSupport: undefined,
              found: false,
              providers: new Set(),
              missingDeps: new Set()
            };
            (_provider$pre = provider.pre) == null ? void 0 : _provider$pre.apply(this, arguments);
          },
          post: function post() {
            var _provider$post;
            (_provider$post = provider.post) == null ? void 0 : _provider$post.apply(this, arguments);
            if (missingDependencies !== false) {
              if (missingDependencies.log === "per-file") {
                deps.logMissing(debugLog.missingDeps);
              } else {
                deps.laterLogMissing(debugLog.missingDeps);
              }
            }
            if (!debug) return;
            if (this.filename) console.log("\n[" + this.filename + "]");
            if (debugLog.polyfills.size === 0) {
              console.log(method === "entry-global" ? debugLog.found ? "Based on your targets, the " + providerName + " polyfill did not add any polyfill." : "The entry point for the " + providerName + " polyfill has not been found." : "Based on your code and targets, the " + providerName + " polyfill did not add any polyfill.");
              return;
            }
            if (method === "entry-global") {
              console.log("The " + providerName + " polyfill entry has been replaced with " + "the following polyfills:");
            } else {
              console.log("The " + providerName + " polyfill added the following polyfills:");
            }
            for (var _iterator = _createForOfIteratorHelperLoose(debugLog.polyfills), _step; !(_step = _iterator()).done;) {
              var name = _step.value;
              var _debugLog$polyfillsSu2;
              if ((_debugLog$polyfillsSu2 = debugLog.polyfillsSupport) != null && _debugLog$polyfillsSu2[name]) {
                var filteredTargets = (0, _helperCompilationTargets.getInclusionReasons)(name, targets, debugLog.polyfillsSupport);
                var formattedTargets = JSON.stringify(filteredTargets).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');
                console.log("  " + name + " " + formattedTargets);
              } else {
                console.log("  " + name);
              }
            }
          }
        };
      });
    }
    function mapGetOr(map, key, getDefault) {
      var val = map.get(key);
      if (val === undefined) {
        val = getDefault();
        map.set(key, val);
      }
      return val;
    }
    function isEmpty(obj) {
      return Object.keys(obj).length === 0;
    }
    return lib$1;
  }

var hasRequiredLib$1;
  function requireLib$1() {
    if (hasRequiredLib$1) return lib$2;
    hasRequiredLib$1 = 1;
    lib$2.__esModule = true;
    lib$2["default"] = void 0;
    var _corejs2BuiltIns = _interopRequireDefault(requireCorejs2BuiltIns());
    var _builtInDefinitions = requireBuiltInDefinitions();
    var _addPlatformSpecificPolyfills = _interopRequireDefault(requireAddPlatformSpecificPolyfills());
    var _helpers = requireHelpers();
    var _helperDefinePolyfillProvider = _interopRequireDefault(requireLib$2());
    var _babel = _interopRequireWildcard(require$$5);
    function _getRequireWildcardCache(nodeInterop) {
      if (typeof WeakMap !== "function") return null;
      var cacheBabelInterop = new WeakMap();
      var cacheNodeInterop = new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
      })(nodeInterop);
    }
    function _interopRequireWildcard(obj, nodeInterop) {
      if (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;
    }
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    var _ref = _babel["default"] || _babel,
      t = _ref.types;
    var BABEL_RUNTIME = "@babel/runtime-corejs2";
    var presetEnvCompat = "#__secret_key__@babel/preset-env__compatibility";
    var runtimeCompat = "#__secret_key__@babel/runtime__compatibility";
    var has = Function.call.bind(Object.hasOwnProperty);
    var _default = (0, _helperDefinePolyfillProvider["default"])(function (api, _ref2) {
      var _ref2$presetEnvCompat = _ref2[presetEnvCompat],
        _ref2$presetEnvCompat2 = _ref2$presetEnvCompat === void 0 ? {} : _ref2$presetEnvCompat,
        _ref2$presetEnvCompat3 = _ref2$presetEnvCompat2.entryInjectRegenerator,
        entryInjectRegenerator = _ref2$presetEnvCompat3 === void 0 ? false : _ref2$presetEnvCompat3,
        _ref2$presetEnvCompat4 = _ref2$presetEnvCompat2.noRuntimeName,
        noRuntimeName = _ref2$presetEnvCompat4 === void 0 ? false : _ref2$presetEnvCompat4,
        _ref2$runtimeCompat = _ref2[runtimeCompat],
        _ref2$runtimeCompat2 = _ref2$runtimeCompat === void 0 ? {} : _ref2$runtimeCompat,
        _ref2$runtimeCompat2$ = _ref2$runtimeCompat2.useBabelRuntime,
        useBabelRuntime = _ref2$runtimeCompat2$ === void 0 ? false : _ref2$runtimeCompat2$,
        _ref2$runtimeCompat2$2 = _ref2$runtimeCompat2.runtimeVersion,
        runtimeVersion = _ref2$runtimeCompat2$2 === void 0 ? "" : _ref2$runtimeCompat2$2,
        _ref2$runtimeCompat2$3 = _ref2$runtimeCompat2.ext,
        ext = _ref2$runtimeCompat2$3 === void 0 ? ".js" : _ref2$runtimeCompat2$3;
      var resolve = api.createMetaResolver({
        global: _builtInDefinitions.BuiltIns,
        "static": _builtInDefinitions.StaticProperties,
        instance: _builtInDefinitions.InstanceProperties
      });
      var debug = api.debug,
        shouldInjectPolyfill = api.shouldInjectPolyfill,
        method = api.method;
      var polyfills = (0, _addPlatformSpecificPolyfills["default"])(api.targets, method, _corejs2BuiltIns["default"]);
      var coreJSBase = useBabelRuntime ? BABEL_RUNTIME + "/core-js" : method === "usage-pure" ? "core-js/library/fn" : "core-js/modules";
      function inject(name, utils) {
        if (typeof name === "string") {
          if (has(polyfills, name) && shouldInjectPolyfill(name)) {
            debug(name);
            utils.injectGlobalImport(coreJSBase + "/" + name + ".js");
          }
          return;
        }
        name.forEach(function (name) {
          return inject(name, utils);
        });
      }
      function maybeInjectPure(desc, hint, utils) {
        var pure = desc.pure,
          meta = desc.meta,
          name = desc.name;
        if (!pure || !shouldInjectPolyfill(name)) return;
        if (runtimeVersion && meta && meta.minRuntimeVersion && !(0, _helpers.hasMinVersion)(meta && meta.minRuntimeVersion, runtimeVersion)) {
          return;
        }
        if (useBabelRuntime && pure === "symbol/index") pure = "symbol";
        return utils.injectDefaultImport(coreJSBase + "/" + pure + ext, hint);
      }
      return {
        name: "corejs2",
        runtimeName: noRuntimeName ? null : BABEL_RUNTIME,
        polyfills: polyfills,
        entryGlobal: function entryGlobal(meta, utils, path) {
          if (meta.kind === "import" && meta.source === "core-js") {
            debug(null);
            inject(Object.keys(polyfills), utils);
            if (entryInjectRegenerator) {
              utils.injectGlobalImport("regenerator-runtime/runtime.js");
            }
            path.remove();
          }
        },
        usageGlobal: function usageGlobal(meta, utils) {
          var resolved = resolve(meta);
          if (!resolved) return;
          var deps = resolved.desc.global;
          if (resolved.kind !== "global" && "object" in meta && meta.object && meta.placement === "prototype") {
            var low = meta.object.toLowerCase();
            deps = deps.filter(function (m) {
              return m.includes(low);
            });
          }
          inject(deps, utils);
        },
        usagePure: function usagePure(meta, utils, path) {
          if (meta.kind === "in") {
            if (meta.key === "Symbol.iterator") {
              path.replaceWith(t.callExpression(utils.injectDefaultImport(coreJSBase + "/is-iterable" + ext, "isIterable"), [path.node.right]));
            }
            return;
          }
          if (path.parentPath.isUnaryExpression({
            operator: "delete"
          })) return;
          if (meta.kind === "property") {
            if (!path.isMemberExpression()) return;
            if (!path.isReferenced()) return;
            if (meta.key === "Symbol.iterator" && shouldInjectPolyfill("es6.symbol") && path.parentPath.isCallExpression({
              callee: path.node
            }) && path.parentPath.node.arguments.length === 0) {
              path.parentPath.replaceWith(t.callExpression(utils.injectDefaultImport(coreJSBase + "/get-iterator" + ext, "getIterator"), [path.node.object]));
              path.skip();
              return;
            }
          }
          var resolved = resolve(meta);
          if (!resolved) return;
          var id = maybeInjectPure(resolved.desc, resolved.name, utils);
          if (id) path.replaceWith(id);
        },
        visitor: method === "usage-global" && {
          YieldExpression: function YieldExpression(path) {
            if (path.node.delegate) {
              inject("web.dom.iterable", api.getUtils(path));
            }
          },
          "ForOfStatement|ArrayPattern": function ForOfStatementArrayPattern(path) {
            _builtInDefinitions.CommonIterators.forEach(function (name) {
              return inject(name, api.getUtils(path));
            });
          }
        }
      };
    });
    lib$2["default"] = _default;
    return lib$2;
  }

var babelPluginPolyfillCorejs2;
  var hasRequiredBabelPluginPolyfillCorejs2;
  function requireBabelPluginPolyfillCorejs2() {
    if (hasRequiredBabelPluginPolyfillCorejs2) return babelPluginPolyfillCorejs2;
    hasRequiredBabelPluginPolyfillCorejs2 = 1;
    function bool(value) {
      if (value == null) return false;
      return value && value !== "false" && value !== "0";
    }
    babelPluginPolyfillCorejs2 = bool(browser$1$1.env["BABEL_8_BREAKING"]) ? null : requireLib$1();
    return babelPluginPolyfillCorejs2;
  }

var lib = {};

var hasRequiredLib;
  function requireLib() {
    if (hasRequiredLib) return lib;
    hasRequiredLib = 1;
    lib.__esModule = true;
    lib["default"] = void 0;
    var _helperDefinePolyfillProvider = _interopRequireDefault(requireLib$2());
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    }
    var runtimeCompat = "#__secret_key__@babel/runtime__compatibility";
    var _default = (0, _helperDefinePolyfillProvider["default"])(function (_ref2, options) {
      var debug = _ref2.debug,
        targets = _ref2.targets,
        babel = _ref2.babel;
      if (!shallowEqual(targets, babel.targets())) {
        throw new Error("This plugin does not use the targets option. Only preset-env's targets" + " or top-level targets need to be configured for this plugin to work." + " See https://github.com/babel/babel-polyfills/issues/36 for more" + " details.");
      }
      var _options$runtimeCompa = options[runtimeCompat],
        _options$runtimeCompa2 = _options$runtimeCompa === void 0 ? {} : _options$runtimeCompa,
        _options$runtimeCompa3 = _options$runtimeCompa2.moduleName,
        moduleName = _options$runtimeCompa3 === void 0 ? null : _options$runtimeCompa3,
        _options$runtimeCompa4 = _options$runtimeCompa2.useBabelRuntime,
        useBabelRuntime = _options$runtimeCompa4 === void 0 ? false : _options$runtimeCompa4;
      return {
        name: "regenerator",
        polyfills: ["regenerator-runtime"],
        usageGlobal: function usageGlobal(meta, utils) {
          if (isRegenerator(meta)) {
            debug("regenerator-runtime");
            utils.injectGlobalImport("regenerator-runtime/runtime.js");
          }
        },
        usagePure: function usagePure(meta, utils, path) {
          if (isRegenerator(meta)) {
            var pureName = "regenerator-runtime";
            if (useBabelRuntime) {
              var _ref;
              var runtimeName = (_ref = moduleName != null ? moduleName : path.hub.file.get("runtimeHelpersModuleName")) != null ? _ref : "@babel/runtime";
              pureName = runtimeName + "/regenerator";
            }
            path.replaceWith(utils.injectDefaultImport(pureName, "regenerator-runtime"));
          }
        }
      };
    });
    lib["default"] = _default;
    var isRegenerator = function isRegenerator(meta) {
      return meta.kind === "global" && meta.name === "regeneratorRuntime";
    };
    function shallowEqual(obj1, obj2) {
      return JSON.stringify(obj1) === JSON.stringify(obj2);
    }
    return lib;
  }

var babelPluginPolyfillRegenerator;
  var hasRequiredBabelPluginPolyfillRegenerator;
  function requireBabelPluginPolyfillRegenerator() {
    if (hasRequiredBabelPluginPolyfillRegenerator) return babelPluginPolyfillRegenerator;
    hasRequiredBabelPluginPolyfillRegenerator = 1;
    function bool(value) {
      if (value == null) return false;
      return value && value !== "false" && value !== "0";
    }
    babelPluginPolyfillRegenerator = bool(browser$1$1.env["BABEL_8_BREAKING"]) ? null : requireLib();
    return babelPluginPolyfillRegenerator;
  }

var utils = {};

var hasRequiredUtils;
  function requireUtils() {
    if (hasRequiredUtils) return utils;
    hasRequiredUtils = 1;
    utils.getImportSource = function (_ref) {
      var node = _ref.node;
      if (node.specifiers.length === 0) return node.source.value;
    };
    utils.getRequireSource = function (_ref2) {
      var node = _ref2.node;
      if (node.type !== "ExpressionStatement") return;
      var expression = node.expression;
      if (expression.type === "CallExpression" && expression.callee.type === "Identifier" && expression.callee.name === "require" && expression.arguments.length === 1 && expression.arguments[0].type === "StringLiteral") {
        return expression.arguments[0].value;
      }
    };
    utils.isPolyfillSource = function (source) {
      return source === "@babel/polyfill" || source === "core-js";
    };
    return utils;
  }

var _templateObject$2, _templateObject2$1, _templateObject3$1, _templateObject4;
  var babelPolyfill;
  var hasRequiredBabelPolyfill;
  function requireBabelPolyfill() {
    if (hasRequiredBabelPolyfill) return babelPolyfill;
    hasRequiredBabelPolyfill = 1;
    var _require$$ = requireUtils(),
      getImportSource = _require$$.getImportSource,
      getRequireSource = _require$$.getRequireSource,
      isPolyfillSource = _require$$.isPolyfillSource;
    var BABEL_POLYFILL_DEPRECATION = "\n  `@babel/polyfill` is deprecated. Please, use required parts of `core-js`\n  and `regenerator-runtime/runtime` separately";
    var NO_DIRECT_POLYFILL_IMPORT = "\n  When setting `useBuiltIns: 'usage'`, polyfills are automatically imported when needed.\n  Please remove the direct import of `SPECIFIER` or use `useBuiltIns: 'entry'` instead.";
    babelPolyfill = function babelPolyfill(_ref, _ref2) {
      var template = _ref.template;
      var regenerator = _ref2.regenerator,
        deprecated = _ref2.deprecated,
        usage = _ref2.usage;
      return {
        name: "preset-env/replace-babel-polyfill",
        visitor: {
          ImportDeclaration: function ImportDeclaration(path) {
            var src = getImportSource(path);
            if (usage && isPolyfillSource(src)) {
              console.warn(NO_DIRECT_POLYFILL_IMPORT.replace("SPECIFIER", src));
              if (!deprecated) path.remove();
            } else if (src === "@babel/polyfill") {
              if (deprecated) {
                console.warn(BABEL_POLYFILL_DEPRECATION);
              } else if (regenerator) {
                path.replaceWithMultiple(template.ast(_templateObject$2 || (_templateObject$2 = _taggedTemplateLiteralLoose(["\n              import \"core-js\";\n              import \"regenerator-runtime/runtime.js\";\n            "]))));
              } else {
                path.replaceWith(template.ast(_templateObject2$1 || (_templateObject2$1 = _taggedTemplateLiteralLoose(["\n              import \"core-js\";\n            "]))));
              }
            }
          },
          Program: function Program(path) {
            path.get("body").forEach(function (bodyPath) {
              var src = getRequireSource(bodyPath);
              if (usage && isPolyfillSource(src)) {
                console.warn(NO_DIRECT_POLYFILL_IMPORT.replace("SPECIFIER", src));
                if (!deprecated) bodyPath.remove();
              } else if (src === "@babel/polyfill") {
                if (deprecated) {
                  console.warn(BABEL_POLYFILL_DEPRECATION);
                } else if (regenerator) {
                  bodyPath.replaceWithMultiple(template.ast(_templateObject3$1 || (_templateObject3$1 = _taggedTemplateLiteralLoose(["\n                require(\"core-js\");\n                require(\"regenerator-runtime/runtime.js\");\n              "]))));
                } else {
                  bodyPath.replaceWith(template.ast(_templateObject4 || (_templateObject4 = _taggedTemplateLiteralLoose(["\n                require(\"core-js\");\n              "]))));
                }
              }
            });
          }
        }
      };
    };
    return babelPolyfill;
  }

var regenerator;
  var hasRequiredRegenerator;
  function requireRegenerator() {
    if (hasRequiredRegenerator) return regenerator;
    hasRequiredRegenerator = 1;
    var _require$$ = requireUtils(),
      getImportSource = _require$$.getImportSource,
      getRequireSource = _require$$.getRequireSource;
    function isRegeneratorSource(source) {
      return source === "regenerator-runtime/runtime" || source === "regenerator-runtime/runtime.js";
    }
    regenerator = function regenerator() {
      var visitor = {
        ImportDeclaration: function ImportDeclaration(path) {
          if (isRegeneratorSource(getImportSource(path))) {
            this.regeneratorImportExcluded = true;
            path.remove();
          }
        },
        Program: function Program(path) {
          var _this = this;
          path.get("body").forEach(function (bodyPath) {
            if (isRegeneratorSource(getRequireSource(bodyPath))) {
              _this.regeneratorImportExcluded = true;
              bodyPath.remove();
            }
          });
        }
      };
      return {
        name: "preset-env/remove-regenerator",
        visitor: visitor,
        pre: function pre() {
          this.regeneratorImportExcluded = false;
        },
        post: function post() {
          if (this.opts.debug && this.regeneratorImportExcluded) {
            var filename = this.file.opts.filename;
            if (browser$1$1.env.BABEL_ENV === "test") {
              filename = filename.replace(/\\/g, "/");
            }
            console.log("\n[" + filename + "] Based on your targets, regenerator-runtime import excluded.");
          }
        }
      };
    };
    return regenerator;
  }

var proposalPlugins = new Set([]);
  var proposalSyntaxPlugins = ["syntax-import-assertions", "syntax-import-attributes"];
  var pluginSyntaxObject = {
    "transform-async-generator-functions": "syntax-async-generators",
    "transform-class-properties": "syntax-class-properties",
    "transform-class-static-block": "syntax-class-static-block",
    "transform-export-namespace-from": "syntax-export-namespace-from",
    "transform-json-strings": "syntax-json-strings",
    "transform-nullish-coalescing-operator": "syntax-nullish-coalescing-operator",
    "transform-numeric-separator": "syntax-numeric-separator",
    "transform-object-rest-spread": "syntax-object-rest-spread",
    "transform-optional-catch-binding": "syntax-optional-catch-binding",
    "transform-optional-chaining": "syntax-optional-chaining",
    "transform-private-methods": "syntax-class-properties",
    "transform-private-property-in-object": "syntax-private-property-in-object",
    "transform-unicode-property-regex": null
  };
  var pluginSyntaxEntries = Object.keys(pluginSyntaxObject).map(function (key) {
    return [key, pluginSyntaxObject[key]];
  });
  var pluginSyntaxMap = new Map(pluginSyntaxEntries);

var data = require$$0$4;

var getModulesListForTargetVersion = getModulesListForTargetVersion$2;

var entries = require$$0$3;

var _InstanceProperties;
  var corejs3ShippedProposalsList = new Set(["esnext.suppressed-error.constructor", "esnext.array.from-async", "esnext.array.group", "esnext.array.group-to-map", "esnext.data-view.get-float16", "esnext.data-view.set-float16", "esnext.iterator.constructor", "esnext.iterator.drop", "esnext.iterator.every", "esnext.iterator.filter", "esnext.iterator.find", "esnext.iterator.flat-map", "esnext.iterator.for-each", "esnext.iterator.from", "esnext.iterator.map", "esnext.iterator.reduce", "esnext.iterator.some", "esnext.iterator.take", "esnext.iterator.to-array", "esnext.json.is-raw-json", "esnext.json.parse", "esnext.json.raw-json", "esnext.math.f16round", "esnext.promise.try", "esnext.symbol.async-dispose", "esnext.symbol.dispose", "esnext.symbol.metadata"]);
  var polyfillsOrder = {};
  Object.keys(data).forEach(function (name, index) {
    polyfillsOrder[name] = index;
  });
  var define = function define(pure, global, name, exclude) {
    if (name === void 0) {
      name = global[0];
    }
    return {
      name: name,
      pure: pure,
      global: global.sort(function (a, b) {
        return polyfillsOrder[a] - polyfillsOrder[b];
      }),
      exclude: exclude
    };
  };
  var typed = function typed() {
    for (var _len = arguments.length, modules = new Array(_len), _key = 0; _key < _len; _key++) {
      modules[_key] = arguments[_key];
    }
    return define(null, [].concat(modules, TypedArrayDependencies));
  };
  var ArrayNatureIterators = ["es.array.iterator", "web.dom-collections.iterator"];
  var CommonIterators = ["es.string.iterator"].concat(ArrayNatureIterators);
  var ArrayNatureIteratorsWithTag = ["es.object.to-string"].concat(ArrayNatureIterators);
  var CommonIteratorsWithTag = ["es.object.to-string"].concat(_toConsumableArray(CommonIterators));
  var ErrorDependencies = ["es.error.cause", "es.error.to-string"];
  var SuppressedErrorDependencies = ["esnext.suppressed-error.constructor"].concat(ErrorDependencies);
  var ArrayBufferDependencies = ["es.array-buffer.constructor", "es.array-buffer.slice", "es.data-view", "es.array-buffer.detached", "es.array-buffer.transfer", "es.array-buffer.transfer-to-fixed-length", "es.object.to-string"];
  var TypedArrayDependencies = ["es.typed-array.at", "es.typed-array.copy-within", "es.typed-array.every", "es.typed-array.fill", "es.typed-array.filter", "es.typed-array.find", "es.typed-array.find-index", "es.typed-array.find-last", "es.typed-array.find-last-index", "es.typed-array.for-each", "es.typed-array.includes", "es.typed-array.index-of", "es.typed-array.iterator", "es.typed-array.join", "es.typed-array.last-index-of", "es.typed-array.map", "es.typed-array.reduce", "es.typed-array.reduce-right", "es.typed-array.reverse", "es.typed-array.set", "es.typed-array.slice", "es.typed-array.some", "es.typed-array.sort", "es.typed-array.subarray", "es.typed-array.to-locale-string", "es.typed-array.to-reversed", "es.typed-array.to-sorted", "es.typed-array.to-string", "es.typed-array.with", "es.object.to-string", "es.array.iterator", "esnext.typed-array.filter-reject", "esnext.typed-array.group-by", "esnext.typed-array.to-spliced", "esnext.typed-array.unique-by"].concat(ArrayBufferDependencies);
  var PromiseDependencies = ["es.promise", "es.object.to-string"];
  var PromiseDependenciesWithIterators = [].concat(PromiseDependencies, _toConsumableArray(CommonIterators));
  var SymbolDependencies = ["es.symbol", "es.symbol.description", "es.object.to-string"];
  var MapDependencies = ["es.map", "esnext.map.delete-all", "esnext.map.emplace", "esnext.map.every", "esnext.map.filter", "esnext.map.find", "esnext.map.find-key", "esnext.map.includes", "esnext.map.key-of", "esnext.map.map-keys", "esnext.map.map-values", "esnext.map.merge", "esnext.map.reduce", "esnext.map.some", "esnext.map.update"].concat(_toConsumableArray(CommonIteratorsWithTag));
  var SetDependencies = ["es.set", "es.set.difference.v2", "es.set.intersection.v2", "es.set.is-disjoint-from.v2", "es.set.is-subset-of.v2", "es.set.is-superset-of.v2", "es.set.symmetric-difference.v2", "es.set.union.v2", "esnext.set.add-all", "esnext.set.delete-all", "esnext.set.difference", "esnext.set.every", "esnext.set.filter", "esnext.set.find", "esnext.set.intersection", "esnext.set.is-disjoint-from", "esnext.set.is-subset-of", "esnext.set.is-superset-of", "esnext.set.join", "esnext.set.map", "esnext.set.reduce", "esnext.set.some", "esnext.set.symmetric-difference", "esnext.set.union"].concat(_toConsumableArray(CommonIteratorsWithTag));
  var WeakMapDependencies = ["es.weak-map", "esnext.weak-map.delete-all", "esnext.weak-map.emplace"].concat(_toConsumableArray(CommonIteratorsWithTag));
  var WeakSetDependencies = ["es.weak-set", "esnext.weak-set.add-all", "esnext.weak-set.delete-all"].concat(_toConsumableArray(CommonIteratorsWithTag));
  var DOMExceptionDependencies = ["web.dom-exception.constructor", "web.dom-exception.stack", "web.dom-exception.to-string-tag", "es.error.to-string"];
  var URLSearchParamsDependencies = ["web.url-search-params", "web.url-search-params.delete", "web.url-search-params.has", "web.url-search-params.size"].concat(_toConsumableArray(CommonIteratorsWithTag));
  var AsyncIteratorDependencies = ["esnext.async-iterator.constructor"].concat(PromiseDependencies);
  var AsyncIteratorProblemMethods = ["esnext.async-iterator.every", "esnext.async-iterator.filter", "esnext.async-iterator.find", "esnext.async-iterator.flat-map", "esnext.async-iterator.for-each", "esnext.async-iterator.map", "esnext.async-iterator.reduce", "esnext.async-iterator.some"];
  var IteratorDependencies = ["esnext.iterator.constructor", "es.object.to-string"];
  var DecoratorMetadataDependencies = ["esnext.symbol.metadata", "esnext.function.metadata"];
  var TypedArrayStaticMethods = function TypedArrayStaticMethods(base) {
    return {
      from: define(null, ["es.typed-array.from", base].concat(TypedArrayDependencies)),
      fromAsync: define(null, ["esnext.typed-array.from-async", base].concat(_toConsumableArray(PromiseDependenciesWithIterators), TypedArrayDependencies)),
      of: define(null, ["es.typed-array.of", base].concat(TypedArrayDependencies))
    };
  };
  var DataViewDependencies = ["es.data-view"].concat(ArrayBufferDependencies);
  var BuiltIns = {
    AsyncDisposableStack: define("async-disposable-stack/index", ["esnext.async-disposable-stack.constructor", "es.object.to-string", "esnext.async-iterator.async-dispose", "esnext.iterator.dispose"].concat(PromiseDependencies, _toConsumableArray(SuppressedErrorDependencies))),
    AsyncIterator: define("async-iterator/index", AsyncIteratorDependencies),
    AggregateError: define("aggregate-error", ["es.aggregate-error"].concat(ErrorDependencies, _toConsumableArray(CommonIteratorsWithTag), ["es.aggregate-error.cause"])),
    ArrayBuffer: define(null, ArrayBufferDependencies),
    DataView: define(null, DataViewDependencies),
    Date: define(null, ["es.date.to-string"]),
    DOMException: define("dom-exception/index", DOMExceptionDependencies),
    DisposableStack: define("disposable-stack/index", ["esnext.disposable-stack.constructor", "es.object.to-string", "esnext.iterator.dispose"].concat(_toConsumableArray(SuppressedErrorDependencies))),
    Error: define(null, ErrorDependencies),
    EvalError: define(null, ErrorDependencies),
    Float32Array: typed("es.typed-array.float32-array"),
    Float64Array: typed("es.typed-array.float64-array"),
    Int8Array: typed("es.typed-array.int8-array"),
    Int16Array: typed("es.typed-array.int16-array"),
    Int32Array: typed("es.typed-array.int32-array"),
    Iterator: define("iterator/index", IteratorDependencies),
    Uint8Array: typed("es.typed-array.uint8-array", "esnext.uint8-array.set-from-base64", "esnext.uint8-array.set-from-hex", "esnext.uint8-array.to-base64", "esnext.uint8-array.to-hex"),
    Uint8ClampedArray: typed("es.typed-array.uint8-clamped-array"),
    Uint16Array: typed("es.typed-array.uint16-array"),
    Uint32Array: typed("es.typed-array.uint32-array"),
    Map: define("map/index", MapDependencies),
    Number: define(null, ["es.number.constructor"]),
    Observable: define("observable/index", ["esnext.observable", "esnext.symbol.observable", "es.object.to-string"].concat(_toConsumableArray(CommonIteratorsWithTag))),
    Promise: define("promise/index", PromiseDependencies),
    RangeError: define(null, ErrorDependencies),
    ReferenceError: define(null, ErrorDependencies),
    Reflect: define(null, ["es.reflect.to-string-tag", "es.object.to-string"]),
    RegExp: define(null, ["es.regexp.constructor", "es.regexp.dot-all", "es.regexp.exec", "es.regexp.sticky", "es.regexp.to-string"]),
    Set: define("set/index", SetDependencies),
    SuppressedError: define("suppressed-error", SuppressedErrorDependencies),
    Symbol: define("symbol/index", SymbolDependencies),
    SyntaxError: define(null, ErrorDependencies),
    TypeError: define(null, ErrorDependencies),
    URIError: define(null, ErrorDependencies),
    URL: define("url/index", ["web.url", "web.url.to-json"].concat(_toConsumableArray(URLSearchParamsDependencies))),
    URLSearchParams: define("url-search-params/index", URLSearchParamsDependencies),
    WeakMap: define("weak-map/index", WeakMapDependencies),
    WeakSet: define("weak-set/index", WeakSetDependencies),
    atob: define("atob", ["web.atob"].concat(DOMExceptionDependencies)),
    btoa: define("btoa", ["web.btoa"].concat(DOMExceptionDependencies)),
    clearImmediate: define("clear-immediate", ["web.immediate"]),
    compositeKey: define("composite-key", ["esnext.composite-key"]),
    compositeSymbol: define("composite-symbol", ["esnext.composite-symbol"]),
    escape: define("escape", ["es.escape"]),
    fetch: define(null, PromiseDependencies),
    globalThis: define("global-this", ["es.global-this"]),
    parseFloat: define("parse-float", ["es.parse-float"]),
    parseInt: define("parse-int", ["es.parse-int"]),
    queueMicrotask: define("queue-microtask", ["web.queue-microtask"]),
    self: define("self", ["web.self"]),
    setImmediate: define("set-immediate", ["web.immediate"]),
    setInterval: define("set-interval", ["web.timers"]),
    setTimeout: define("set-timeout", ["web.timers"]),
    structuredClone: define("structured-clone", ["web.structured-clone"].concat(DOMExceptionDependencies, ["es.array.iterator", "es.object.keys", "es.object.to-string", "es.map", "es.set"])),
    unescape: define("unescape", ["es.unescape"])
  };
  var StaticProperties = {
    AsyncIterator: {
      from: define("async-iterator/from", ["esnext.async-iterator.from"].concat(_toConsumableArray(AsyncIteratorDependencies), AsyncIteratorProblemMethods, _toConsumableArray(CommonIterators)))
    },
    Array: {
      from: define("array/from", ["es.array.from", "es.string.iterator"]),
      fromAsync: define("array/from-async", ["esnext.array.from-async"].concat(_toConsumableArray(PromiseDependenciesWithIterators))),
      isArray: define("array/is-array", ["es.array.is-array"]),
      isTemplateObject: define("array/is-template-object", ["esnext.array.is-template-object"]),
      of: define("array/of", ["es.array.of"])
    },
    ArrayBuffer: {
      isView: define(null, ["es.array-buffer.is-view"])
    },
    BigInt: {
      range: define("bigint/range", ["esnext.bigint.range", "es.object.to-string"])
    },
    Date: {
      now: define("date/now", ["es.date.now"])
    },
    Function: {
      isCallable: define("function/is-callable", ["esnext.function.is-callable"]),
      isConstructor: define("function/is-constructor", ["esnext.function.is-constructor"])
    },
    Iterator: {
      from: define("iterator/from", ["esnext.iterator.from"].concat(IteratorDependencies, _toConsumableArray(CommonIterators))),
      range: define("iterator/range", ["esnext.iterator.range", "es.object.to-string"])
    },
    JSON: {
      isRawJSON: define("json/is-raw-json", ["esnext.json.is-raw-json"]),
      parse: define("json/parse", ["esnext.json.parse", "es.object.keys"]),
      rawJSON: define("json/raw-json", ["esnext.json.raw-json", "es.object.create", "es.object.freeze"]),
      stringify: define("json/stringify", ["es.json.stringify", "es.date.to-json"], "es.symbol")
    },
    Math: {
      DEG_PER_RAD: define("math/deg-per-rad", ["esnext.math.deg-per-rad"]),
      RAD_PER_DEG: define("math/rad-per-deg", ["esnext.math.rad-per-deg"]),
      acosh: define("math/acosh", ["es.math.acosh"]),
      asinh: define("math/asinh", ["es.math.asinh"]),
      atanh: define("math/atanh", ["es.math.atanh"]),
      cbrt: define("math/cbrt", ["es.math.cbrt"]),
      clamp: define("math/clamp", ["esnext.math.clamp"]),
      clz32: define("math/clz32", ["es.math.clz32"]),
      cosh: define("math/cosh", ["es.math.cosh"]),
      degrees: define("math/degrees", ["esnext.math.degrees"]),
      expm1: define("math/expm1", ["es.math.expm1"]),
      fround: define("math/fround", ["es.math.fround"]),
      f16round: define("math/f16round", ["esnext.math.f16round"]),
      fscale: define("math/fscale", ["esnext.math.fscale"]),
      hypot: define("math/hypot", ["es.math.hypot"]),
      iaddh: define("math/iaddh", ["esnext.math.iaddh"]),
      imul: define("math/imul", ["es.math.imul"]),
      imulh: define("math/imulh", ["esnext.math.imulh"]),
      isubh: define("math/isubh", ["esnext.math.isubh"]),
      log10: define("math/log10", ["es.math.log10"]),
      log1p: define("math/log1p", ["es.math.log1p"]),
      log2: define("math/log2", ["es.math.log2"]),
      radians: define("math/radians", ["esnext.math.radians"]),
      scale: define("math/scale", ["esnext.math.scale"]),
      seededPRNG: define("math/seeded-prng", ["esnext.math.seeded-prng"]),
      sign: define("math/sign", ["es.math.sign"]),
      signbit: define("math/signbit", ["esnext.math.signbit"]),
      sinh: define("math/sinh", ["es.math.sinh"]),
      sumPrecise: define("math/sum-precise", ["esnext.math.sum-precise", "es.array.iterator"]),
      tanh: define("math/tanh", ["es.math.tanh"]),
      trunc: define("math/trunc", ["es.math.trunc"]),
      umulh: define("math/umulh", ["esnext.math.umulh"])
    },
    Map: {
      from: define("map/from", ["esnext.map.from"].concat(_toConsumableArray(MapDependencies))),
      groupBy: define("map/group-by", ["es.map.group-by"].concat(_toConsumableArray(MapDependencies))),
      keyBy: define("map/key-by", ["esnext.map.key-by"].concat(_toConsumableArray(MapDependencies))),
      of: define("map/of", ["esnext.map.of"].concat(_toConsumableArray(MapDependencies)))
    },
    Number: {
      EPSILON: define("number/epsilon", ["es.number.epsilon"]),
      MAX_SAFE_INTEGER: define("number/max-safe-integer", ["es.number.max-safe-integer"]),
      MIN_SAFE_INTEGER: define("number/min-safe-integer", ["es.number.min-safe-integer"]),
      fromString: define("number/from-string", ["esnext.number.from-string"]),
      isFinite: define("number/is-finite", ["es.number.is-finite"]),
      isInteger: define("number/is-integer", ["es.number.is-integer"]),
      isNaN: define("number/is-nan", ["es.number.is-nan"]),
      isSafeInteger: define("number/is-safe-integer", ["es.number.is-safe-integer"]),
      parseFloat: define("number/parse-float", ["es.number.parse-float"]),
      parseInt: define("number/parse-int", ["es.number.parse-int"]),
      range: define("number/range", ["esnext.number.range", "es.object.to-string"])
    },
    Object: {
      assign: define("object/assign", ["es.object.assign"]),
      create: define("object/create", ["es.object.create"]),
      defineProperties: define("object/define-properties", ["es.object.define-properties"]),
      defineProperty: define("object/define-property", ["es.object.define-property"]),
      entries: define("object/entries", ["es.object.entries"]),
      freeze: define("object/freeze", ["es.object.freeze"]),
      fromEntries: define("object/from-entries", ["es.object.from-entries", "es.array.iterator"]),
      getOwnPropertyDescriptor: define("object/get-own-property-descriptor", ["es.object.get-own-property-descriptor"]),
      getOwnPropertyDescriptors: define("object/get-own-property-descriptors", ["es.object.get-own-property-descriptors"]),
      getOwnPropertyNames: define("object/get-own-property-names", ["es.object.get-own-property-names"]),
      getOwnPropertySymbols: define("object/get-own-property-symbols", ["es.symbol"]),
      getPrototypeOf: define("object/get-prototype-of", ["es.object.get-prototype-of"]),
      groupBy: define("object/group-by", ["es.object.group-by", "es.object.create"]),
      hasOwn: define("object/has-own", ["es.object.has-own"]),
      is: define("object/is", ["es.object.is"]),
      isExtensible: define("object/is-extensible", ["es.object.is-extensible"]),
      isFrozen: define("object/is-frozen", ["es.object.is-frozen"]),
      isSealed: define("object/is-sealed", ["es.object.is-sealed"]),
      keys: define("object/keys", ["es.object.keys"]),
      preventExtensions: define("object/prevent-extensions", ["es.object.prevent-extensions"]),
      seal: define("object/seal", ["es.object.seal"]),
      setPrototypeOf: define("object/set-prototype-of", ["es.object.set-prototype-of"]),
      values: define("object/values", ["es.object.values"])
    },
    Promise: {
      all: define(null, PromiseDependenciesWithIterators),
      allSettled: define("promise/all-settled", ["es.promise.all-settled"].concat(_toConsumableArray(PromiseDependenciesWithIterators))),
      any: define("promise/any", ["es.promise.any", "es.aggregate-error"].concat(_toConsumableArray(PromiseDependenciesWithIterators))),
      race: define(null, PromiseDependenciesWithIterators),
      "try": define("promise/try", ["esnext.promise.try"].concat(PromiseDependencies)),
      withResolvers: define("promise/with-resolvers", ["es.promise.with-resolvers"].concat(PromiseDependencies))
    },
    Reflect: {
      apply: define("reflect/apply", ["es.reflect.apply"]),
      construct: define("reflect/construct", ["es.reflect.construct"]),
      defineMetadata: define("reflect/define-metadata", ["esnext.reflect.define-metadata"]),
      defineProperty: define("reflect/define-property", ["es.reflect.define-property"]),
      deleteMetadata: define("reflect/delete-metadata", ["esnext.reflect.delete-metadata"]),
      deleteProperty: define("reflect/delete-property", ["es.reflect.delete-property"]),
      get: define("reflect/get", ["es.reflect.get"]),
      getMetadata: define("reflect/get-metadata", ["esnext.reflect.get-metadata"]),
      getMetadataKeys: define("reflect/get-metadata-keys", ["esnext.reflect.get-metadata-keys"]),
      getOwnMetadata: define("reflect/get-own-metadata", ["esnext.reflect.get-own-metadata"]),
      getOwnMetadataKeys: define("reflect/get-own-metadata-keys", ["esnext.reflect.get-own-metadata-keys"]),
      getOwnPropertyDescriptor: define("reflect/get-own-property-descriptor", ["es.reflect.get-own-property-descriptor"]),
      getPrototypeOf: define("reflect/get-prototype-of", ["es.reflect.get-prototype-of"]),
      has: define("reflect/has", ["es.reflect.has"]),
      hasMetadata: define("reflect/has-metadata", ["esnext.reflect.has-metadata"]),
      hasOwnMetadata: define("reflect/has-own-metadata", ["esnext.reflect.has-own-metadata"]),
      isExtensible: define("reflect/is-extensible", ["es.reflect.is-extensible"]),
      metadata: define("reflect/metadata", ["esnext.reflect.metadata"]),
      ownKeys: define("reflect/own-keys", ["es.reflect.own-keys"]),
      preventExtensions: define("reflect/prevent-extensions", ["es.reflect.prevent-extensions"]),
      set: define("reflect/set", ["es.reflect.set"]),
      setPrototypeOf: define("reflect/set-prototype-of", ["es.reflect.set-prototype-of"])
    },
    RegExp: {
      escape: define("regexp/escape", ["esnext.regexp.escape"])
    },
    Set: {
      from: define("set/from", ["esnext.set.from"].concat(_toConsumableArray(SetDependencies))),
      of: define("set/of", ["esnext.set.of"].concat(_toConsumableArray(SetDependencies)))
    },
    String: {
      cooked: define("string/cooked", ["esnext.string.cooked"]),
      dedent: define("string/dedent", ["esnext.string.dedent", "es.string.from-code-point", "es.weak-map"]),
      fromCodePoint: define("string/from-code-point", ["es.string.from-code-point"]),
      raw: define("string/raw", ["es.string.raw"])
    },
    Symbol: {
      asyncDispose: define("symbol/async-dispose", ["esnext.symbol.async-dispose", "esnext.async-iterator.async-dispose"]),
      asyncIterator: define("symbol/async-iterator", ["es.symbol.async-iterator"]),
      customMatcher: define("symbol/custom-matcher", ["esnext.symbol.custom-matcher"]),
      dispose: define("symbol/dispose", ["esnext.symbol.dispose", "esnext.iterator.dispose"]),
      "for": define("symbol/for", [], "es.symbol"),
      hasInstance: define("symbol/has-instance", ["es.symbol.has-instance", "es.function.has-instance"]),
      isConcatSpreadable: define("symbol/is-concat-spreadable", ["es.symbol.is-concat-spreadable", "es.array.concat"]),
      isRegistered: define("symbol/is-registered", ["esnext.symbol.is-registered", "es.symbol"]),
      isRegisteredSymbol: define("symbol/is-registered-symbol", ["esnext.symbol.is-registered-symbol", "es.symbol"]),
      isWellKnown: define("symbol/is-well-known", ["esnext.symbol.is-well-known", "es.symbol"]),
      isWellKnownSymbol: define("symbol/is-well-known-symbol", ["esnext.symbol.is-well-known-symbol", "es.symbol"]),
      iterator: define("symbol/iterator", ["es.symbol.iterator"].concat(_toConsumableArray(CommonIteratorsWithTag))),
      keyFor: define("symbol/key-for", [], "es.symbol"),
      match: define("symbol/match", ["es.symbol.match", "es.string.match"]),
      matcher: define("symbol/matcher", ["esnext.symbol.matcher"]),
      matchAll: define("symbol/match-all", ["es.symbol.match-all", "es.string.match-all"]),
      metadata: define("symbol/metadata", DecoratorMetadataDependencies),
      metadataKey: define("symbol/metadata-key", ["esnext.symbol.metadata-key"]),
      observable: define("symbol/observable", ["esnext.symbol.observable"]),
      patternMatch: define("symbol/pattern-match", ["esnext.symbol.pattern-match"]),
      replace: define("symbol/replace", ["es.symbol.replace", "es.string.replace"]),
      search: define("symbol/search", ["es.symbol.search", "es.string.search"]),
      species: define("symbol/species", ["es.symbol.species", "es.array.species"]),
      split: define("symbol/split", ["es.symbol.split", "es.string.split"]),
      toPrimitive: define("symbol/to-primitive", ["es.symbol.to-primitive", "es.date.to-primitive"]),
      toStringTag: define("symbol/to-string-tag", ["es.symbol.to-string-tag", "es.object.to-string", "es.math.to-string-tag", "es.json.to-string-tag"]),
      unscopables: define("symbol/unscopables", ["es.symbol.unscopables"])
    },
    URL: {
      canParse: define("url/can-parse", ["web.url.can-parse", "web.url"]),
      parse: define("url/parse", ["web.url.parse", "web.url"])
    },
    WeakMap: {
      from: define("weak-map/from", ["esnext.weak-map.from"].concat(_toConsumableArray(WeakMapDependencies))),
      of: define("weak-map/of", ["esnext.weak-map.of"].concat(_toConsumableArray(WeakMapDependencies)))
    },
    WeakSet: {
      from: define("weak-set/from", ["esnext.weak-set.from"].concat(_toConsumableArray(WeakSetDependencies))),
      of: define("weak-set/of", ["esnext.weak-set.of"].concat(_toConsumableArray(WeakSetDependencies)))
    },
    Int8Array: TypedArrayStaticMethods("es.typed-array.int8-array"),
    Uint8Array: Object.assign({
      fromBase64: define(null, ["esnext.uint8-array.from-base64"].concat(TypedArrayDependencies)),
      fromHex: define(null, ["esnext.uint8-array.from-hex"].concat(TypedArrayDependencies))
    }, TypedArrayStaticMethods("es.typed-array.uint8-array")),
    Uint8ClampedArray: TypedArrayStaticMethods("es.typed-array.uint8-clamped-array"),
    Int16Array: TypedArrayStaticMethods("es.typed-array.int16-array"),
    Uint16Array: TypedArrayStaticMethods("es.typed-array.uint16-array"),
    Int32Array: TypedArrayStaticMethods("es.typed-array.int32-array"),
    Uint32Array: TypedArrayStaticMethods("es.typed-array.uint32-array"),
    Float32Array: TypedArrayStaticMethods("es.typed-array.float32-array"),
    Float64Array: TypedArrayStaticMethods("es.typed-array.float64-array"),
    WebAssembly: {
      CompileError: define(null, ErrorDependencies),
      LinkError: define(null, ErrorDependencies),
      RuntimeError: define(null, ErrorDependencies)
    }
  };
  var InstanceProperties = (_InstanceProperties = {
    asIndexedPairs: define(null, ["esnext.async-iterator.as-indexed-pairs"].concat(_toConsumableArray(AsyncIteratorDependencies), ["esnext.iterator.as-indexed-pairs"], IteratorDependencies)),
    at: define("instance/at", ["esnext.string.at", "es.string.at-alternative", "es.array.at"]),
    anchor: define(null, ["es.string.anchor"]),
    big: define(null, ["es.string.big"]),
    bind: define("instance/bind", ["es.function.bind"]),
    blink: define(null, ["es.string.blink"]),
    bold: define(null, ["es.string.bold"]),
    codePointAt: define("instance/code-point-at", ["es.string.code-point-at"]),
    codePoints: define("instance/code-points", ["esnext.string.code-points"]),
    concat: define("instance/concat", ["es.array.concat"], undefined, ["String"]),
    copyWithin: define("instance/copy-within", ["es.array.copy-within"]),
    demethodize: define("instance/demethodize", ["esnext.function.demethodize"]),
    description: define(null, ["es.symbol", "es.symbol.description"]),
    dotAll: define(null, ["es.regexp.dot-all"]),
    drop: define(null, ["esnext.async-iterator.drop"].concat(_toConsumableArray(AsyncIteratorDependencies), ["esnext.iterator.drop"], IteratorDependencies)),
    emplace: define("instance/emplace", ["esnext.map.emplace", "esnext.weak-map.emplace"]),
    endsWith: define("instance/ends-with", ["es.string.ends-with"]),
    entries: define("instance/entries", ArrayNatureIteratorsWithTag),
    every: define("instance/every", ["es.array.every", "esnext.async-iterator.every", "esnext.iterator.every"].concat(IteratorDependencies)),
    exec: define(null, ["es.regexp.exec"]),
    fill: define("instance/fill", ["es.array.fill"]),
    filter: define("instance/filter", ["es.array.filter", "esnext.async-iterator.filter", "esnext.iterator.filter"].concat(IteratorDependencies)),
    filterReject: define("instance/filterReject", ["esnext.array.filter-reject"]),
    "finally": define(null, ["es.promise.finally"].concat(PromiseDependencies)),
    find: define("instance/find", ["es.array.find", "esnext.async-iterator.find", "esnext.iterator.find"].concat(IteratorDependencies)),
    findIndex: define("instance/find-index", ["es.array.find-index"]),
    findLast: define("instance/find-last", ["es.array.find-last"]),
    findLastIndex: define("instance/find-last-index", ["es.array.find-last-index"]),
    fixed: define(null, ["es.string.fixed"]),
    flags: define("instance/flags", ["es.regexp.flags"]),
    flatMap: define("instance/flat-map", ["es.array.flat-map", "es.array.unscopables.flat-map", "esnext.async-iterator.flat-map", "esnext.iterator.flat-map"].concat(IteratorDependencies)),
    flat: define("instance/flat", ["es.array.flat", "es.array.unscopables.flat"]),
    getFloat16: define(null, ["esnext.data-view.get-float16"].concat(_toConsumableArray(DataViewDependencies))),
    getUint8Clamped: define(null, ["esnext.data-view.get-uint8-clamped"].concat(_toConsumableArray(DataViewDependencies))),
    getYear: define(null, ["es.date.get-year"]),
    group: define("instance/group", ["esnext.array.group"]),
    groupBy: define("instance/group-by", ["esnext.array.group-by"]),
    groupByToMap: define("instance/group-by-to-map", ["esnext.array.group-by-to-map", "es.map", "es.object.to-string"]),
    groupToMap: define("instance/group-to-map", ["esnext.array.group-to-map", "es.map", "es.object.to-string"]),
    fontcolor: define(null, ["es.string.fontcolor"]),
    fontsize: define(null, ["es.string.fontsize"]),
    forEach: define("instance/for-each", ["es.array.for-each", "esnext.async-iterator.for-each", "esnext.iterator.for-each"].concat(IteratorDependencies, ["web.dom-collections.for-each"])),
    includes: define("instance/includes", ["es.array.includes", "es.string.includes"]),
    indexed: define(null, ["esnext.async-iterator.indexed"].concat(_toConsumableArray(AsyncIteratorDependencies), ["esnext.iterator.indexed"], IteratorDependencies)),
    indexOf: define("instance/index-of", ["es.array.index-of"]),
    isWellFormed: define("instance/is-well-formed", ["es.string.is-well-formed"]),
    italic: define(null, ["es.string.italics"]),
    join: define(null, ["es.array.join"]),
    keys: define("instance/keys", ArrayNatureIteratorsWithTag),
    lastIndex: define(null, ["esnext.array.last-index"]),
    lastIndexOf: define("instance/last-index-of", ["es.array.last-index-of"]),
    lastItem: define(null, ["esnext.array.last-item"]),
    link: define(null, ["es.string.link"]),
    map: define("instance/map", ["es.array.map", "esnext.async-iterator.map", "esnext.iterator.map"]),
    match: define(null, ["es.string.match", "es.regexp.exec"]),
    matchAll: define("instance/match-all", ["es.string.match-all", "es.regexp.exec"]),
    name: define(null, ["es.function.name"]),
    padEnd: define("instance/pad-end", ["es.string.pad-end"]),
    padStart: define("instance/pad-start", ["es.string.pad-start"]),
    push: define("instance/push", ["es.array.push"]),
    reduce: define("instance/reduce", ["es.array.reduce", "esnext.async-iterator.reduce", "esnext.iterator.reduce"].concat(IteratorDependencies)),
    reduceRight: define("instance/reduce-right", ["es.array.reduce-right"]),
    repeat: define("instance/repeat", ["es.string.repeat"]),
    replace: define(null, ["es.string.replace", "es.regexp.exec"]),
    replaceAll: define("instance/replace-all", ["es.string.replace-all", "es.string.replace", "es.regexp.exec"]),
    reverse: define("instance/reverse", ["es.array.reverse"]),
    search: define(null, ["es.string.search", "es.regexp.exec"]),
    setFloat16: define(null, ["esnext.data-view.set-float16"].concat(_toConsumableArray(DataViewDependencies))),
    setUint8Clamped: define(null, ["esnext.data-view.set-uint8-clamped"].concat(_toConsumableArray(DataViewDependencies))),
    setYear: define(null, ["es.date.set-year"]),
    slice: define("instance/slice", ["es.array.slice"]),
    small: define(null, ["es.string.small"]),
    some: define("instance/some", ["es.array.some", "esnext.async-iterator.some", "esnext.iterator.some"].concat(IteratorDependencies)),
    sort: define("instance/sort", ["es.array.sort"]),
    splice: define("instance/splice", ["es.array.splice"]),
    split: define(null, ["es.string.split", "es.regexp.exec"]),
    startsWith: define("instance/starts-with", ["es.string.starts-with"]),
    sticky: define(null, ["es.regexp.sticky"]),
    strike: define(null, ["es.string.strike"]),
    sub: define(null, ["es.string.sub"]),
    substr: define(null, ["es.string.substr"]),
    sup: define(null, ["es.string.sup"]),
    take: define(null, ["esnext.async-iterator.take"].concat(_toConsumableArray(AsyncIteratorDependencies), ["esnext.iterator.take"], IteratorDependencies)),
    test: define(null, ["es.regexp.test", "es.regexp.exec"]),
    toArray: define(null, ["esnext.async-iterator.to-array"].concat(_toConsumableArray(AsyncIteratorDependencies), ["esnext.iterator.to-array"], IteratorDependencies)),
    toAsync: define(null, ["esnext.iterator.to-async"].concat(IteratorDependencies, _toConsumableArray(AsyncIteratorDependencies), AsyncIteratorProblemMethods)),
    toExponential: define(null, ["es.number.to-exponential"]),
    toFixed: define(null, ["es.number.to-fixed"]),
    toGMTString: define(null, ["es.date.to-gmt-string"]),
    toISOString: define(null, ["es.date.to-iso-string"]),
    toJSON: define(null, ["es.date.to-json"]),
    toPrecision: define(null, ["es.number.to-precision"]),
    toReversed: define("instance/to-reversed", ["es.array.to-reversed"]),
    toSorted: define("instance/to-sorted", ["es.array.to-sorted", "es.array.sort"]),
    toSpliced: define("instance/to-spliced", ["es.array.to-spliced"]),
    toString: define(null, ["es.object.to-string", "es.error.to-string", "es.date.to-string", "es.regexp.to-string"]),
    toWellFormed: define("instance/to-well-formed", ["es.string.to-well-formed"]),
    trim: define("instance/trim", ["es.string.trim"]),
    trimEnd: define("instance/trim-end", ["es.string.trim-end"]),
    trimLeft: define("instance/trim-left", ["es.string.trim-start"]),
    trimRight: define("instance/trim-right", ["es.string.trim-end"]),
    trimStart: define("instance/trim-start", ["es.string.trim-start"]),
    uniqueBy: define("instance/unique-by", ["esnext.array.unique-by", "es.map"]),
    unshift: define("instance/unshift", ["es.array.unshift"]),
    unThis: define("instance/un-this", ["esnext.function.un-this"]),
    values: define("instance/values", ArrayNatureIteratorsWithTag),
    "with": define("instance/with", ["es.array.with"]),
    __defineGetter__: define(null, ["es.object.define-getter"]),
    __defineSetter__: define(null, ["es.object.define-setter"]),
    __lookupGetter__: define(null, ["es.object.lookup-getter"]),
    __lookupSetter__: define(null, ["es.object.lookup-setter"])
  }, _InstanceProperties["__proto__"] = define(null, ["es.object.proto"]), _InstanceProperties);
  var stable = new Set(["array", "array/from", "array/is-array", "array/of", "clear-immediate", "date/now", "instance/bind", "instance/code-point-at", "instance/concat", "instance/copy-within", "instance/ends-with", "instance/entries", "instance/every", "instance/fill", "instance/filter", "instance/find", "instance/find-index", "instance/flags", "instance/flat", "instance/flat-map", "instance/for-each", "instance/includes", "instance/index-of", "instance/keys", "instance/last-index-of", "instance/map", "instance/pad-end", "instance/pad-start", "instance/reduce", "instance/reduce-right", "instance/repeat", "instance/reverse", "instance/slice", "instance/some", "instance/sort", "instance/splice", "instance/starts-with", "instance/trim", "instance/trim-end", "instance/trim-left", "instance/trim-right", "instance/trim-start", "instance/values", "json/stringify", "map", "math/acosh", "math/asinh", "math/atanh", "math/cbrt", "math/clz32", "math/cosh", "math/expm1", "math/fround", "math/hypot", "math/imul", "math/log10", "math/log1p", "math/log2", "math/sign", "math/sinh", "math/tanh", "math/trunc", "number/epsilon", "number/is-finite", "number/is-integer", "number/is-nan", "number/is-safe-integer", "number/max-safe-integer", "number/min-safe-integer", "number/parse-float", "number/parse-int", "object/assign", "object/create", "object/define-properties", "object/define-property", "object/entries", "object/freeze", "object/from-entries", "object/get-own-property-descriptor", "object/get-own-property-descriptors", "object/get-own-property-names", "object/get-own-property-symbols", "object/get-prototype-of", "object/is", "object/is-extensible", "object/is-frozen", "object/is-sealed", "object/keys", "object/prevent-extensions", "object/seal", "object/set-prototype-of", "object/values", "parse-float", "parse-int", "promise", "queue-microtask", "reflect/apply", "reflect/construct", "reflect/define-property", "reflect/delete-property", "reflect/get", "reflect/get-own-property-descriptor", "reflect/get-prototype-of", "reflect/has", "reflect/is-extensible", "reflect/own-keys", "reflect/prevent-extensions", "reflect/set", "reflect/set-prototype-of", "set", "set-immediate", "set-interval", "set-timeout", "string/from-code-point", "string/raw", "symbol", "symbol/async-iterator", "symbol/for", "symbol/has-instance", "symbol/is-concat-spreadable", "symbol/iterator", "symbol/key-for", "symbol/match", "symbol/replace", "symbol/search", "symbol/species", "symbol/split", "symbol/to-primitive", "symbol/to-string-tag", "symbol/unscopables", "url", "url-search-params", "weak-map", "weak-set"]);
  var proposals = new Set([].concat(_toConsumableArray(stable), ["aggregate-error", "composite-key", "composite-symbol", "global-this", "instance/at", "instance/code-points", "instance/match-all", "instance/replace-all", "math/clamp", "math/degrees", "math/deg-per-rad", "math/fscale", "math/iaddh", "math/imulh", "math/isubh", "math/rad-per-deg", "math/radians", "math/scale", "math/seeded-prng", "math/signbit", "math/umulh", "number/from-string", "observable", "reflect/define-metadata", "reflect/delete-metadata", "reflect/get-metadata", "reflect/get-metadata-keys", "reflect/get-own-metadata", "reflect/get-own-metadata-keys", "reflect/has-metadata", "reflect/has-own-metadata", "reflect/metadata", "symbol/dispose", "symbol/observable", "symbol/pattern-match"]));
  var _ref = _babel,
    t$2 = _ref.types;
  function canSkipPolyfill(desc, path) {
    var node = path.node,
      parent = path.parent;
    switch (desc.name) {
      case "es.string.split":
        {
          if (!t$2.isCallExpression(parent, {
            callee: node
          })) return false;
          if (parent.arguments.length < 1) return true;
          var splitter = parent.arguments[0];
          return t$2.isStringLiteral(splitter) || t$2.isTemplateLiteral(splitter);
        }
    }
  }
  var _ref2 = _babel,
    t$1 = _ref2.types;
  var BABEL_RUNTIME = "@babel/runtime-corejs3";
  function callMethod(path, id) {
    var object = path.node.object;
    var context1, context2;
    if (t$1.isIdentifier(object)) {
      context1 = object;
      context2 = t$1.cloneNode(object);
    } else {
      context1 = path.scope.generateDeclaredUidIdentifier("context");
      context2 = t$1.assignmentExpression("=", t$1.cloneNode(context1), object);
    }
    path.replaceWith(t$1.memberExpression(t$1.callExpression(id, [context2]), t$1.identifier("call")));
    path.parentPath.unshiftContainer("arguments", context1);
  }
  function isCoreJSSource(source) {
    if (typeof source === "string") {
      source = source.replace(/\\/g, "/").replace(/(\/(index)?)?(\.js)?$/i, "").toLowerCase();
    }
    return Object.prototype.hasOwnProperty.call(entries, source) && entries[source];
  }
  function coreJSModule(name) {
    return "core-js/modules/" + name + ".js";
  }
  function coreJSPureHelper(name, useBabelRuntime, ext) {
    return useBabelRuntime ? BABEL_RUNTIME + "/core-js/" + name + ext : "core-js-pure/features/" + name + ".js";
  }
  var _ref3 = _babel,
    t = _ref3.types;
  var presetEnvCompat = "#__secret_key__@babel/preset-env__compatibility";
  var runtimeCompat = "#__secret_key__@babel/runtime__compatibility";
  var uniqueObjects = ["array", "string", "iterator", "async-iterator", "dom-collections"].map(function (v) {
    return new RegExp("[a-z]*\\." + v + "\\..*");
  });
  var esnextFallback = function esnextFallback(name, cb) {
    if (cb(name)) return true;
    if (!name.startsWith("es.")) return false;
    var fallback = "esnext." + name.slice(3);
    if (!data[fallback]) return false;
    return cb(fallback);
  };
  var index = definePolyfillProvider(function (_ref4, _ref5) {
    var getUtils = _ref4.getUtils,
      method = _ref4.method,
      shouldInjectPolyfill = _ref4.shouldInjectPolyfill,
      createMetaResolver = _ref4.createMetaResolver,
      debug = _ref4.debug,
      babel = _ref4.babel;
    var _ref5$version = _ref5.version,
      version = _ref5$version === void 0 ? 3 : _ref5$version,
      proposals$1 = _ref5.proposals,
      shippedProposals = _ref5.shippedProposals,
      _ref5$presetEnvCompat = _ref5[presetEnvCompat],
      _ref5$presetEnvCompat2 = _ref5$presetEnvCompat === void 0 ? {} : _ref5$presetEnvCompat,
      _ref5$presetEnvCompat3 = _ref5$presetEnvCompat2.noRuntimeName,
      noRuntimeName = _ref5$presetEnvCompat3 === void 0 ? false : _ref5$presetEnvCompat3,
      _ref5$runtimeCompat = _ref5[runtimeCompat],
      _ref5$runtimeCompat2 = _ref5$runtimeCompat === void 0 ? {} : _ref5$runtimeCompat,
      _ref5$runtimeCompat2$ = _ref5$runtimeCompat2.useBabelRuntime,
      useBabelRuntime = _ref5$runtimeCompat2$ === void 0 ? false : _ref5$runtimeCompat2$,
      _ref5$runtimeCompat2$2 = _ref5$runtimeCompat2.ext,
      ext = _ref5$runtimeCompat2$2 === void 0 ? ".js" : _ref5$runtimeCompat2$2;
    var isWebpack = babel.caller(function (caller) {
      return (caller == null ? void 0 : caller.name) === "babel-loader";
    });
    var resolve = createMetaResolver({
      global: BuiltIns,
      "static": StaticProperties,
      instance: InstanceProperties
    });
    var available = new Set(getModulesListForTargetVersion(version));
    function getCoreJSPureBase(useProposalBase) {
      return useBabelRuntime ? useProposalBase ? BABEL_RUNTIME + "/core-js" : BABEL_RUNTIME + "/core-js-stable" : useProposalBase ? "core-js-pure/features" : "core-js-pure/stable";
    }
    function maybeInjectGlobalImpl(name, utils) {
      if (shouldInjectPolyfill(name)) {
        debug(name);
        utils.injectGlobalImport(coreJSModule(name), name);
        return true;
      }
      return false;
    }
    function maybeInjectGlobal(names, utils, fallback) {
      if (fallback === void 0) {
        fallback = true;
      }
      for (var _iterator = _createForOfIteratorHelperLoose(names), _step; !(_step = _iterator()).done;) {
        var name = _step.value;
        if (fallback) {
          esnextFallback(name, function (name) {
            return maybeInjectGlobalImpl(name, utils);
          });
        } else {
          maybeInjectGlobalImpl(name, utils);
        }
      }
    }
    function maybeInjectPure(desc, hint, utils, object) {
      if (desc.pure && !(object && desc.exclude && desc.exclude.includes(object)) && esnextFallback(desc.name, shouldInjectPolyfill)) {
        var name = desc.name;
        var useProposalBase = false;
        if (proposals$1 || shippedProposals && name.startsWith("esnext.")) {
          useProposalBase = true;
        } else if (name.startsWith("es.") && !available.has(name)) {
          useProposalBase = true;
        }
        if (useBabelRuntime && !(useProposalBase ? proposals : stable).has(desc.pure)) {
          return;
        }
        var coreJSPureBase = getCoreJSPureBase(useProposalBase);
        return utils.injectDefaultImport(coreJSPureBase + "/" + desc.pure + ext, hint);
      }
    }
    function isFeatureStable(name) {
      if (name.startsWith("esnext.")) {
        var esName = "es." + name.slice(7);
        return esName in data;
      }
      return true;
    }
    return {
      name: "corejs3",
      runtimeName: noRuntimeName ? null : BABEL_RUNTIME,
      polyfills: data,
      filterPolyfills: function filterPolyfills(name) {
        if (!available.has(name)) return false;
        if (proposals$1 || method === "entry-global") return true;
        if (shippedProposals && corejs3ShippedProposalsList.has(name)) {
          return true;
        }
        return isFeatureStable(name);
      },
      entryGlobal: function entryGlobal(meta, utils, path) {
        if (meta.kind !== "import") return;
        var modules = isCoreJSSource(meta.source);
        if (!modules) return;
        if (modules.length === 1 && meta.source === coreJSModule(modules[0]) && shouldInjectPolyfill(modules[0])) {
          debug(null);
          return;
        }
        var modulesSet = new Set(modules);
        var filteredModules = modules.filter(function (module) {
          if (!module.startsWith("esnext.")) return true;
          var stable = module.replace("esnext.", "es.");
          if (modulesSet.has(stable) && shouldInjectPolyfill(stable)) {
            return false;
          }
          return true;
        });
        maybeInjectGlobal(filteredModules, utils, false);
        path.remove();
      },
      usageGlobal: function usageGlobal(meta, utils, path) {
        var resolved = resolve(meta);
        if (!resolved) return;
        if (canSkipPolyfill(resolved.desc, path)) return;
        var deps = resolved.desc.global;
        if (resolved.kind !== "global" && "object" in meta && meta.object && meta.placement === "prototype") {
          var low = meta.object.toLowerCase();
          deps = deps.filter(function (m) {
            return uniqueObjects.some(function (v) {
              return v.test(m);
            }) ? m.includes(low) : true;
          });
        }
        maybeInjectGlobal(deps, utils);
        return true;
      },
      usagePure: function usagePure(meta, utils, path) {
        if (meta.kind === "in") {
          if (meta.key === "Symbol.iterator") {
            path.replaceWith(t.callExpression(utils.injectDefaultImport(coreJSPureHelper("is-iterable", useBabelRuntime, ext), "isIterable"), [path.node.right]));
          }
          return;
        }
        if (path.parentPath.isUnaryExpression({
          operator: "delete"
        })) return;
        if (meta.kind === "property") {
          if (!path.isMemberExpression()) return;
          if (!path.isReferenced()) return;
          if (path.parentPath.isUpdateExpression()) return;
          if (t.isSuper(path.node.object)) {
            return;
          }
          if (meta.key === "Symbol.iterator") {
            if (!shouldInjectPolyfill("es.symbol.iterator")) return;
            var parent = path.parent,
              node = path.node;
            if (t.isCallExpression(parent, {
              callee: node
            })) {
              if (parent.arguments.length === 0) {
                path.parentPath.replaceWith(t.callExpression(utils.injectDefaultImport(coreJSPureHelper("get-iterator", useBabelRuntime, ext), "getIterator"), [node.object]));
                path.skip();
              } else {
                callMethod(path, utils.injectDefaultImport(coreJSPureHelper("get-iterator-method", useBabelRuntime, ext), "getIteratorMethod"));
              }
            } else {
              path.replaceWith(t.callExpression(utils.injectDefaultImport(coreJSPureHelper("get-iterator-method", useBabelRuntime, ext), "getIteratorMethod"), [path.node.object]));
            }
            return;
          }
        }
        var resolved = resolve(meta);
        if (!resolved) return;
        if (canSkipPolyfill(resolved.desc, path)) return;
        if (useBabelRuntime && resolved.desc.pure && resolved.desc.pure.slice(-6) === "/index") {
          resolved = Object.assign(Object.assign({}, resolved), {}, {
            desc: Object.assign(Object.assign({}, resolved.desc), {}, {
              pure: resolved.desc.pure.slice(0, -6)
            })
          });
        }
        if (resolved.kind === "global") {
          var id = maybeInjectPure(resolved.desc, resolved.name, utils);
          if (id) path.replaceWith(id);
        } else if (resolved.kind === "static") {
          var _id = maybeInjectPure(resolved.desc, resolved.name, utils, meta.object);
          if (_id) path.replaceWith(_id);
        } else if (resolved.kind === "instance") {
          var _id2 = maybeInjectPure(resolved.desc, resolved.name + "InstanceProperty", utils, meta.object);
          if (!_id2) return;
          var _node = path.node;
          if (t.isCallExpression(path.parent, {
            callee: _node
          })) {
            callMethod(path, _id2);
          } else {
            path.replaceWith(t.callExpression(_id2, [_node.object]));
          }
        }
      },
      visitor: method === "usage-global" && {
        CallExpression: function CallExpression(path) {
          if (path.get("callee").isImport()) {
            var utils = getUtils(path);
            if (isWebpack) {
              maybeInjectGlobal(PromiseDependenciesWithIterators, utils);
            } else {
              maybeInjectGlobal(PromiseDependencies, utils);
            }
          }
        },
        Function: function Function(path) {
          if (path.node.async) {
            maybeInjectGlobal(PromiseDependencies, getUtils(path));
          }
        },
        "ForOfStatement|ArrayPattern": function ForOfStatementArrayPattern(path) {
          maybeInjectGlobal(CommonIterators, getUtils(path));
        },
        SpreadElement: function SpreadElement(path) {
          if (!path.parentPath.isObjectExpression()) {
            maybeInjectGlobal(CommonIterators, getUtils(path));
          }
        },
        YieldExpression: function YieldExpression(path) {
          if (path.node.delegate) {
            maybeInjectGlobal(CommonIterators, getUtils(path));
          }
        },
        Class: function Class(path) {
          var _path$node$decorators;
          var hasDecorators = ((_path$node$decorators = path.node.decorators) == null ? void 0 : _path$node$decorators.length) || path.node.body.body.some(function (el) {
            var _decorators;
            return (_decorators = el.decorators) == null ? void 0 : _decorators.length;
          });
          if (hasDecorators) {
            maybeInjectGlobal(DecoratorMetadataDependencies, getUtils(path));
          }
        }
      }
    };
  });

new OptionValidator("@babel/preset-flow");
  function normalizeOptions$2(options) {
    if (options === void 0) {
      options = {};
    }
    var _options = options,
      all = _options.all,
      ignoreExtensions = _options.ignoreExtensions,
      experimental_useHermesParser = _options.experimental_useHermesParser;
    var _options2 = options,
      allowDeclareFields = _options2.allowDeclareFields;
    {
      return {
        all: all,
        allowDeclareFields: allowDeclareFields,
        ignoreExtensions: ignoreExtensions,
        experimental_useHermesParser: experimental_useHermesParser
      };
    }
  }

new OptionValidator("@babel/preset-react");
  function normalizeOptions$1(options) {
    if (options === void 0) {
      options = {};
    }
    {
      var _options = options,
        pragma = _options.pragma,
        pragmaFrag = _options.pragmaFrag;
      var _options2 = options,
        pure = _options2.pure,
        _options2$throwIfName = _options2.throwIfNamespace,
        throwIfNamespace = _options2$throwIfName === void 0 ? true : _options2$throwIfName,
        _options2$runtime = _options2.runtime,
        runtime = _options2$runtime === void 0 ? "classic" : _options2$runtime,
        importSource = _options2.importSource,
        useBuiltIns = _options2.useBuiltIns,
        useSpread = _options2.useSpread;
      if (runtime === "classic") {
        pragma = pragma || "React.createElement";
        pragmaFrag = pragmaFrag || "React.Fragment";
      }
      var development = options.development == null ? undefined : !!options.development;
      return {
        development: development,
        importSource: importSource,
        pragma: pragma,
        pragmaFrag: pragmaFrag,
        pure: pure,
        runtime: runtime,
        throwIfNamespace: throwIfNamespace,
        useBuiltIns: useBuiltIns,
        useSpread: useSpread
      };
    }
  }

var _templateObject;
  var pluginRewriteTSImports = declare(function (_ref) {
    var t = _ref.types,
      template = _ref.template;
    function maybeReplace(source, path) {
      if (!source) return;
      if (t.isStringLiteral(source)) {
        if (/[\\/]/.test(source.value)) {
          source.value = source.value.replace(/(\.[mc]?)ts$/, "$1js").replace(/\.tsx$/, ".js");
        }
        return;
      }
      path.replaceWith(template.expression.ast(_templateObject || (_templateObject = _taggedTemplateLiteralLoose(["(", " + \"\").replace(/([\\/].*.[mc]?)tsx?$/, \"$1js\")"], ["(", " + \"\").replace(/([\\\\/].*\\.[mc]?)tsx?$/, \"$1js\")"])), source));
    }
    return {
      name: "preset-typescript/plugin-rewrite-ts-imports",
      visitor: {
        "ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration": function ImportDeclarationExportAllDeclarationExportNamedDeclaration(path) {
          var node = path.node;
          var kind = t.isImportDeclaration(node) ? node.importKind : node.exportKind;
          if (kind === "value") {
            maybeReplace(node.source, path.get("source"));
          }
        },
        CallExpression: function CallExpression(path) {
          if (t.isImport(path.node.callee)) {
            maybeReplace(path.node.arguments[0], path.get("arguments.0"));
          }
        },
        ImportExpression: function ImportExpression(path) {
          maybeReplace(path.node.source, path.get("source"));
        }
      }
    };
  });

var packages = /*#__PURE__*/Object.freeze({
    __proto__: null,
    generator: index$2,
    parser: index$4,
    template: index$3,
    traverse: index$1,
    types: t$4
  });

var legacyPluginAliases = {
    __proto__: null,
    "transform-class-static-block": "proposal-class-static-block",
    "transform-private-property-in-object": "proposal-private-property-in-object",
    "transform-class-properties": "proposal-class-properties",
    "transform-private-methods": "proposal-private-methods",
    "transform-numeric-separator": "proposal-numeric-separator",
    "transform-logical-assignment-operators": "proposal-logical-assignment-operators",
    "transform-nullish-coalescing-operator": "proposal-nullish-coalescing-operator",
    "transform-optional-chaining": "proposal-optional-chaining",
    "transform-json-strings": "proposal-json-strings",
    "transform-optional-catch-binding": "proposal-optional-catch-binding",
    "transform-async-generator-functions": "proposal-async-generator-functions",
    "transform-object-rest-spread": "proposal-object-rest-spread",
    "transform-unicode-property-regex": "proposal-unicode-property-regex",
    "transform-export-namespace-from": "proposal-export-namespace-from"
  };

var _window;
  for (var name in legacyPluginAliases) {
    all[legacyPluginAliases[name]] = all[name];
  }
  all["proposal-unicode-sets-regex"] = all["transform-unicode-sets-regex"];
  var availablePlugins = {};
  registerPlugins(all);
  var availablePresets = {
    env: presetEnv,
    es2015: preset2015,
    es2016: function es2016() {
      return {
        plugins: [availablePlugins["transform-exponentiation-operator"]]
      };
    },
    es2017: function es2017() {
      return {
        plugins: [availablePlugins["transform-async-to-generator"]]
      };
    },
    react: presetReact,
    "stage-0": presetStage0,
    "stage-1": presetStage1,
    "stage-2": presetStage2,
    "stage-3": presetStage3,
    "es2015-loose": {
      presets: [[preset2015, {
        loose: true
      }]]
    },
    "es2015-no-commonjs": {
      presets: [[preset2015, {
        modules: false
      }]]
    },
    typescript: presetTypescript,
    flow: presetFlow
  };
  var isArray = Array.isArray || function (arg) {
    return Object.prototype.toString.call(arg) === "[object Array]";
  };
  function loadBuiltin(builtinTable, name) {
    if (isArray(name) && typeof name[0] === "string") {
      if (hasOwnProperty.call(builtinTable, name[0])) {
        return [builtinTable[name[0]]].concat(name.slice(1));
      }
      return;
    } else if (typeof name === "string") {
      return builtinTable[name];
    }
    return name;
  }
  function processOptions(options) {
    var presets = (options.presets || []).map(function (presetName) {
      var preset = loadBuiltin(availablePresets, presetName);
      if (preset) {
        if (isArray(preset) && typeof preset[0] === "object" && hasOwnProperty.call(preset[0], "buildPreset")) {
          preset[0] = Object.assign({}, preset[0], {
            buildPreset: preset[0].buildPreset
          });
        }
      } else {
        throw new Error("Invalid preset specified in Babel options: \"" + presetName + "\"");
      }
      return preset;
    });
    var plugins = (options.plugins || []).map(function (pluginName) {
      var plugin = loadBuiltin(availablePlugins, pluginName);
      if (!plugin) {
        throw new Error("Invalid plugin specified in Babel options: \"" + pluginName + "\"");
      }
      return plugin;
    });
    return Object.assign({
      babelrc: false
    }, options, {
      presets: presets,
      plugins: plugins
    });
  }
  function transform(code, options) {
    return transformSync(code, processOptions(options));
  }
  function transformFromAst(ast, code, options) {
    return transformFromAstSync(ast, code, processOptions(options));
  }
  var buildExternalHelpers = babelBuildExternalHelpers;
  function registerPlugin(name, plugin) {
    if (hasOwnProperty.call(availablePlugins, name)) {
      console.warn("A plugin named \"" + name + "\" is already registered, it will be overridden");
    }
    availablePlugins[name] = plugin;
  }
  function registerPlugins(newPlugins) {
    Object.keys(newPlugins).forEach(function (name) {
      return registerPlugin(name, newPlugins[name]);
    });
  }
  function registerPreset(name, preset) {
    if (hasOwnProperty.call(availablePresets, name)) {
      if (name === "env") {
        console.warn("@babel/preset-env is now included in @babel/standalone, please remove @babel/preset-env-standalone");
      } else {
        console.warn("A preset named \"" + name + "\" is already registered, it will be overridden");
      }
    }
    availablePresets[name] = preset;
  }
  function registerPresets(newPresets) {
    Object.keys(newPresets).forEach(function (name) {
      return registerPreset(name, newPresets[name]);
    });
  }
  var version = "7.26.7";
  function onDOMContentLoaded() {
    transformScriptTags();
  }
  if (typeof window !== "undefined" && (_window = window) != null && _window.addEventListener) {
    window.addEventListener("DOMContentLoaded", onDOMContentLoaded, false);
  }
  function transformScriptTags(scriptTags) {
    runScripts(transform, scriptTags);
  }
  function disableScriptTags() {
    window.removeEventListener("DOMContentLoaded", onDOMContentLoaded);
  }

exports.availablePlugins = availablePlugins;
  exports.availablePresets = availablePresets;
  exports.buildExternalHelpers = buildExternalHelpers;
  exports.disableScriptTags = disableScriptTags;
  exports.packages = packages;
  exports.registerPlugin = registerPlugin;
  exports.registerPlugins = registerPlugins;
  exports.registerPreset = registerPreset;
  exports.registerPresets = registerPresets;
  exports.transform = transform;
  exports.transformFromAst = transformFromAst;
  exports.transformScriptTags = transformScriptTags;
  exports.version = version;

Object.defineProperty(exports, '__esModule', { value: true });

}));
//# sourceMappingURL=babel.js.map

文件操作 - babel.js

文件: /var/www/OLD/node_modules/@babel/standalone/babel.js

编辑文件内容

修改文件时间

删除文件