chevrotain/lib_esm/chevrotain.mjs

Chevrotain is a high performance fault tolerant javascript parsing DSL for building recursive decent parsers

var __commonJS = (callback, module2) => () => {
  if (!module2) {
    module2 = {exports: {}};
    callback(module2.exports, module2);
  }
  return module2.exports;
};

// lib/src/version.js
var require_version = __commonJS((exports2) => {
  "use strict";
  Object.defineProperty(exports2, "__esModule", {value: true});
  exports2.VERSION = void 0;
  exports2.VERSION = "9.0.1";
});

// ../utils/lib/src/api.js
var require_api = __commonJS((exports, module) => {
  "use strict";
  var __spreadArray = exports && exports.__spreadArray || function(to, from) {
    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
      to[j] = from[i];
    return to;
  };
  Object.defineProperty(exports, "__esModule", {value: true});
  exports.toFastProperties = exports.timer = exports.peek = exports.isES2015MapSupported = exports.PRINT_WARNING = exports.PRINT_ERROR = exports.packArray = exports.IDENTITY = exports.NOOP = exports.merge = exports.groupBy = exports.defaults = exports.assignNoOverwrite = exports.assign = exports.zipObject = exports.sortBy = exports.indexOf = exports.some = exports.difference = exports.every = exports.isObject = exports.isRegExp = exports.isArray = exports.partial = exports.uniq = exports.compact = exports.reduce = exports.findAll = exports.find = exports.cloneObj = exports.cloneArr = exports.contains = exports.has = exports.pick = exports.reject = exports.filter = exports.dropRight = exports.drop = exports.isFunction = exports.isUndefined = exports.isString = exports.forEach = exports.last = exports.first = exports.flatten = exports.map = exports.mapValues = exports.values = exports.keys = exports.isEmpty = void 0;
  function isEmpty(arr) {
    return arr && arr.length === 0;
  }
  exports.isEmpty = isEmpty;
  function keys(obj) {
    if (obj === void 0 || obj === null) {
      return [];
    }
    return Object.keys(obj);
  }
  exports.keys = keys;
  function values(obj) {
    var vals = [];
    var keys2 = Object.keys(obj);
    for (var i = 0; i < keys2.length; i++) {
      vals.push(obj[keys2[i]]);
    }
    return vals;
  }
  exports.values = values;
  function mapValues(obj, callback) {
    var result = [];
    var objKeys = keys(obj);
    for (var idx = 0; idx < objKeys.length; idx++) {
      var currKey = objKeys[idx];
      result.push(callback.call(null, obj[currKey], currKey));
    }
    return result;
  }
  exports.mapValues = mapValues;
  function map(arr, callback) {
    var result = [];
    for (var idx = 0; idx < arr.length; idx++) {
      result.push(callback.call(null, arr[idx], idx));
    }
    return result;
  }
  exports.map = map;
  function flatten(arr) {
    var result = [];
    for (var idx = 0; idx < arr.length; idx++) {
      var currItem = arr[idx];
      if (Array.isArray(currItem)) {
        result = result.concat(flatten(currItem));
      } else {
        result.push(currItem);
      }
    }
    return result;
  }
  exports.flatten = flatten;
  function first(arr) {
    return isEmpty(arr) ? void 0 : arr[0];
  }
  exports.first = first;
  function last(arr) {
    var len = arr && arr.length;
    return len ? arr[len - 1] : void 0;
  }
  exports.last = last;
  function forEach(collection, iteratorCallback) {
    if (Array.isArray(collection)) {
      for (var i = 0; i < collection.length; i++) {
        iteratorCallback.call(null, collection[i], i);
      }
    } else if (isObject(collection)) {
      var colKeys = keys(collection);
      for (var i = 0; i < colKeys.length; i++) {
        var key = colKeys[i];
        var value = collection[key];
        iteratorCallback.call(null, value, key);
      }
    } else {
      throw Error("non exhaustive match");
    }
  }
  exports.forEach = forEach;
  function isString(item) {
    return typeof item === "string";
  }
  exports.isString = isString;
  function isUndefined(item) {
    return item === void 0;
  }
  exports.isUndefined = isUndefined;
  function isFunction(item) {
    return item instanceof Function;
  }
  exports.isFunction = isFunction;
  function drop(arr, howMuch) {
    if (howMuch === void 0) {
      howMuch = 1;
    }
    return arr.slice(howMuch, arr.length);
  }
  exports.drop = drop;
  function dropRight(arr, howMuch) {
    if (howMuch === void 0) {
      howMuch = 1;
    }
    return arr.slice(0, arr.length - howMuch);
  }
  exports.dropRight = dropRight;
  function filter(arr, predicate) {
    var result = [];
    if (Array.isArray(arr)) {
      for (var i = 0; i < arr.length; i++) {
        var item = arr[i];
        if (predicate.call(null, item)) {
          result.push(item);
        }
      }
    }
    return result;
  }
  exports.filter = filter;
  function reject(arr, predicate) {
    return filter(arr, function(item) {
      return !predicate(item);
    });
  }
  exports.reject = reject;
  function pick(obj, predicate) {
    var keys2 = Object.keys(obj);
    var result = {};
    for (var i = 0; i < keys2.length; i++) {
      var currKey = keys2[i];
      var currItem = obj[currKey];
      if (predicate(currItem)) {
        result[currKey] = currItem;
      }
    }
    return result;
  }
  exports.pick = pick;
  function has(obj, prop) {
    if (isObject(obj)) {
      return obj.hasOwnProperty(prop);
    }
    return false;
  }
  exports.has = has;
  function contains(arr, item) {
    return find(arr, function(currItem) {
      return currItem === item;
    }) !== void 0 ? true : false;
  }
  exports.contains = contains;
  function cloneArr(arr) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
      newArr.push(arr[i]);
    }
    return newArr;
  }
  exports.cloneArr = cloneArr;
  function cloneObj(obj) {
    var clonedObj = {};
    for (var key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        clonedObj[key] = obj[key];
      }
    }
    return clonedObj;
  }
  exports.cloneObj = cloneObj;
  function find(arr, predicate) {
    for (var i = 0; i < arr.length; i++) {
      var item = arr[i];
      if (predicate.call(null, item)) {
        return item;
      }
    }
    return void 0;
  }
  exports.find = find;
  function findAll(arr, predicate) {
    var found = [];
    for (var i = 0; i < arr.length; i++) {
      var item = arr[i];
      if (predicate.call(null, item)) {
        found.push(item);
      }
    }
    return found;
  }
  exports.findAll = findAll;
  function reduce(arrOrObj, iterator, initial) {
    var isArr = Array.isArray(arrOrObj);
    var vals = isArr ? arrOrObj : values(arrOrObj);
    var objKeys = isArr ? [] : keys(arrOrObj);
    var accumulator = initial;
    for (var i = 0; i < vals.length; i++) {
      accumulator = iterator.call(null, accumulator, vals[i], isArr ? i : objKeys[i]);
    }
    return accumulator;
  }
  exports.reduce = reduce;
  function compact(arr) {
    return reject(arr, function(item) {
      return item === null || item === void 0;
    });
  }
  exports.compact = compact;
  function uniq(arr, identity) {
    if (identity === void 0) {
      identity = function(item) {
        return item;
      };
    }
    var identities = [];
    return reduce(arr, function(result, currItem) {
      var currIdentity = identity(currItem);
      if (contains(identities, currIdentity)) {
        return result;
      } else {
        identities.push(currIdentity);
        return result.concat(currItem);
      }
    }, []);
  }
  exports.uniq = uniq;
  function partial(func) {
    var restArgs = [];
    for (var _i = 1; _i < arguments.length; _i++) {
      restArgs[_i - 1] = arguments[_i];
    }
    var firstArg = [null];
    var allArgs = firstArg.concat(restArgs);
    return Function.bind.apply(func, allArgs);
  }
  exports.partial = partial;
  function isArray(obj) {
    return Array.isArray(obj);
  }
  exports.isArray = isArray;
  function isRegExp(obj) {
    return obj instanceof RegExp;
  }
  exports.isRegExp = isRegExp;
  function isObject(obj) {
    return obj instanceof Object;
  }
  exports.isObject = isObject;
  function every(arr, predicate) {
    for (var i = 0; i < arr.length; i++) {
      if (!predicate(arr[i], i)) {
        return false;
      }
    }
    return true;
  }
  exports.every = every;
  function difference(arr, values2) {
    return reject(arr, function(item) {
      return contains(values2, item);
    });
  }
  exports.difference = difference;
  function some(arr, predicate) {
    for (var i = 0; i < arr.length; i++) {
      if (predicate(arr[i])) {
        return true;
      }
    }
    return false;
  }
  exports.some = some;
  function indexOf(arr, value) {
    for (var i = 0; i < arr.length; i++) {
      if (arr[i] === value) {
        return i;
      }
    }
    return -1;
  }
  exports.indexOf = indexOf;
  function sortBy(arr, orderFunc) {
    var result = cloneArr(arr);
    result.sort(function(a, b) {
      return orderFunc(a) - orderFunc(b);
    });
    return result;
  }
  exports.sortBy = sortBy;
  function zipObject(keys2, values2) {
    if (keys2.length !== values2.length) {
      throw Error("can't zipObject with different number of keys and values!");
    }
    var result = {};
    for (var i = 0; i < keys2.length; i++) {
      result[keys2[i]] = values2[i];
    }
    return result;
  }
  exports.zipObject = zipObject;
  function assign(target) {
    var sources = [];
    for (var _i = 1; _i < arguments.length; _i++) {
      sources[_i - 1] = arguments[_i];
    }
    for (var i = 0; i < sources.length; i++) {
      var curSource = sources[i];
      var currSourceKeys = keys(curSource);
      for (var j = 0; j < currSourceKeys.length; j++) {
        var currKey = currSourceKeys[j];
        target[currKey] = curSource[currKey];
      }
    }
    return target;
  }
  exports.assign = assign;
  function assignNoOverwrite(target) {
    var sources = [];
    for (var _i = 1; _i < arguments.length; _i++) {
      sources[_i - 1] = arguments[_i];
    }
    for (var i = 0; i < sources.length; i++) {
      var curSource = sources[i];
      var currSourceKeys = keys(curSource);
      for (var j = 0; j < currSourceKeys.length; j++) {
        var currKey = currSourceKeys[j];
        if (!has(target, currKey)) {
          target[currKey] = curSource[currKey];
        }
      }
    }
    return target;
  }
  exports.assignNoOverwrite = assignNoOverwrite;
  function defaults() {
    var sources = [];
    for (var _i = 0; _i < arguments.length; _i++) {
      sources[_i] = arguments[_i];
    }
    return assignNoOverwrite.apply(void 0, __spreadArray([{}], sources));
  }
  exports.defaults = defaults;
  function groupBy(arr, groupKeyFunc) {
    var result = {};
    forEach(arr, function(item) {
      var currGroupKey = groupKeyFunc(item);
      var currGroupArr = result[currGroupKey];
      if (currGroupArr) {
        currGroupArr.push(item);
      } else {
        result[currGroupKey] = [item];
      }
    });
    return result;
  }
  exports.groupBy = groupBy;
  function merge(obj1, obj2) {
    var result = cloneObj(obj1);
    var keys2 = keys(obj2);
    for (var i = 0; i < keys2.length; i++) {
      var key = keys2[i];
      var value = obj2[key];
      result[key] = value;
    }
    return result;
  }
  exports.merge = merge;
  function NOOP() {
  }
  exports.NOOP = NOOP;
  function IDENTITY(item) {
    return item;
  }
  exports.IDENTITY = IDENTITY;
  function packArray(holeyArr) {
    var result = [];
    for (var i = 0; i < holeyArr.length; i++) {
      var orgValue = holeyArr[i];
      result.push(orgValue !== void 0 ? orgValue : void 0);
    }
    return result;
  }
  exports.packArray = packArray;
  function PRINT_ERROR(msg) {
    if (console && console.error) {
      console.error("Error: " + msg);
    }
  }
  exports.PRINT_ERROR = PRINT_ERROR;
  function PRINT_WARNING(msg) {
    if (console && console.warn) {
      console.warn("Warning: " + msg);
    }
  }
  exports.PRINT_WARNING = PRINT_WARNING;
  function isES2015MapSupported() {
    return typeof Map === "function";
  }
  exports.isES2015MapSupported = isES2015MapSupported;
  function peek(arr) {
    return arr[arr.length - 1];
  }
  exports.peek = peek;
  function timer(func) {
    var start = new Date().getTime();
    var val = func();
    var end = new Date().getTime();
    var total = end - start;
    return {time: total, value: val};
  }
  exports.timer = timer;
  function toFastProperties(toBecomeFast) {
    function FakeConstructor() {
    }
    FakeConstructor.prototype = toBecomeFast;
    var fakeInstance = new FakeConstructor();
    function fakeAccess() {
      return typeof fakeInstance.bar;
    }
    fakeAccess();
    fakeAccess();
    return toBecomeFast;
    eval(toBecomeFast);
  }
  exports.toFastProperties = toFastProperties;
});

