astexplorer.app/vendor/astexplorer/out/43.js

https://astexplorer.net with ES Modules support and Hot Reloading

(window.webpackJsonp=window.webpackJsonp||[]).push([[43],{"./node_modules/regexp-tree/dist/compat-transpiler/index.js":function(module,exports,__webpack_require__){"use strict";eval("/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n\n\nvar compatTransforms = __webpack_require__(\"./node_modules/regexp-tree/dist/compat-transpiler/transforms/index.js\");\n\nvar _transform = __webpack_require__(\"./node_modules/regexp-tree/dist/transform/index.js\");\n\nmodule.exports = {\n  /**\n   * Translates a regexp in new syntax to equivalent regexp in old syntax.\n   *\n   * @param string|RegExp|AST - regexp\n   * @param Array transformsWhitelist - names of the transforms to apply\n   */\n  transform: function transform(regexp) {\n    var transformsWhitelist = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n    var transformToApply = transformsWhitelist.length > 0 ? transformsWhitelist : Object.keys(compatTransforms);\n    var result = void 0; // Collect extra data per transform.\n\n    var extra = {};\n    transformToApply.forEach(function (transformName) {\n      if (!compatTransforms.hasOwnProperty(transformName)) {\n        throw new Error('Unknown compat-transform: ' + transformName + '. ' + 'Available transforms are: ' + Object.keys(compatTransforms).join(', '));\n      }\n\n      var handler = compatTransforms[transformName];\n      result = _transform.transform(regexp, handler);\n      regexp = result.getAST(); // Collect `extra` transform result.\n\n      if (typeof handler.getExtra === 'function') {\n        extra[transformName] = handler.getExtra();\n      }\n    }); // Set the final extras for all transforms.\n\n    result.setExtra(extra);\n    return result;\n  }\n};\n\n//# sourceURL=webpack:///./node_modules/regexp-tree/dist/compat-transpiler/index.js?")},"./node_modules/regexp-tree/dist/compat-transpiler/runtime/index.js":function(module,exports,__webpack_require__){"use strict";eval("/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n\n/**\n * The `RegExpTree` class provides runtime support for `compat-transpiler`\n * module from `regexp-tree`.\n *\n * E.g. it tracks names of the capturing groups, in order to access the\n * names on the matched result.\n *\n * It's a thin-wrapper on top of original regexp.\n */\n\nvar _createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nvar RegExpTree = function () {\n  /**\n   * Initializes a `RegExpTree` instance.\n   *\n   * @param RegExp - a regular expression\n   *\n   * @param Object state:\n   *\n   *   An extra state which may store any related to transformation\n   *   data, for example, names of the groups.\n   *\n   *   - flags - original flags\n   *   - groups - names of the groups, and their indices\n   *   - source - original source\n   */\n  function RegExpTree(re, _ref) {\n    var flags = _ref.flags,\n        groups = _ref.groups,\n        source = _ref.source;\n\n    _classCallCheck(this, RegExpTree);\n\n    this._re = re;\n    this._groups = groups; // Original props.\n\n    this.flags = flags;\n    this.source = source || re.source;\n    this.dotAll = flags.includes('s'); // Inherited directly from `re`.\n\n    this.global = re.global;\n    this.ignoreCase = re.ignoreCase;\n    this.multiline = re.multiline;\n    this.sticky = re.sticky;\n    this.unicode = re.unicode;\n  }\n  /**\n   * Facade wrapper for RegExp `test` method.\n   */\n\n\n  _createClass(RegExpTree, [{\n    key: 'test',\n    value: function test(string) {\n      return this._re.test(string);\n    }\n    /**\n     * Facade wrapper for RegExp `compile` method.\n     */\n\n  }, {\n    key: 'compile',\n    value: function compile(string) {\n      return this._re.compile(string);\n    }\n    /**\n     * Facade wrapper for RegExp `toString` method.\n     */\n\n  }, {\n    key: 'toString',\n    value: function toString() {\n      if (!this._toStringResult) {\n        this._toStringResult = '/' + this.source + '/' + this.flags;\n      }\n\n      return this._toStringResult;\n    }\n    /**\n     * Facade wrapper for RegExp `exec` method.\n     */\n\n  }, {\n    key: 'exec',\n    value: function exec(string) {\n      var result = this._re.exec(string);\n\n      if (!this._groups || !result) {\n        return result;\n      }\n\n      result.groups = {};\n\n      for (var group in this._groups) {\n        var groupNumber = this._groups[group];\n        result.groups[group] = result[groupNumber];\n      }\n\n      return result;\n    }\n  }]);\n\n  return RegExpTree;\n}();\n\nmodule.exports = {\n  RegExpTree: RegExpTree\n};\n\n//# sourceURL=webpack:///./node_modules/regexp-tree/dist/compat-transpiler/runtime/index.js?")},"./node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-dotall-s-transform.js":function(module,exports,__webpack_require__){"use strict";eval("/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n\n/**\n * A regexp-tree plugin to translate `/./s` to `/[\\0-\\uFFFF]/`.\n */\n\nmodule.exports = {\n  // Whether `u` flag present. In which case we transform to\n  // \\u{10FFFF} instead of \\uFFFF.\n  _hasUFlag: false,\n  // Only run this plugin if we have `s` flag.\n  shouldRun: function shouldRun(ast) {\n    var shouldRun = ast.flags.includes('s');\n\n    if (!shouldRun) {\n      return false;\n    } // Strip the `s` flag.\n\n\n    ast.flags = ast.flags.replace('s', ''); // Whether we have also `u`.\n\n    this._hasUFlag = ast.flags.includes('u');\n    return true;\n  },\n  Char: function Char(path) {\n    var node = path.node;\n\n    if (node.kind !== 'meta' || node.value !== '.') {\n      return;\n    }\n\n    var toValue = \"\\\\uFFFF\";\n    var toSymbol = \"\\uFFFF\";\n\n    if (this._hasUFlag) {\n      toValue = \"\\\\u{10FFFF}\";\n      toSymbol = \"\\uDBFF\\uDFFF\";\n    }\n\n    path.replace({\n      type: 'CharacterClass',\n      expressions: [{\n        type: 'ClassRange',\n        from: {\n          type: 'Char',\n          value: '\\\\0',\n          kind: 'decimal',\n          symbol: '\\0'\n        },\n        to: {\n          type: 'Char',\n          value: toValue,\n          kind: 'unicode',\n          symbol: toSymbol\n        }\n      }]\n    });\n  }\n};\n\n//# sourceURL=webpack:///./node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-dotall-s-transform.js?")},"./node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-named-capturing-groups-transform.js":function(module,exports,__webpack_require__){"use strict";eval("/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n\n/**\n * A regexp-tree plugin to translate `/(?<name>a)\\k<name>/` to `/(a)\\1/`.\n */\n\nmodule.exports = {\n  // To track the names of the groups, and return them\n  // in the transform result state.\n  //\n  // A map from name to number: {foo: 2, bar: 4}\n  _groupNames: {},\n\n  /**\n   * Initialises the trasnform.\n   */\n  init: function init() {\n    this._groupNames = {};\n  },\n\n  /**\n   * Returns extra state, which eventually is returned to\n   */\n  getExtra: function getExtra() {\n    return this._groupNames;\n  },\n  Group: function Group(path) {\n    var node = path.node;\n\n    if (!node.name) {\n      return;\n    } // Record group name.\n\n\n    this._groupNames[node.name] = node.number;\n    delete node.name;\n    delete node.nameRaw;\n  },\n  Backreference: function Backreference(path) {\n    var node = path.node;\n\n    if (node.kind !== 'name') {\n      return;\n    }\n\n    node.kind = 'number';\n    node.reference = node.number;\n    delete node.referenceRaw;\n  }\n};\n\n//# sourceURL=webpack:///./node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-named-capturing-groups-transform.js?")},"./node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-x-flag-transform.js":function(module,exports,__webpack_require__){"use strict";eval("/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n\n/**\n * A regexp-tree plugin to remove `x` flag `/foo/x` to `/foo/`.\n *\n * Note: other features of `x` flags (whitespace, comments) are\n * already removed at parsing stage.\n */\n\nmodule.exports = {\n  RegExp: function RegExp(_ref) {\n    var node = _ref.node;\n\n    if (node.flags.includes('x')) {\n      node.flags = node.flags.replace('x', '');\n    }\n  }\n};\n\n//# sourceURL=webpack:///./node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-x-flag-transform.js?")},"./node_modules/regexp-tree/dist/compat-transpiler/transforms/index.js":function(module,exports,__webpack_require__){"use strict";eval('/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n\n\nmodule.exports = {\n  // "dotAll" `s` flag\n  dotAll: __webpack_require__("./node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-dotall-s-transform.js"),\n  // Named capturing groups.\n  namedCapturingGroups: __webpack_require__("./node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-named-capturing-groups-transform.js"),\n  // `x` flag\n  xFlag: __webpack_require__("./node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-x-flag-transform.js")\n};\n\n//# sourceURL=webpack:///./node_modules/regexp-tree/dist/compat-transpiler/transforms/index.js?')},"./node_modules/regexp-tree/dist/generator/index.js":function(module,exports,__webpack_require__){"use strict";eval("/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n\n/**\n * Helper `gen` function calls node type handler.\n */\n\nfunction gen(node) {\n  return node ? generator[node.type](node) : '';\n}\n/**\n * AST handler.\n */\n\n\nvar generator = {\n  RegExp: function RegExp(node) {\n    return '/' + gen(node.body) + '/' + node.flags;\n  },\n  Alternative: function Alternative(node) {\n    return (node.expressions || []).map(gen).join('');\n  },\n  Disjunction: function Disjunction(node) {\n    return gen(node.left) + '|' + gen(node.right);\n  },\n  Group: function Group(node) {\n    var expression = gen(node.expression);\n\n    if (node.capturing) {\n      // A named group.\n      if (node.name) {\n        return '(?<' + (node.nameRaw || node.name) + '>' + expression + ')';\n      }\n\n      return '(' + expression + ')';\n    }\n\n    return '(?:' + expression + ')';\n  },\n  Backreference: function Backreference(node) {\n    switch (node.kind) {\n      case 'number':\n        return '\\\\' + node.reference;\n\n      case 'name':\n        return '\\\\k<' + (node.referenceRaw || node.reference) + '>';\n\n      default:\n        throw new TypeError('Unknown Backreference kind: ' + node.kind);\n    }\n  },\n  Assertion: function Assertion(node) {\n    switch (node.kind) {\n      case '^':\n      case '$':\n      case '\\\\b':\n      case '\\\\B':\n        return node.kind;\n\n      case 'Lookahead':\n        {\n          var assertion = gen(node.assertion);\n\n          if (node.negative) {\n            return '(?!' + assertion + ')';\n          }\n\n          return '(?=' + assertion + ')';\n        }\n\n      case 'Lookbehind':\n        {\n          var _assertion = gen(node.assertion);\n\n          if (node.negative) {\n            return '(?<!' + _assertion + ')';\n          }\n\n          return '(?<=' + _assertion + ')';\n        }\n\n      default:\n        throw new TypeError('Unknown Assertion kind: ' + node.kind);\n    }\n  },\n  CharacterClass: function CharacterClass(node) {\n    var expressions = node.expressions.map(gen).join('');\n\n    if (node.negative) {\n      return '[^' + expressions + ']';\n    }\n\n    return '[' + expressions + ']';\n  },\n  ClassRange: function ClassRange(node) {\n    return gen(node.from) + '-' + gen(node.to);\n  },\n  Repetition: function Repetition(node) {\n    return '' + gen(node.expression) + gen(node.quantifier);\n  },\n  Quantifier: function Quantifier(node) {\n    var quantifier = void 0;\n    var greedy = node.greedy ? '' : '?';\n\n    switch (node.kind) {\n      case '+':\n      case '?':\n      case '*':\n        quantifier = node.kind;\n        break;\n\n      case 'Range':\n        // Exact: {1}\n        if (node.from === node.to) {\n          quantifier = '{' + node.from + '}';\n        } // Open: {1,}\n        else if (!node.to) {\n          quantifier = '{' + node.from + ',}';\n        } // Closed: {1,3}\n        else {\n          quantifier = '{' + node.from + ',' + node.to + '}';\n        }\n\n        break;\n\n      default:\n        throw new TypeError('Unknown Quantifier kind: ' + node.kind);\n    }\n\n    return '' + quantifier + greedy;\n  },\n  Char: function Char(node) {\n    var value = node.value;\n\n    switch (node.kind) {\n      case 'simple':\n        {\n          if (node.escaped) {\n            return '\\\\' + value;\n          }\n\n          return value;\n        }\n\n      case 'hex':\n      case 'unicode':\n      case 'oct':\n      case 'decimal':\n      case 'control':\n      case 'meta':\n        return value;\n\n      default:\n        throw new TypeError('Unknown Char kind: ' + node.kind);\n    }\n  },\n  UnicodeProperty: function UnicodeProperty(node) {\n    var escapeChar = node.negative ? 'P' : 'p';\n    var namePart = void 0;\n\n    if (!node.shorthand && !node.binary) {\n      namePart = node.name + '=';\n    } else {\n      namePart = '';\n    }\n\n    return '\\\\' + escapeChar + '{' + namePart + node.value + '}';\n  }\n};\nmodule.exports = {\n  /**\n   * Generates a regexp string from an AST.\n   *\n   * @param Object ast - an AST node\n   */\n  generate: gen\n};\n\n//# sourceURL=webpack:///./node_modules/regexp-tree/dist/generator/index.js?")},"./node_modules/regexp-tree/dist/interpreter/finite-automaton/dfa/dfa-minimizer.js":function(module,exports,__webpack_require__){"use strict";eval('/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n // DFA minization.\n\n/**\n * Map from state to current set it goes.\n */\n\nvar _slicedToArray = function () {\n  function sliceIterator(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n\n    try {\n      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i["return"]) _i["return"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  return function (arr, i) {\n    if (Array.isArray(arr)) {\n      return arr;\n    } else if (Symbol.iterator in Object(arr)) {\n      return sliceIterator(arr, i);\n    } else {\n      throw new TypeError("Invalid attempt to destructure non-iterable instance");\n    }\n  };\n}();\n\nfunction _toArray(arr) {\n  return Array.isArray(arr) ? arr : Array.from(arr);\n}\n\nfunction _toConsumableArray(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n}\n\nvar currentTransitionMap = null;\n/**\n * Takes a DFA, and returns a minimized version of it\n * compressing some states to groups (using standard, 0-, 1-,\n * 2-, ... N-equivalence algorithm).\n */\n\nfunction minimize(dfa) {\n  var table = dfa.getTransitionTable();\n  var allStates = Object.keys(table);\n  var alphabet = dfa.getAlphabet();\n  var accepting = dfa.getAcceptingStateNumbers();\n  currentTransitionMap = {};\n  var nonAccepting = new Set();\n  allStates.forEach(function (state) {\n    state = Number(state);\n    var isAccepting = accepting.has(state);\n\n    if (isAccepting) {\n      currentTransitionMap[state] = accepting;\n    } else {\n      nonAccepting.add(state);\n      currentTransitionMap[state] = nonAccepting;\n    }\n  }); // ---------------------------------------------------------------------------\n  // Step 1: build equivalent sets.\n  // All [1..N] equivalent sets.\n\n  var all = [// 0-equivalent sets.\n  [nonAccepting, accepting].filter(function (set) {\n    return set.size > 0;\n  })];\n  var current = void 0;\n  var previous = void 0; // Top of the stack is the current list of sets to analyze.\n\n  current = all[all.length - 1]; // Previous set (to check whether we need to stop).\n\n  previous = all[all.length - 2]; // Until we\'ll not have the same N and N-1 equivalent rows.\n\n  var _loop = function _loop() {\n    var newTransitionMap = {};\n    var _iteratorNormalCompletion3 = true;\n    var _didIteratorError3 = false;\n    var _iteratorError3 = undefined;\n\n    try {\n      for (var _iterator3 = current[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n        var _set = _step3.value; // Handled states for this set.\n\n        var handledStates = {};\n\n        var _set2 = _toArray(_set),\n            first = _set2[0],\n            rest = _set2.slice(1);\n\n        handledStates[first] = new Set([first]); // Have to compare each from the rest states with\n        // the already handled states, and see if they are equivalent.\n\n        var _iteratorNormalCompletion4 = true;\n        var _didIteratorError4 = false;\n        var _iteratorError4 = undefined;\n\n        try {\n          restSets: for (var _iterator4 = rest[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {\n            var state = _step4.value;\n            var _iteratorNormalCompletion5 = true;\n            var _didIteratorError5 = false;\n            var _iteratorError5 = undefined;\n\n            try {\n              for (var _iterator5 = Object.keys(handledStates)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {\n                var handledState = _step5.value; // This and some previously handled state are equivalent --\n                // just append this state to the same set.\n\n                if (areEquivalent(state, handledState, table, alphabet)) {\n                  handledStates[handledState].add(state);\n                  handledStates[state] = handledStates[handledState];\n                  continue restSets;\n                }\n              } // Else, this state is not equivalent to any of the\n              // handled states -- allocate a new set for it.\n\n            } catch (err) {\n              _didIteratorError5 = true;\n              _iteratorError5 = err;\n            } finally {\n              try {\n                if (!_iteratorNormalCompletion5 && _iterator5.return) {\n                  _iterator5.return();\n                }\n              } finally {\n                if (_didIteratorError5) {\n                  throw _iteratorError5;\n                }\n              }\n            }\n\n            handledStates[state] = new Set([state]);\n          }\n        } catch (err) {\n          _didIteratorError4 = true;\n          _iteratorError4 = err;\n        } finally {\n          try {\n            if (!_iteratorNormalCompletion4 && _iterator4.return) {\n              _iterator4.return();\n            }\n          } finally {\n            if (_didIteratorError4) {\n              throw _iteratorError4;\n            }\n          }\n        } // Add these handled states to all states map.\n\n\n        Object.assign(newTransitionMap, handledStates);\n      } // Update current transition map for the handled row.\n\n    } catch (err) {\n      _didIteratorError3 = true;\n      _iteratorError3 = err;\n    } finally {\n      try {\n        if (!_iteratorNormalCompletion3 && _iterator3.return) {\n          _iterator3.return();\n        }\n      } finally {\n        if (_didIteratorError3) {\n          throw _iteratorError3;\n        }\n      }\n    }\n\n    currentTransitionMap = newTransitionMap;\n    var newSets = new Set(Object.keys(newTransitionMap).map(function (state) {\n      return newTransitionMap[state];\n    }));\n    all.push([].concat(_toConsumableArray(newSets))); // Top of the stack is the current.\n\n    current = all[all.length - 1]; // Previous set.\n\n    previous = all[all.length - 2];\n  };\n\n  while (!sameRow(current, previous)) {\n    _loop();\n  } // ---------------------------------------------------------------------------\n  // Step 2: build minimized table from the equivalent sets.\n  // Remap state numbers from sets to index-based.\n\n\n  var remaped = new Map();\n  var idx = 1;\n  current.forEach(function (set) {\n    return remaped.set(set, idx++);\n  }); // Build the minimized table from the calculated equivalent sets.\n\n  var minimizedTable = {};\n  var minimizedAcceptingStates = new Set();\n\n  var updateAcceptingStates = function updateAcceptingStates(set, idx) {\n    var _iteratorNormalCompletion = true;\n    var _didIteratorError = false;\n    var _iteratorError = undefined;\n\n    try {\n      for (var _iterator = set[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n        var state = _step.value;\n\n        if (accepting.has(state)) {\n          minimizedAcceptingStates.add(idx);\n        }\n      }\n    } catch (err) {\n      _didIteratorError = true;\n      _iteratorError = err;\n    } finally {\n      try {\n        if (!_iteratorNormalCompletion && _iterator.return) {\n          _iterator.return();\n        }\n      } finally {\n        if (_didIteratorError) {\n          throw _iteratorError;\n        }\n      }\n    }\n  };\n\n  var _iteratorNormalCompletion2 = true;\n  var _didIteratorError2 = false;\n  var _iteratorError2 = undefined;\n\n  try {\n    for (var _iterator2 = remaped.entries()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n      var _ref = _step2.value;\n\n      var _ref2 = _slicedToArray(_ref, 2);\n\n      var set = _ref2[0];\n      var _idx = _ref2[1];\n      minimizedTable[_idx] = {};\n      var _iteratorNormalCompletion6 = true;\n      var _didIteratorError6 = false;\n      var _iteratorError6 = undefined;\n\n      try {\n        for (var _iterator6 = alphabet[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {\n          var symbol = _step6.value;\n          updateAcceptingStates(set, _idx); // Determine original transition for this symbol from the set.\n\n          var originalTransition = void 0;\n          var _iteratorNormalCompletion7 = true;\n          var _didIteratorError7 = false;\n          var _iteratorError7 = undefined;\n\n          try {\n            for (var _iterator7 = set[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {\n              var originalState = _step7.value;\n              originalTransition = table[originalState][symbol];\n\n              if (originalTransition) {\n                break;\n              }\n            }\n          } catch (err) {\n            _didIteratorError7 = true;\n            _iteratorError7 = err;\n          } finally {\n            try {\n              if (!_iteratorNormalCompletion7 && _iterator7.return) {\n                _iterator7.return();\n              }\n            } finally {\n              if (_didIteratorError7) {\n                throw _iteratorError7;\n              }\n            }\n          }\n\n          if (originalTransition) {\n            minimizedTable[_idx][symbol] = remaped.get(currentTransitionMap[originalTransition]);\n          }\n        }\n      } catch (err) {\n        _didIteratorError6 = true;\n        _iteratorError6 = err;\n      } finally {\n        try {\n          if (!_iteratorNormalCompletion6 && _iterator6.return) {\n            _iterator6.return();\n          }\n        } finally {\n          if (_didIteratorError6) {\n            throw _iteratorError6;\n          }\n        }\n      }\n    } // Update the table, and accepting states on the original DFA.\n\n  } catch (err) {\n    _didIteratorError2 = true;\n    _iteratorError2 = err;\n  } finally {\n    try {\n      if (!_iteratorNormalCompletion2 && _iterator2.return) {\n        _iterator2.return();\n      }\n    } finally {\n      if (_didIteratorError2) {\n        throw _iteratorError2;\n      }\n    }\n  }\n\n  dfa.setTransitionTable(minimizedTable);\n  dfa.setAcceptingStateNumbers(minimizedAcceptingStates);\n  return dfa;\n}\n\nfunction sameRow(r1, r2) {\n  if (!r2) {\n    return false;\n  }\n\n  if (r1.length !== r2.length) {\n    return false;\n  }\n\n  for (var i = 0; i < r1.length; i++) {\n    var s1 = r1[i];\n    var s2 = r2[i];\n\n    if (s1.size !== s2.size) {\n      return false;\n    }\n\n    if ([].concat(_toConsumableArray(s1)).sort().join(\',\') !== [].concat(_toConsumableArray(s2)).sort().join(\',\')) {\n      return false;\n    }\n  }\n\n  return true;\n}\n/**\n * Checks whether two states are N-equivalent, i.e. whether they go\n * to the same set on a symbol.\n */\n\n\nfunction areEquivalent(s1, s2, table, alphabet) {\n  var _iteratorNormalCompletion8 = true;\n  var _didIteratorError8 = false;\n  var _iteratorError8 = undefined;\n\n  try {\n    for (var _iterator8 = alphabet[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {\n      var symbol = _step8.value;\n\n      if (!goToSameSet(s1, s2, table, symbol)) {\n        return false;\n      }\n    }\n  } catch (err) {\n    _didIteratorError8 = true;\n    _iteratorError8 = err;\n  } finally {\n    try {\n      if (!_iteratorNormalCompletion8 && _iterator8.return) {\n        _iterator8.return();\n      }\n    } finally {\n      if (_didIteratorError8) {\n        throw _iteratorError8;\n      }\n    }\n  }\n\n  return true;\n}\n/**\n * Checks whether states go to the same set.\n */\n\n\nfunction goToSameSet(s1, s2, table, symbol) {\n  if (!currentTransitionMap[s1] || !currentTransitionMap[s2]) {\n    return false;\n  }\n\n  var originalTransitionS1 = table[s1][symbol];\n  var originalTransitionS2 = table[s2][symbol]; // If no actual transition on this symbol, treat it as positive.\n\n  if (!originalTransitionS1 && !originalTransitionS2) {\n    return true;\n  } // Otherwise, check if they are in the same sets.\n\n\n  return currentTransitionMap[s1].has(originalTransitionS1) && currentTransitionMap[s2].has(originalTransitionS2);\n}\n\nmodule.exports = {\n  minimize: minimize\n};\n\n//# sourceURL=webpack:///./node_modules/regexp-tree/dist/interpreter/finite-automaton/dfa/dfa-minimizer.js?')},"./node_modules/regexp-tree/dist/interpreter/finite-automaton/dfa/dfa.js":function(module,exports,__webpack_require__){"use strict";eval("/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n\n\nvar _createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nfunction _toConsumableArray(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nvar DFAMinimizer = __webpack_require__(\"./node_modules/regexp-tree/dist/interpreter/finite-automaton/dfa/dfa-minimizer.js\");\n\nvar _require = __webpack_require__(\"./node_modules/regexp-tree/dist/interpreter/finite-automaton/special-symbols.js\"),\n    EPSILON_CLOSURE = _require.EPSILON_CLOSURE;\n/**\n * DFA is build by converting from NFA (subset construction).\n */\n\n\nvar DFA = function () {\n  function DFA(nfa) {\n    _classCallCheck(this, DFA);\n\n    this._nfa = nfa;\n  }\n  /**\n   * Minimizes DFA.\n   */\n\n\n  _createClass(DFA, [{\n    key: 'minimize',\n    value: function minimize() {\n      this.getTransitionTable();\n      this._originalAcceptingStateNumbers = this._acceptingStateNumbers;\n      this._originalTransitionTable = this._transitionTable;\n      DFAMinimizer.minimize(this);\n    }\n    /**\n     * Returns alphabet for this DFA.\n     */\n\n  }, {\n    key: 'getAlphabet',\n    value: function getAlphabet() {\n      return this._nfa.getAlphabet();\n    }\n    /**\n     * Returns accepting states.\n     */\n\n  }, {\n    key: 'getAcceptingStateNumbers',\n    value: function getAcceptingStateNumbers() {\n      if (!this._acceptingStateNumbers) {\n        // Accepting states are determined during table construction.\n        this.getTransitionTable();\n      }\n\n      return this._acceptingStateNumbers;\n    }\n    /**\n     * Returns original accepting states.\n     */\n\n  }, {\n    key: 'getOriginaAcceptingStateNumbers',\n    value: function getOriginaAcceptingStateNumbers() {\n      if (!this._originalAcceptingStateNumbers) {\n        // Accepting states are determined during table construction.\n        this.getTransitionTable();\n      }\n\n      return this._originalAcceptingStateNumbers;\n    }\n    /**\n     * Sets transition table.\n     */\n\n  }, {\n    key: 'setTransitionTable',\n    value: function setTransitionTable(table) {\n      this._transitionTable = table;\n    }\n    /**\n     * Sets accepting states.\n     */\n\n  }, {\n    key: 'setAcceptingStateNumbers',\n    value: function setAcceptingStateNumbers(stateNumbers) {\n      this._acceptingStateNumbers = stateNumbers;\n    }\n    /**\n     * DFA transition table is built from NFA table.\n     */\n\n  }, {\n    key: 'getTransitionTable',\n    value: function getTransitionTable() {\n      var _this = this;\n\n      if (this._transitionTable) {\n        return this._transitionTable;\n      } // Calculate from NFA transition table.\n\n\n      var nfaTable = this._nfa.getTransitionTable();\n\n      var nfaStates = Object.keys(nfaTable);\n      this._acceptingStateNumbers = new Set(); // Start state of DFA is E(S[nfa])\n\n      var startState = nfaTable[nfaStates[0]][EPSILON_CLOSURE]; // Init the worklist (states which should be in the DFA).\n\n      var worklist = [startState];\n      var alphabet = this.getAlphabet();\n\n      var nfaAcceptingStates = this._nfa.getAcceptingStateNumbers();\n\n      var dfaTable = {}; // Determine whether the combined DFA state is accepting.\n\n      var updateAcceptingStates = function updateAcceptingStates(states) {\n        var _iteratorNormalCompletion = true;\n        var _didIteratorError = false;\n        var _iteratorError = undefined;\n\n        try {\n          for (var _iterator = nfaAcceptingStates[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n            var nfaAcceptingState = _step.value; // If any of the states from NFA is accepting, DFA's\n            // state is accepting as well.\n\n            if (states.indexOf(nfaAcceptingState) !== -1) {\n              _this._acceptingStateNumbers.add(states.join(','));\n\n              break;\n            }\n          }\n        } catch (err) {\n          _didIteratorError = true;\n          _iteratorError = err;\n        } finally {\n          try {\n            if (!_iteratorNormalCompletion && _iterator.return) {\n              _iterator.return();\n            }\n          } finally {\n            if (_didIteratorError) {\n              throw _iteratorError;\n            }\n          }\n        }\n      };\n\n      while (worklist.length > 0) {\n        var states = worklist.shift();\n        var dfaStateLabel = states.join(',');\n        dfaTable[dfaStateLabel] = {};\n        var _iteratorNormalCompletion2 = true;\n        var _didIteratorError2 = false;\n        var _iteratorError2 = undefined;\n\n        try {\n          for (var _iterator2 = alphabet[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n            var symbol = _step2.value;\n            var onSymbol = []; // Determine whether the combined state is accepting.\n\n            updateAcceptingStates(states);\n            var _iteratorNormalCompletion3 = true;\n            var _didIteratorError3 = false;\n            var _iteratorError3 = undefined;\n\n            try {\n              for (var _iterator3 = states[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n                var state = _step3.value;\n                var nfaStatesOnSymbol = nfaTable[state][symbol];\n\n                if (!nfaStatesOnSymbol) {\n                  continue;\n                }\n\n                var _iteratorNormalCompletion4 = true;\n                var _didIteratorError4 = false;\n                var _iteratorError4 = undefined;\n\n                try {\n                  for (var _iterator4 = nfaStatesOnSymbol[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {\n                    var nfaStateOnSymbol = _step4.value;\n\n                    if (!nfaTable[nfaStateOnSymbol]) {\n                      continue;\n                    }\n\n                    onSymbol.push.apply(onSymbol, _toConsumableArray(nfaTable[nfaStateOnSymbol][EPSILON_CLOSURE]));\n                  }\n                } catch (err) {\n                  _didIteratorError4 = true;\n                  _iteratorError4 = err;\n                } finally {\n                  try {\n                    if (!_iteratorNormalCompletion4 && _iterator4.return) {\n                      _iterator4.return();\n                    }\n                  } finally {\n                    if (_didIteratorError4) {\n                      throw _iteratorError4;\n                    }\n                  }\n                }\n              }\n            } catch (err) {\n              _didIteratorError3 = true;\n              _iteratorError3 = err;\n            } finally {\n              try {\n                if (!_iteratorNormalCompletion3 && _iterator3.return) {\n                  _iterator3.return();\n                }\n              } finally {\n                if (_didIteratorError3) {\n                  throw _iteratorError3;\n                }\n              }\n            }\n\n            var dfaStatesOnSymbolSet = new Set(onSymbol);\n            var dfaStatesOnSymbol = [].concat(_toConsumableArray(dfaStatesOnSymbolSet));\n\n            if (dfaStatesOnSymbol.length > 0) {\n              var dfaOnSymbolStr = dfaStatesOnSymbol.join(',');\n              dfaTable[dfaStateLabel][symbol] = dfaOnSymbolStr;\n\n              if (!dfaTable.hasOwnProperty(dfaOnSymbolStr)) {\n                worklist.unshift(dfaStatesOnSymbol);\n              }\n            }\n          }\n        } catch (err) {\n          _didIteratorError2 = true;\n          _iteratorError2 = err;\n        } finally {\n          try {\n            if (!_iteratorNormalCompletion2 && _iterator2.return) {\n              _iterator2.return();\n            }\n          } finally {\n            if (_didIteratorError2) {\n              throw _iteratorError2;\n            }\n          }\n        }\n      }\n\n      return this._transitionTable = this._remapStateNumbers(dfaTable);\n    }\n    /**\n     * Remaps state numbers in the resulting table:\n     * combined states '1,2,3' -> 1, '3,4' -> 2, etc.\n     */\n\n  }, {\n    key: '_remapStateNumbers',\n    value: function _remapStateNumbers(calculatedDFATable) {\n      var newStatesMap = {};\n      this._originalTransitionTable = calculatedDFATable;\n      var transitionTable = {};\n      Object.keys(calculatedDFATable).forEach(function (originalNumber, newNumber) {\n        newStatesMap[originalNumber] = newNumber + 1;\n      });\n\n      for (var originalNumber in calculatedDFATable) {\n        var originalRow = calculatedDFATable[originalNumber];\n        var row = {};\n\n        for (var symbol in originalRow) {\n          row[symbol] = newStatesMap[originalRow[symbol]];\n        }\n\n        transitionTable[newStatesMap[originalNumber]] = row;\n      } // Remap accepting states.\n\n\n      this._originalAcceptingStateNumbers = this._acceptingStateNumbers;\n      this._acceptingStateNumbers = new Set();\n      var _iteratorNormalCompletion5 = true;\n      var _didIteratorError5 = false;\n      var _iteratorError5 = undefined;\n\n      try {\n        for (var _iterator5 = this._originalAcceptingStateNumbers[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {\n          var _originalNumber = _step5.value;\n\n          this._acceptingStateNumbers.add(newStatesMap[_originalNumber]);\n        }\n      } catch (err) {\n        _didIteratorError5 = true;\n        _iteratorError5 = err;\n      } finally {\n        try {\n          if (!_iteratorNormalCompletion5 && _iterator5.return) {\n            _iterator5.return();\n          }\n        } finally {\n          if (_didIteratorError5) {\n            throw _iteratorError5;\n          }\n        }\n      }\n\n      return transitionTable;\n    }\n    /**\n     * Returns original DFA table, where state numbers\n     * are combined numbers from NFA.\n     */\n\n  }, {\n    key: 'getOriginalTransitionTable',\n    value: function getOriginalTransitionTable() {\n      if (!this._originalTransitionTable) {\n        // Original table is determined during table construction.\n        this.getTransitionTable();\n      }\n\n      return this._originalTransitionTable;\n    }\n    /**\n     * Checks whether this DFA accepts a string.\n     */\n\n  }, {\n    key: 'matches',\n    value: function matches(string) {\n      var state = 1;\n      var i = 0;\n      var table = this.getTransitionTable();\n\n      while (string[i]) {\n        state = table[state][string[i++]];\n\n        if (!state) {\n          return false;\n        }\n      }\n\n      if (!this.getAcceptingStateNumbers().has(state)) {\n        return false;\n      }\n\n      return true;\n    }\n  }]);\n\n  return DFA;\n}();\n\nmodule.exports = DFA;\n\n//# sourceURL=webpack:///./node_modules/regexp-tree/dist/interpreter/finite-automaton/dfa/dfa.js?")},"./node_modules/regexp-tree/dist/interpreter/finite-automaton/index.js":function(module,exports,__webpack_require__){"use strict";eval('/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n\n\nvar NFA = __webpack_require__("./node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/nfa.js");\n\nvar DFA = __webpack_require__("./node_modules/regexp-tree/dist/interpreter/finite-automaton/dfa/dfa.js");\n\nvar nfaFromRegExp = __webpack_require__("./node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/nfa-from-regexp.js");\n\nvar builders = __webpack_require__("./node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/builders.js");\n\nmodule.exports = {\n  /**\n   * Export NFA and DFA classes.\n   */\n  NFA: NFA,\n  DFA: DFA,\n\n  /**\n   * Expose builders.\n   */\n  builders: builders,\n\n  /**\n   * Builds an NFA for the passed regexp.\n   *\n   * @param string | AST | RegExp:\n   *\n   *   a regular expression in different representations: a string,\n   *   a RegExp object, or an AST.\n   */\n  toNFA: function toNFA(regexp) {\n    return nfaFromRegExp.build(regexp);\n  },\n\n  /**\n   * Builds DFA for the passed regexp.\n   *\n   * @param string | AST | RegExp:\n   *\n   *   a regular expression in different representations: a string,\n   *   a RegExp object, or an AST.\n   */\n  toDFA: function toDFA(regexp) {\n    return new DFA(this.toNFA(regexp));\n  },\n\n  /**\n   * Returns true if regexp accepts the string.\n   */\n  test: function test(regexp, string) {\n    return this.toDFA(regexp).matches(string);\n  }\n};\n\n//# sourceURL=webpack:///./node_modules/regexp-tree/dist/interpreter/finite-automaton/index.js?')},"./node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/builders.js":function(module,exports,__webpack_require__){"use strict";eval('/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n\n\nvar NFA = __webpack_require__("./node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/nfa.js");\n\nvar NFAState = __webpack_require__("./node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/nfa-state.js");\n\nvar _require = __webpack_require__("./node_modules/regexp-tree/dist/interpreter/finite-automaton/special-symbols.js"),\n    EPSILON = _require.EPSILON; // -----------------------------------------------------------------------------\n// Char NFA fragment: `c`\n\n/**\n * Char factory.\n *\n * Creates an NFA fragment for a single char.\n *\n * [in] --c--\x3e [out]\n */\n\n\nfunction char(c) {\n  var inState = new NFAState();\n  var outState = new NFAState({\n    accepting: true\n  });\n  return new NFA(inState.addTransition(c, outState), outState);\n} // -----------------------------------------------------------------------------\n// Epsilon NFA fragment\n\n/**\n * Epsilon factory.\n *\n * Creates an NFA fragment for ε (recognizes an empty string).\n *\n * [in] --ε--\x3e [out]\n */\n\n\nfunction e() {\n  return char(EPSILON);\n} // -----------------------------------------------------------------------------\n// Alteration NFA fragment: `abc`\n\n/**\n * Creates a connection between two NFA fragments on epsilon transition.\n *\n * [in-a] --a--\x3e [out-a] --ε--\x3e [in-b] --b--\x3e [out-b]\n */\n\n\nfunction altPair(first, second) {\n  first.out.accepting = false;\n  second.out.accepting = true;\n  first.out.addTransition(EPSILON, second.in);\n  return new NFA(first.in, second.out);\n}\n/**\n * Alteration factory.\n *\n * Creates a alteration NFA for (at least) two NFA-fragments.\n */\n\n\nfunction alt(first) {\n  for (var _len = arguments.length, fragments = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    fragments[_key - 1] = arguments[_key];\n  }\n\n  var _iteratorNormalCompletion = true;\n  var _didIteratorError = false;\n  var _iteratorError = undefined;\n\n  try {\n    for (var _iterator = fragments[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n      var fragment = _step.value;\n      first = altPair(first, fragment);\n    }\n  } catch (err) {\n    _didIteratorError = true;\n    _iteratorError = err;\n  } finally {\n    try {\n      if (!_iteratorNormalCompletion && _iterator.return) {\n        _iterator.return();\n      }\n    } finally {\n      if (_didIteratorError) {\n        throw _iteratorError;\n      }\n    }\n  }\n\n  return first;\n} // -----------------------------------------------------------------------------\n// Disjunction NFA fragment: `a|b`\n\n/**\n * Creates a disjunction choice between two fragments.\n */\n\n\nfunction orPair(first, second) {\n  var inState = new NFAState();\n  var outState = new NFAState();\n  inState.addTransition(EPSILON, first.in);\n  inState.addTransition(EPSILON, second.in);\n  outState.accepting = true;\n  first.out.accepting = false;\n  second.out.accepting = false;\n  first.out.addTransition(EPSILON, outState);\n  second.out.addTransition(EPSILON, outState);\n  return new NFA(inState, outState);\n}\n/**\n * Disjunction factory.\n *\n * Creates a disjunction NFA for (at least) two NFA-fragments.\n */\n\n\nfunction or(first) {\n  for (var _len2 = arguments.length, fragments = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n    fragments[_key2 - 1] = arguments[_key2];\n  }\n\n  var _iteratorNormalCompletion2 = true;\n  var _didIteratorError2 = false;\n  var _iteratorError2 = undefined;\n\n  try {\n    for (var _iterator2 = fragments[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n      var fragment = _step2.value;\n      first = orPair(first, fragment);\n    }\n  } catch (err) {\n    _didIteratorError2 = true;\n    _iteratorError2 = err;\n  } finally {\n    try {\n      if (!_iteratorNormalCompletion2 && _iterator2.return) {\n        _iterator2.return();\n      }\n    } finally {\n      if (_didIteratorError2) {\n        throw _iteratorError2;\n      }\n    }\n  }\n\n  return first;\n} // -----------------------------------------------------------------------------\n// Kleene-closure\n\n/**\n * Kleene star/closure.\n *\n * a*\n */\n\n\nfunction repExplicit(fragment) {\n  var inState = new NFAState();\n  var outState = new NFAState({\n    accepting: true\n  }); // 0 or more.\n\n  inState.addTransition(EPSILON, fragment.in);\n  inState.addTransition(EPSILON, outState);\n  fragment.out.accepting = false;\n  fragment.out.addTransition(EPSILON, outState);\n  outState.addTransition(EPSILON, fragment.in);\n  return new NFA(inState, outState);\n}\n/**\n * Optimized Kleene-star: just adds ε-transitions from\n * input to the output, and back.\n */\n\n\nfunction rep(fragment) {\n  fragment.in.addTransition(EPSILON, fragment.out);\n  fragment.out.addTransition(EPSILON, fragment.in);\n  return fragment;\n}\n/**\n * Optimized Plus: just adds ε-transitions from\n * the output to the input.\n */\n\n\nfunction plusRep(fragment) {\n  fragment.out.addTransition(EPSILON, fragment.in);\n  return fragment;\n}\n/**\n * Optimized ? repetition: just adds ε-transitions from\n * the input to the output.\n */\n\n\nfunction questionRep(fragment) {\n  fragment.in.addTransition(EPSILON, fragment.out);\n  return fragment;\n}\n\nmodule.exports = {\n  alt: alt,\n  char: char,\n  e: e,\n  or: or,\n  rep: rep,\n  repExplicit: repExplicit,\n  plusRep: plusRep,\n  questionRep: questionRep\n};\n\n//# sourceURL=webpack:///./node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/builders.js?')},"./node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/nfa-from-regexp.js":function(module,exports,__webpack_require__){"use strict";eval("/**\n * The MIT License (MIT)\n * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>\n */\n\n\nfunction _toConsumableArray(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n}\n\nvar parser = __webpack_require__(\"./node_modules/regexp-tree/dist/parser/index.js\");\n\nvar _require = __webpack_require__(\"./node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/builders.js\"),\n    alt = _require.alt,\n    char = _require.char,\n    or = _require.or,\n    rep = _require.rep,\n    plusRep = _require.plusRep,\n    questionRep = _require.questionRep;\n/**\n * Helper `gen` function calls node type handler.\n */\n\n\nfunction gen(node) {\n  if (node && !generator[node.type]) {\n    throw new Error(node.type + ' is not supported in NFA/DFA interpreter.');\n  }\n\n  return node ? generator[node.type](node) : '';\n}\n/**\n * AST handler.\n */\n\n\nvar generator = {\n  RegExp: function RegExp(node) {\n    if (node.flags !== '') {\n      throw new Error('NFA/DFA: Flags are not supported yet.');\n    }\n\n    return gen(node.body);\n  },\n  Alternative: function Alternative(node) {\n    var fragments = (node.expressions || []).map(gen);\n    return alt.apply(undefined, _toConsumableArray(fragments));\n  },\n  Disjunction: function Disjunction(node) {\n    return or(gen(node.left), gen(node.right));\n  },\n  Repetition: function Repetition(node) {\n    switch (node.quantifier.kind) {\n      case '*':\n        return rep(gen(node.expression));\n\n      case '+':\n        return plusRep(gen(node.expression));\n\n      case '?':\n        return questionRep(gen(node.expression));\n\n      default:\n        throw new Error('Unknown repeatition: ' + node.quantifier.kind + '.');\n    }\n  },\n  Char: function Char(node) {\n    if (node.kind !== 'simple') {\n      throw new Error('NFA/DFA: Only simple chars are supported yet.');\n    }\n\n    return char(node.value);\n  },\n  Group: function Group(node) {\n    return gen(node.expression);\n  }\n};\nmodule.exports = {\n  /**\n