// ../../node_modules/regexp-to-ast/lib/regexp-to-ast.js
var require_regexp_to_ast = __commonJS((exports2, module2) => {
  (function(root, factory) {
    if (typeof define === "function" && define.amd) {
      define([], factory);
    } else if (typeof module2 === "object" && module2.exports) {
      module2.exports = factory();
    } else {
      root.regexpToAst = factory();
    }
  })(typeof self !== "undefined" ? self : exports2, function() {
    function RegExpParser() {
    }
    RegExpParser.prototype.saveState = function() {
      return {
        idx: this.idx,
        input: this.input,
        groupIdx: this.groupIdx
      };
    };
    RegExpParser.prototype.restoreState = function(newState) {
      this.idx = newState.idx;
      this.input = newState.input;
      this.groupIdx = newState.groupIdx;
    };
    RegExpParser.prototype.pattern = function(input) {
      this.idx = 0;
      this.input = input;
      this.groupIdx = 0;
      this.consumeChar("/");
      var value = this.disjunction();
      this.consumeChar("/");
      var flags = {
        type: "Flags",
        loc: {begin: this.idx, end: input.length},
        global: false,
        ignoreCase: false,
        multiLine: false,
        unicode: false,
        sticky: false
      };
      while (this.isRegExpFlag()) {
        switch (this.popChar()) {
          case "g":
            addFlag(flags, "global");
            break;
          case "i":
            addFlag(flags, "ignoreCase");
            break;
          case "m":
            addFlag(flags, "multiLine");
            break;
          case "u":
            addFlag(flags, "unicode");
            break;
          case "y":
            addFlag(flags, "sticky");
            break;
        }
      }
      if (this.idx !== this.input.length) {
        throw Error("Redundant input: " + this.input.substring(this.idx));
      }
      return {
        type: "Pattern",
        flags,
        value,
        loc: this.loc(0)
      };
    };
    RegExpParser.prototype.disjunction = function() {
      var alts = [];
      var begin = this.idx;
      alts.push(this.alternative());
      while (this.peekChar() === "|") {
        this.consumeChar("|");
        alts.push(this.alternative());
      }
      return {type: "Disjunction", value: alts, loc: this.loc(begin)};
    };
    RegExpParser.prototype.alternative = function() {
      var terms = [];
      var begin = this.idx;
      while (this.isTerm()) {
        terms.push(this.term());
      }
      return {type: "Alternative", value: terms, loc: this.loc(begin)};
    };
    RegExpParser.prototype.term = function() {
      if (this.isAssertion()) {
        return this.assertion();
      } else {
        return this.atom();
      }
    };
    RegExpParser.prototype.assertion = function() {
      var begin = this.idx;
      switch (this.popChar()) {
        case "^":
          return {
            type: "StartAnchor",
            loc: this.loc(begin)
          };
        case "$":
          return {type: "EndAnchor", loc: this.loc(begin)};
        case "\\":
          switch (this.popChar()) {
            case "b":
              return {
                type: "WordBoundary",
                loc: this.loc(begin)
              };
            case "B":
              return {
                type: "NonWordBoundary",
                loc: this.loc(begin)
              };
          }
          throw Error("Invalid Assertion Escape");
        case "(":
          this.consumeChar("?");
          var type;
          switch (this.popChar()) {
            case "=":
              type = "Lookahead";
              break;
            case "!":
              type = "NegativeLookahead";
              break;
          }
          ASSERT_EXISTS(type);
          var disjunction = this.disjunction();
          this.consumeChar(")");
          return {
            type,
            value: disjunction,
            loc: this.loc(begin)
          };
      }
      ASSERT_NEVER_REACH_HERE();
    };
    RegExpParser.prototype.quantifier = function(isBacktracking) {
      var range;
      var begin = this.idx;
      switch (this.popChar()) {
        case "*":
          range = {
            atLeast: 0,
            atMost: Infinity
          };
          break;
        case "+":
          range = {
            atLeast: 1,
            atMost: Infinity
          };
          break;
        case "?":
          range = {
            atLeast: 0,
            atMost: 1
          };
          break;
        case "{":
          var atLeast = this.integerIncludingZero();
          switch (this.popChar()) {
            case "}":
              range = {
                atLeast,
                atMost: atLeast
              };
              break;
            case ",":
              var atMost;
              if (this.isDigit()) {
                atMost = this.integerIncludingZero();
                range = {
                  atLeast,
                  atMost
                };
              } else {
                range = {
                  atLeast,
                  atMost: Infinity
                };
              }
              this.consumeChar("}");
              break;
          }
          if (isBacktracking === true && range === void 0) {
            return void 0;
          }
          ASSERT_EXISTS(range);
          break;
      }
      if (isBacktracking === true && range === void 0) {
        return void 0;
      }
      ASSERT_EXISTS(range);
      if (this.peekChar(0) === "?") {
        this.consumeChar("?");
        range.greedy = false;
      } else {
        range.greedy = true;
      }
      range.type = "Quantifier";
      range.loc = this.loc(begin);
      return range;
    };
    RegExpParser.prototype.atom = function() {
      var atom;
      var begin = this.idx;
      switch (this.peekChar()) {
        case ".":
          atom = this.dotAll();
          break;
        case "\\":
          atom = this.atomEscape();
          break;
        case "[":
          atom = this.characterClass();
          break;
        case "(":
          atom = this.group();
          break;
      }
      if (atom === void 0 && this.isPatternCharacter()) {
        atom = this.patternCharacter();
      }
      ASSERT_EXISTS(atom);
      atom.loc = this.loc(begin);
      if (this.isQuantifier()) {
        atom.quantifier = this.quantifier();
      }
      return atom;
    };
    RegExpParser.prototype.dotAll = function() {
      this.consumeChar(".");
      return {
        type: "Set",
        complement: true,
        value: [cc("\n"), cc("\r"), cc("\u2028"), cc("\u2029")]
      };
    };
    RegExpParser.prototype.atomEscape = function() {
      this.consumeChar("\\");
      switch (this.peekChar()) {
        case "1":
        case "2":
        case "3":
        case "4":
        case "5":
        case "6":
        case "7":
        case "8":
        case "9":
          return this.decimalEscapeAtom();
        case "d":
        case "D":
        case "s":
        case "S":
        case "w":
        case "W":
          return this.characterClassEscape();
        case "f":
        case "n":
        case "r":
        case "t":
        case "v":
          return this.controlEscapeAtom();
        case "c":
          return this.controlLetterEscapeAtom();
        case "0":
          return this.nulCharacterAtom();
        case "x":
          return this.hexEscapeSequenceAtom();
        case "u":
          return this.regExpUnicodeEscapeSequenceAtom();
        default:
          return this.identityEscapeAtom();
      }
    };
    RegExpParser.prototype.decimalEscapeAtom = function() {
      var value = this.positiveInteger();
      return {type: "GroupBackReference", value};
    };
    RegExpParser.prototype.characterClassEscape = function() {
      var set;
      var complement = false;
      switch (this.popChar()) {
        case "d":
          set = digitsCharCodes;
          break;
        case "D":
          set = digitsCharCodes;
          complement = true;
          break;
        case "s":
          set = whitespaceCodes;
          break;
        case "S":
          set = whitespaceCodes;
          complement = true;
          break;
        case "w":
          set = wordCharCodes;
          break;
        case "W":
          set = wordCharCodes;
          complement = true;
          break;
      }
      ASSERT_EXISTS(set);
      return {type: "Set", value: set, complement};
    };
    RegExpParser.prototype.controlEscapeAtom = function() {
      var escapeCode;
      switch (this.popChar()) {
        case "f":
          escapeCode = cc("\f");
          break;
        case "n":
          escapeCode = cc("\n");
          break;
        case "r":
          escapeCode = cc("\r");
          break;
        case "t":
          escapeCode = cc("	");
          break;
        case "v":
          escapeCode = cc("\v");
          break;
      }
      ASSERT_EXISTS(escapeCode);
      return {type: "Character", value: escapeCode};
    };
    RegExpParser.prototype.controlLetterEscapeAtom = function() {
      this.consumeChar("c");
      var letter = this.popChar();
      if (/[a-zA-Z]/.test(letter) === false) {
        throw Error("Invalid ");
      }
      var letterCode = letter.toUpperCase().charCodeAt(0) - 64;
      return {type: "Character", value: letterCode};
    };
    RegExpParser.prototype.nulCharacterAtom = function() {
      this.consumeChar("0");
      return {type: "Character", value: cc("\0")};
    };
    RegExpParser.prototype.hexEscapeSequenceAtom = function() {
      this.consumeChar("x");
      return this.parseHexDigits(2);
    };
    RegExpParser.prototype.regExpUnicodeEscapeSequenceAtom = function() {
      this.consumeChar("u");
      return this.parseHexDigits(4);
    };
    RegExpParser.prototype.identityEscapeAtom = function() {
      var escapedChar = this.popChar();
      return {type: "Character", value: cc(escapedChar)};
    };
    RegExpParser.prototype.classPatternCharacterAtom = function() {
      switch (this.peekChar()) {
        case "\n":
        case "\r":
        case "\u2028":
        case "\u2029":
        case "\\":
        case "]":
          throw Error("TBD");
        default:
          var nextChar = this.popChar();
          return {type: "Character", value: cc(nextChar)};
      }
    };
    RegExpParser.prototype.characterClass = function() {
      var set = [];
      var complement = false;
      this.consumeChar("[");
      if (this.peekChar(0) === "^") {
        this.consumeChar("^");
        complement = true;
      }
      while (this.isClassAtom()) {
        var from = this.classAtom();
        var isFromSingleChar = from.type === "Character";
        if (isFromSingleChar && this.isRangeDash()) {
          this.consumeChar("-");
          var to = this.classAtom();
          var isToSingleChar = to.type === "Character";
          if (isToSingleChar) {
            if (to.value < from.value) {
              throw Error("Range out of order in character class");
            }
            set.push({from: from.value, to: to.value});
          } else {
            insertToSet(from.value, set);
            set.push(cc("-"));
            insertToSet(to.value, set);
          }
        } else {
          insertToSet(from.value, set);
        }
      }
      this.consumeChar("]");
      return {type: "Set", complement, value: set};
    };
    RegExpParser.prototype.classAtom = function() {
      switch (this.peekChar()) {
        case "]":
        case "\n":
        case "\r":
        case "\u2028":
        case "\u2029":
          throw Error("TBD");
        case "\\":
          return this.classEscape();
        default:
          return this.classPatternCharacterAtom();
      }
    };
    RegExpParser.prototype.classEscape = function() {
      this.consumeChar("\\");
      switch (this.peekChar()) {
        case "b":
          this.consumeChar("b");
          return {type: "Character", value: cc("\b")};
        case "d":
        case "D":
        case "s":
        case "S":
        case "w":
        case "W":
          return this.characterClassEscape();
        case "f":
        case "n":
        case "r":
        case "t":
        case "v":
          return this.controlEscapeAtom();
        case "c":
          return this.controlLetterEscapeAtom();
        case "0":
          return this.nulCharacterAtom();
        case "x":
          return this.hexEscapeSequenceAtom();
        case "u":
          return this.regExpUnicodeEscapeSequenceAtom();
        default:
          return this.identityEscapeAtom();
      }
    };
    RegExpParser.prototype.group = function() {
      var capturing = true;
      this.consumeChar("(");
      switch (this.peekChar(0)) {
        case "?":
          this.consumeChar("?");
          this.consumeChar(":");
          capturing = false;
          break;
        default:
          this.groupIdx++;
          break;
      }
      var value = this.disjunction();
      this.consumeChar(")");
      var groupAst = {
        type: "Group",
        capturing,
        value
      };
      if (capturing) {
        groupAst.idx = this.groupIdx;
      }
      return groupAst;
    };
    RegExpParser.prototype.positiveInteger = function() {
      var number = this.popChar();
      if (decimalPatternNoZero.test(number) === false) {
        throw Error("Expecting a positive integer");
      }
      while (decimalPattern.test(this.peekChar(0))) {
        number += this.popChar();
      }
      return parseInt(number, 10);
    };
    RegExpParser.prototype.integerIncludingZero = function() {
      var number = this.popChar();
      if (decimalPattern.test(number) === false) {
        throw Error("Expecting an integer");
      }
      while (decimalPattern.test(this.peekChar(0))) {
        number += this.popChar();
      }
      return parseInt(number, 10);
    };
    RegExpParser.prototype.patternCharacter = function() {
      var nextChar = this.popChar();
      switch (nextChar) {
        case "\n":
        case "\r":
        case "\u2028":
        case "\u2029":
        case "^":
        case "$":
        case "\\":
        case ".":
        case "*":
        case "+":
        case "?":
        case "(":
        case ")":
        case "[":
        case "|":
          throw Error("TBD");
        default:
          return {type: "Character", value: cc(nextChar)};
      }
    };
    RegExpParser.prototype.isRegExpFlag = function() {
      switch (this.peekChar(0)) {
        case "g":
        case "i":
        case "m":
        case "u":
        case "y":
          return true;
        default:
          return false;
      }
    };
    RegExpParser.prototype.isRangeDash = function() {
      return this.peekChar() === "-" && this.isClassAtom(1);
    };
    RegExpParser.prototype.isDigit = function() {
      return decimalPattern.test(this.peekChar(0));
    };
    RegExpParser.prototype.isClassAtom = function(howMuch) {
      if (howMuch === void 0) {
        howMuch = 0;
      }
      switch (this.peekChar(howMuch)) {
        case "]":
        case "\n":
        case "\r":
        case "\u2028":
        case "\u2029":
          return false;
        default:
          return true;
      }
    };
    RegExpParser.prototype.isTerm = function() {
      return this.isAtom() || this.isAssertion();
    };
    RegExpParser.prototype.isAtom = function() {
      if (this.isPatternCharacter()) {
        return true;
      }
      switch (this.peekChar(0)) {
        case ".":
        case "\\":
        case "[":
        case "(":
          return true;
        default:
          return false;
      }
    };
    RegExpParser.prototype.isAssertion = function() {
      switch (this.peekChar(0)) {
        case "^":
        case "$":
          return true;
        case "\\":
          switch (this.peekChar(1)) {
            case "b":
            case "B":
              return true;
            default:
              return false;
          }
        case "(":
          return this.peekChar(1) === "?" && (this.peekChar(2) === "=" || this.peekChar(2) === "!");
        default:
          return false;
      }
    };
    RegExpParser.prototype.isQuantifier = function() {
      var prevState = this.saveState();
      try {
        return this.quantifier(true) !== void 0;
      } catch (e) {
        return false;
      } finally {
        this.restoreState(prevState);
      }
    };
    RegExpParser.prototype.isPatternCharacter = function() {
      switch (this.peekChar()) {
        case "^":
        case "$":
        case "\\":
        case ".":
        case "*":
        case "+":
        case "?":
        case "(":
        case ")":
        case "[":
        case "|":
        case "/":
        case "\n":
        case "\r":
        case "\u2028":
        case "\u2029":
          return false;
        default:
          return true;
      }
    };
    RegExpParser.prototype.parseHexDigits = function(howMany) {
      var hexString = "";
      for (var i2 = 0; i2 < howMany; i2++) {
        var hexChar = this.popChar();
        if (hexDigitPattern.test(hexChar) === false) {
          throw Error("Expecting a HexDecimal digits");
        }
        hexString += hexChar;
      }
      var charCode = parseInt(hexString, 16);
      return {type: "Character", value: charCode};
    };
    RegExpParser.prototype.peekChar = function(howMuch) {
      if (howMuch === void 0) {
        howMuch = 0;
      }
      return this.input[this.idx + howMuch];
    };
    RegExpParser.prototype.popChar = function() {
      var nextChar = this.peekChar(0);
      this.consumeChar();
      return nextChar;
    };
    RegExpParser.prototype.consumeChar = function(char) {
      if (char !== void 0 && this.input[this.idx] !== char) {
        throw Error("Expected: '" + char + "' but found: '" + this.input[this.idx] + "' at offset: " + this.idx);
      }
      if (this.idx >= this.input.length) {
        throw Error("Unexpected end of input");
      }
      this.idx++;
    };
    RegExpParser.prototype.loc = function(begin) {
      return {begin, end: this.idx};
    };
    var hexDigitPattern = /[0-9a-fA-F]/;
    var decimalPattern = /[0-9]/;
    var decimalPatternNoZero = /[1-9]/;
    function cc(char) {
      return char.charCodeAt(0);
    }
    function insertToSet(item, set) {
      if (item.length !== void 0) {
        item.forEach(function(subItem) {
          set.push(subItem);
        });
      } else {
        set.push(item);
      }
    }
    function addFlag(flagObj, flagKey) {
      if (flagObj[flagKey] === true) {
        throw "duplicate flag " + flagKey;
      }
      flagObj[flagKey] = true;
    }
    function ASSERT_EXISTS(obj) {
      if (obj === void 0) {
        throw Error("Internal Error - Should never get here!");
      }
    }
    function ASSERT_NEVER_REACH_HERE() {
      throw Error("Internal Error - Should never get here!");
    }
    var i;
    var digitsCharCodes = [];
    for (i = cc("0"); i <= cc("9"); i++) {
      digitsCharCodes.push(i);
    }
    var wordCharCodes = [cc("_")].concat(digitsCharCodes);
    for (i = cc("a"); i <= cc("z"); i++) {
      wordCharCodes.push(i);
    }
    for (i = cc("A"); i <= cc("Z"); i++) {
      wordCharCodes.push(i);
    }
    var whitespaceCodes = [
      cc(" "),
      cc("\f"),
      cc("\n"),
      cc("\r"),
      cc("	"),
      cc("\v"),
      cc("	"),
      cc("\xA0"),
      cc("\u1680"),
      cc("\u2000"),
      cc("\u2001"),
      cc("\u2002"),
      cc("\u2003"),
      cc("\u2004"),
      cc("\u2005"),
      cc("\u2006"),
      cc("\u2007"),
      cc("\u2008"),
      cc("\u2009"),
      cc("\u200A"),
      cc("\u2028"),
      cc("\u2029"),
      cc("\u202F"),
      cc("\u205F"),
      cc("\u3000"),
      cc("\uFEFF")
    ];
    function BaseRegExpVisitor() {
    }
    BaseRegExpVisitor.prototype.visitChildren = function(node) {
      for (var key in node) {
        var child = node[key];
        if (node.hasOwnProperty(key)) {
          if (child.type !== void 0) {
            this.visit(child);
          } else if (Array.isArray(child)) {
            child.forEach(function(subChild) {
              this.visit(subChild);
            }, this);
          }
        }
      }
    };
    BaseRegExpVisitor.prototype.visit = function(node) {
      switch (node.type) {
        case "Pattern":
          this.visitPattern(node);
          break;
        case "Flags":
          this.visitFlags(node);
          break;
        case "Disjunction":
          this.visitDisjunction(node);
          break;
        case "Alternative":
          this.visitAlternative(node);
          break;
        case "StartAnchor":
          this.visitStartAnchor(node);
          break;
        case "EndAnchor":
          this.visitEndAnchor(node);
          break;
        case "WordBoundary":
          this.visitWordBoundary(node);
          break;
        case "NonWordBoundary":
          this.visitNonWordBoundary(node);
          break;
        case "Lookahead":
          this.visitLookahead(node);
          break;
        case "NegativeLookahead":
          this.visitNegativeLookahead(node);
          break;
        case "Character":
          this.visitCharacter(node);
          break;
        case "Set":
          this.visitSet(node);
          break;
        case "Group":
          this.visitGroup(node);
          break;
        case "GroupBackReference":
          this.visitGroupBackReference(node);
          break;
        case "Quantifier":
          this.visitQuantifier(node);
          break;
      }
      this.visitChildren(node);
    };
    BaseRegExpVisitor.prototype.visitPattern = function(node) {
    };
    BaseRegExpVisitor.prototype.visitFlags = function(node) {
    };
    BaseRegExpVisitor.prototype.visitDisjunction = function(node) {
    };
    BaseRegExpVisitor.prototype.visitAlternative = function(node) {
    };
    BaseRegExpVisitor.prototype.visitStartAnchor = function(node) {
    };
    BaseRegExpVisitor.prototype.visitEndAnchor = function(node) {
    };
    BaseRegExpVisitor.prototype.visitWordBoundary = function(node) {
    };
    BaseRegExpVisitor.prototype.visitNonWordBoundary = function(node) {
    };
    BaseRegExpVisitor.prototype.visitLookahead = function(node) {
    };
    BaseRegExpVisitor.prototype.visitNegativeLookahead = function(node) {
    };
    BaseRegExpVisitor.prototype.visitCharacter = function(node) {
    };
    BaseRegExpVisitor.prototype.visitSet = function(node) {
    };
    BaseRegExpVisitor.prototype.visitGroup = function(node) {
    };
    BaseRegExpVisitor.prototype.visitGroupBackReference = function(node) {
    };
    BaseRegExpVisitor.prototype.visitQuantifier = function(node) {
    };
    return {
      RegExpParser,
      BaseRegExpVisitor,
      VERSION: "0.5.0"
    };
  });
});

// lib/src/scan/reg_exp_parser.js
var require_reg_exp_parser = __commonJS((exports2) => {
  "use strict";
  Object.defineProperty(exports2, "__esModule", {value: true});
  exports2.clearRegExpParserCache = exports2.getRegExpAst = void 0;
  var regexp_to_ast_1 = require_regexp_to_ast();
  var regExpAstCache = {};
  var regExpParser = new regexp_to_ast_1.RegExpParser();
  function getRegExpAst(regExp) {
    var regExpStr = regExp.toString();
    if (regExpAstCache.hasOwnProperty(regExpStr)) {
      return regExpAstCache[regExpStr];
    } else {
      var regExpAst = regExpParser.pattern(regExpStr);
      regExpAstCache[regExpStr] = regExpAst;
      return regExpAst;
    }
  }
  exports2.getRegExpAst = getRegExpAst;
  function clearRegExpParserCache() {
    regExpAstCache = {};
  }
  exports2.clearRegExpParserCache = clearRegExpParserCache;
});

// lib/src/scan/reg_exp.js
var require_reg_exp = __commonJS((exports2) => {
  "use strict";
  var __extends = exports2 && exports2.__extends || function() {
    var extendStatics = function(d, b) {
      extendStatics = Object.setPrototypeOf || {__proto__: []} instanceof Array && function(d2, b2) {
        d2.__proto__ = b2;
      } || function(d2, b2) {
        for (var p in b2)
          if (Object.prototype.hasOwnProperty.call(b2, p))
            d2[p] = b2[p];
      };
      return extendStatics(d, b);
    };
    return function(d, b) {
      if (typeof b !== "function" && b !== null)
        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
      extendStatics(d, b);
      function __() {
        this.constructor = d;
      }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
  }();
  Object.defineProperty(exports2, "__esModule", {value: true});
  exports2.canMatchCharCode = exports2.firstCharOptimizedIndices = exports2.getOptimizedStartCodesIndices = exports2.failedOptimizationPrefixMsg = void 0;
  var regexp_to_ast_1 = require_regexp_to_ast();
  var utils_1 = require_api();
  var reg_exp_parser_1 = require_reg_exp_parser();
  var lexer_1 = require_lexer();
  var complementErrorMessage = "Complement Sets are not supported for first char optimization";
  exports2.failedOptimizationPrefixMsg = 'Unable to use "first char" lexer optimizations:\n';
  function getOptimizedStartCodesIndices(regExp, ensureOptimizations) {
    if (ensureOptimizations === void 0) {
      ensureOptimizations = false;
    }
    try {
      var ast = reg_exp_parser_1.getRegExpAst(regExp);
      var firstChars = firstCharOptimizedIndices(ast.value, {}, ast.flags.ignoreCase);
      return firstChars;
    } catch (e) {
      if (e.message === complementErrorMessage) {
        if (ensureOptimizations) {
          utils_1.PRINT_WARNING("" + exports2.failedOptimizationPrefixMsg + ("	Unable to optimize: < " + regExp.toString() + " >\n") + "	Complement Sets cannot be automatically optimized.\n	This will disable the lexer's first char optimizations.\n	See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.");
        }
      } else {
        var msgSuffix = "";
        if (ensureOptimizations) {
          msgSuffix = "\n	This will disable the lexer's first char optimizations.\n	See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#REGEXP_PARSING for details.";
        }
        utils_1.PRINT_ERROR(exports2.failedOptimizationPrefixMsg + "\n" + ("	Failed parsing: < " + regExp.toString() + " >\n") + ("	Using the regexp-to-ast library version: " + regexp_to_ast_1.VERSION + "\n") + "	Please open an issue at: https://github.com/bd82/regexp-to-ast/issues" + msgSuffix);
      }
    }
    return [];
  }
  exports2.getOptimizedStartCodesIndices = getOptimizedStartCodesIndices;
  function firstCharOptimizedIndices(ast, result, ignoreCase) {
    switch (ast.type) {
      case "Disjunction":
        for (var i = 0; i < ast.value.length; i++) {
          firstCharOptimizedIndices(ast.value[i], result, ignoreCase);
        }
        break;
      case "Alternative":
        var terms = ast.value;
        for (var i = 0; i < terms.length; i++) {
          var term = terms[i];
          switch (term.type) {
            case "EndAnchor":
            case "GroupBackReference":
            case "Lookahead":
            case "NegativeLookahead":
            case "StartAnchor":
            case "WordBoundary":
            case "NonWordBoundary":
              continue;
          }
          var atom = term;
          switch (atom.type) {
            case "Character":
              addOptimizedIdxToResult(atom.value, result, ignoreCase);
              break;
            case "Set":
              if (atom.complement === true) {
                throw Error(complementErrorMessage);
              }
              utils_1.forEach(atom.value, function(code) {
                if (typeof code === "number") {
                  addOptimizedIdxToResult(code, result, ignoreCase);
                } else {
                  var range = code;
                  if (ignoreCase === true) {
                    for (var rangeCode = range.from; rangeCode <= range.to; rangeCode++) {
                      addOptimizedIdxToResult(rangeCode, result, ignoreCase);
                    }
                  } else {
                    for (var rangeCode = range.from; rangeCode <= range.to && rangeCode < lexer_1.minOptimizationVal; rangeCode++) {
                      addOptimizedIdxToResult(rangeCode, result, ignoreCase);
                    }
                    if (range.to >= lexer_1.minOptimizationVal) {
                      var minUnOptVal = range.from >= lexer_1.minOptimizationVal ? range.from : lexer_1.minOptimizationVal;
                      var maxUnOptVal = range.to;
                      var minOptIdx = lexer_1.charCodeToOptimizedIndex(minUnOptVal);
                      var maxOptIdx = lexer_1.charCodeToOptimizedIndex(maxUnOptVal);
                      for (var currOptIdx = minOptIdx; currOptIdx <= maxOptIdx; currOptIdx++) {
                        result[currOptIdx] = currOptIdx;
                      }
                    }
                  }
                }
              });
              break;
            case "Group":
              firstCharOptimizedIndices(atom.value, result, ignoreCase);
              break;
            default:
              throw Error("Non Exhaustive Match");
          }
          var isOptionalQuantifier = atom.quantifier !== void 0 && atom.quantifier.atLeast === 0;
          if (atom.type === "Group" && isWholeOptional(atom) === false || atom.type !== "Group" && isOptionalQuantifier === false) {
            break;
          }
        }
        break;
      default:
        throw Error("non exhaustive match!");
    }
    return utils_1.values(result);
  }
  exports2.firstCharOptimizedIndices = firstCharOptimizedIndices;
  function addOptimizedIdxToResult(code, result, ignoreCase) {
    var optimizedCharIdx = lexer_1.charCodeToOptimizedIndex(code);
    result[optimizedCharIdx] = optimizedCharIdx;
    if (ignoreCase === true) {
      handleIgnoreCase(code, result);
    }
  }
  function handleIgnoreCase(code, result) {
    var char = String.fromCharCode(code);
    var upperChar = char.toUpperCase();
    if (upperChar !== char) {
      var optimizedCharIdx = lexer_1.charCodeToOptimizedIndex(upperChar.charCodeAt(0));
      result[optimizedCharIdx] = optimizedCharIdx;
    } else {
      var lowerChar = char.toLowerCase();
      if (lowerChar !== char) {
        var optimizedCharIdx = lexer_1.charCodeToOptimizedIndex(lowerChar.charCodeAt(0));
        result[optimizedCharIdx] = optimizedCharIdx;
      }
    }
  }
  function findCode(setNode, targetCharCodes) {
    return utils_1.find(setNode.value, function(codeOrRange) {
      if (typeof codeOrRange === "number") {
        return utils_1.contains(targetCharCodes, codeOrRange);
      } else {
        var range_1 = codeOrRange;
        return utils_1.find(targetCharCodes, function(targetCode) {
          return range_1.from <= targetCode && targetCode <= range_1.to;
        }) !== void 0;
      }
    });
  }
  function isWholeOptional(ast) {
    if (ast.quantifier && ast.quantifier.atLeast === 0) {
      return true;
    }
    if (!ast.value) {
      return false;
    }
    return utils_1.isArray(ast.value) ? utils_1.every(ast.value, isWholeOptional) : isWholeOptional(ast.value);
  }
  var CharCodeFinder = function(_super) {
    __extends(CharCodeFinder2, _super);
    function CharCodeFinder2(targetCharCodes) {
      var _this = _super.call(this) || this;
      _this.targetCharCodes = targetCharCodes;
      _this.found = false;
      return _this;
    }
    CharCodeFinder2.prototype.visitChildren = function(node) {
      if (this.found === true) {
        return;
      }
      switch (node.type) {
        case "Lookahead":
          this.visitLookahead(node);
          return;
        case "NegativeLookahead":
          this.visitNegativeLookahead(node);
          return;
      }
      _super.prototype.visitChildren.call(this, node);
    };
    CharCodeFinder2.prototype.visitCharacter = function(node) {
      if (utils_1.contains(this.targetCharCodes, node.value)) {
        this.found = true;
      }
    };
    CharCodeFinder2.prototype.visitSet = function(node) {
      if (node.complement) {
        if (findCode(node, this.targetCharCodes) === void 0) {
          this.found = true;
        }
      } else {
        if (findCode(node, this.targetCharCodes) !== void 0) {
          this.found = true;
        }
      }
    };
    return CharCodeFinder2;
  }(regexp_to_ast_1.BaseRegExpVisitor);
  function canMatchCharCode(charCodes, pattern) {
    if (pattern instanceof RegExp) {
      var ast = reg_exp_parser_1.getRegExpAst(pattern);
      var charCodeFinder = new CharCodeFinder(charCodes);
      charCodeFinder.visit(ast);
      return charCodeFinder.found;
    } else {
      return utils_1.find(pattern, function(char) {
        return utils_1.contains(charCodes, char.charCodeAt(0));
      }) !== void 0;
    }
  }
  exports2.canMatchCharCode = canMatchCharCode;
});

// lib/src/scan/lexer.js
var require_lexer = __commonJS((exports2) => {
  "use strict";
  var __extends = exports2 && exports2.__extends || function() {
    var extendStatics = function(d, b) {
      extendStatics = Object.setPrototypeOf || {__proto__: []} instanceof Array && function(d2, b2) {
        d2.__proto__ = b2;
      } || function(d2, b2) {
        for (var p in b2)
          if (Object.prototype.hasOwnProperty.call(b2, p))
            d2[p] = b2[p];
      };
      return extendStatics(d, b);
    };
    return function(d, b) {
      if (typeof b !== "function" && b !== null)
        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
      extendStatics(d, b);
      function __() {
        this.constructor = d;
      }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
  }();
  Object.defineProperty(exports2, "__esModule", {value: true});
  exports2.charCodeToOptimizedIndex = exports2.minOptimizationVal = exports2.buildLineBreakIssueMessage = exports2.LineTerminatorOptimizedTester = exports2.isShortPattern = exports2.isCustomPattern = exports2.cloneEmptyGroups = exports2.performWarningRuntimeChecks = exports2.performRuntimeChecks = exports2.addStickyFlag = exports2.addStartOfInput = exports2.findUnreachablePatterns = exports2.findModesThatDoNotExist = exports2.findInvalidGroupType = exports2.findDuplicatePatterns = exports2.findUnsupportedFlags = exports2.findStartOfInputAnchor = exports2.findEmptyMatchRegExps = exports2.findEndOfInputAnchor = exports2.findInvalidPatterns = exports2.findMissingPatterns = exports2.validatePatterns = exports2.analyzeTokenTypes = exports2.enableSticky = exports2.disableSticky = exports2.SUPPORT_STICKY = exports2.MODES = exports2.DEFAULT_MODE = void 0;
  var regexp_to_ast_1 = require_regexp_to_ast();
  var lexer_public_1 = require_lexer_public();
  var utils_1 = require_api();
  var reg_exp_1 = require_reg_exp();
  var reg_exp_parser_1 = require_reg_exp_parser();
  var PATTERN = "PATTERN";
  exports2.DEFAULT_MODE = "defaultMode";
  exports2.MODES = "modes";
  exports2.SUPPORT_STICKY = typeof new RegExp("(?:)").sticky === "boolean";
  function disableSticky() {
    exports2.SUPPORT_STICKY = false;
  }
  exports2.disableSticky = disableSticky;
  function enableSticky() {
    exports2.SUPPORT_STICKY = true;
  }
  exports2.enableSticky = enableSticky;
  function analyzeTokenTypes(tokenTypes, options) {
    options = utils_1.defaults(options, {
      useSticky: exports2.SUPPORT_STICKY,
      debug: false,
      safeMode: false,
      positionTracking: "full",
      lineTerminatorCharacters: ["\r", "\n"],
      tracer: function(msg, action) {
        return action();
      }
    });
    var tracer = options.tracer;
    tracer("initCharCodeToOptimizedIndexMap", function() {
      initCharCodeToOptimizedIndexMap();
    });
    var onlyRelevantTypes;
    tracer("Reject Lexer.NA", function() {
      onlyRelevantTypes = utils_1.reject(tokenTypes, function(currType) {
        return currType[PATTERN] === lexer_public_1.Lexer.NA;
      });
    });
    var hasCustom = false;
    var allTransformedPatterns;
    tracer("Transform Patterns", function() {
      hasCustom = false;
      allTransformedPatterns = utils_1.map(onlyRelevantTypes, function(currType) {
        var currPattern = currType[PATTERN];
        if (utils_1.isRegExp(currPattern)) {
          var regExpSource = currPattern.source;
          if (regExpSource.length === 1 && regExpSource !== "^" && regExpSource !== "$" && regExpSource !== "." && !currPattern.ignoreCase) {
            return regExpSource;
          } else if (regExpSource.length === 2 && regExpSource[0] === "\\" && !utils_1.contains([
            "d",
            "D",
            "s",
            "S",
            "t",
            "r",
            "n",
            "t",
            "0",
            "c",
            "b",
            "B",
            "f",
            "v",
            "w",
            "W"
          ], regExpSource[1])) {
            return regExpSource[1];
          } else {
            return options.useSticky ? addStickyFlag(currPattern) : addStartOfInput(currPattern);
          }
        } else if (utils_1.isFunction(currPattern)) {
          hasCustom = true;
          return {exec: currPattern};
        } else if (utils_1.