three-stdlib 2.26.1 → 2.26.2

package/index.js

@@ -9,7 +9,7 @@ import { Loader, FileLoader, BufferGeometry, Vector3, Float32BufferAttribute, An
 import potpack from "potpack";
 import { strToU8, zipSync, unzlibSync, gunzipSync, unzipSync, strFromU8 } from "fflate";
 import { CharsetEncoder, Parser } from "mmd-parser";
-import require$$0$3 from "lodash/isEmpty";
+import require$$0$2 from "lodash/isEmpty";
 import require$$2 from "lodash/map";
 import require$$1 from "lodash/forEach";
 import require$$3$2 from "lodash/values";
@@ -26,7 +26,6 @@ import require$$2$3 from "lodash/includes";
 import require$$3$1 from "lodash/flatten";
 import require$$4$1 from "lodash/uniq";
 import require$$2$4 from "lodash/isUndefined";
-import require$$0$2 from "regexp-to-ast";
 import require$$1$2 from "lodash/first";
 import require$$1$3 from "lodash/compact";
 import require$$1$1 from "lodash/isArray";
@@ -52989,11 +52988,850 @@ follow.buildInProdFollowPrefix = buildInProdFollowPrefix;
 var tokens_public = {};
 var lexer_public = {};
 var lexer = {};
+var regexpToAst = { exports: {} };
+(function(module) {
+  (function(root, factory) {
+    if (module.exports) {
+      module.exports = factory();
+    } else {
+      root.regexpToAst = factory();
+    }
+  })(
+    typeof self !== "undefined" ? (
+      // istanbul ignore next
+      self
+    ) : commonjsGlobal,
+    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 i3 = 0; i3 < howMany; i3++) {
+          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 i2;
+      var digitsCharCodes = [];
+      for (i2 = cc("0"); i2 <= cc("9"); i2++) {
+        digitsCharCodes.push(i2);
+      }
+      var wordCharCodes = [cc("_")].concat(digitsCharCodes);
+      for (i2 = cc("a"); i2 <= cc("z"); i2++) {
+        wordCharCodes.push(i2);
+      }
+      for (i2 = cc("A"); i2 <= cc("Z"); i2++) {
+        wordCharCodes.push(i2);
+      }
+      var whitespaceCodes = [
+        cc(" "),
+        cc("\f"),
+        cc("\n"),
+        cc("\r"),
+        cc("	"),
+        cc("\v"),
+        cc("	"),
+        cc(" "),
+        cc(" "),
+        cc(" "),
+        cc(" "),
+        cc(" "),
+        cc(" "),
+        cc(" "),
+        cc(" "),
+        cc(" "),
+        cc(" "),
+        cc(" "),
+        cc(" "),
+        cc(" "),
+        cc("\u2028"),
+        cc("\u2029"),
+        cc(" "),
+        cc(" "),
+        cc("　"),
+        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"
+      };
+    }
+  );
+})(regexpToAst);
+var regexpToAstExports = regexpToAst.exports;
 var reg_exp = {};
 var reg_exp_parser = {};
 Object.defineProperty(reg_exp_parser, "__esModule", { value: true });
 reg_exp_parser.clearRegExpParserCache = reg_exp_parser.getRegExpAst = void 0;
-var regexp_to_ast_1 = require$$0$2;
+var regexp_to_ast_1 = regexpToAstExports;
 var regExpAstCache = {};
 var regExpParser = new regexp_to_ast_1.RegExpParser();
 function getRegExpAst(regExp) {
@@ -53043,7 +53881,7 @@ function requireReg_exp() {
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.canMatchCharCode = exports.firstCharOptimizedIndices = exports.getOptimizedStartCodesIndices = exports.failedOptimizationPrefixMsg = void 0;
-    var regexp_to_ast_12 = require$$0$2;
+    var regexp_to_ast_12 = regexpToAstExports;
     var isArray_12 = __importDefault2(require$$1$1);
     var every_12 = __importDefault2(require$$2$2);
     var forEach_12 = __importDefault2(require$$1);
@@ -53292,10 +54130,10 @@ function requireLexer() {
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.charCodeToOptimizedIndex = exports.minOptimizationVal = exports.buildLineBreakIssueMessage = exports.LineTerminatorOptimizedTester = exports.isShortPattern = exports.isCustomPattern = exports.cloneEmptyGroups = exports.performWarningRuntimeChecks = exports.performRuntimeChecks = exports.addStickyFlag = exports.addStartOfInput = exports.findUnreachablePatterns = exports.findModesThatDoNotExist = exports.findInvalidGroupType = exports.findDuplicatePatterns = exports.findUnsupportedFlags = exports.findStartOfInputAnchor = exports.findEmptyMatchRegExps = exports.findEndOfInputAnchor = exports.findInvalidPatterns = exports.findMissingPatterns = exports.validatePatterns = exports.analyzeTokenTypes = exports.enableSticky = exports.disableSticky = exports.SUPPORT_STICKY = exports.MODES = exports.DEFAULT_MODE = void 0;
-    var regexp_to_ast_12 = require$$0$2;
+    var regexp_to_ast_12 = regexpToAstExports;
     var lexer_public_1 = requireLexer_public();
     var first_12 = __importDefault2(require$$1$2);
-    var isEmpty_12 = __importDefault2(require$$0$3);
+    var isEmpty_12 = __importDefault2(require$$0$2);
     var compact_1 = __importDefault2(require$$1$3);
     var isArray_12 = __importDefault2(require$$1$1);
     var values_12 = __importDefault2(require$$3$2);
@@ -54059,7 +54897,7 @@ var tokens = {};
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.isTokenType = exports.hasExtendingTokensTypesMapProperty = exports.hasExtendingTokensTypesProperty = exports.hasCategoriesProperty = exports.hasShortKeyProperty = exports.singleAssignCategoriesToksMap = exports.assignCategoriesMapProp = exports.assignCategoriesTokensProp = exports.assignTokenDefaultProps = exports.expandCategories = exports.augmentTokenTypes = exports.tokenIdxToClass = exports.tokenShortNameIdx = exports.tokenStructuredMatcherNoCategories = exports.tokenStructuredMatcher = void 0;
-  var isEmpty_12 = __importDefault2(require$$0$3);
+  var isEmpty_12 = __importDefault2(require$$0$2);
   var compact_1 = __importDefault2(require$$1$3);
   var isArray_12 = __importDefault2(require$$1$1);
   var flatten_12 = __importDefault2(require$$3$1);
@@ -54206,7 +55044,7 @@ function requireLexer_public() {
     exports.Lexer = exports.LexerDefinitionErrorType = void 0;
     var lexer_1 = requireLexer();
     var noop_1 = __importDefault2(require$$1$5);
-    var isEmpty_12 = __importDefault2(require$$0$3);
+    var isEmpty_12 = __importDefault2(require$$0$2);
     var isArray_12 = __importDefault2(require$$1$1);
     var last_12 = __importDefault2(require$$4$3);
     var reject_1 = __importDefault2(require$$5$1);
@@ -55151,7 +55989,7 @@ Object.defineProperty(interpreter, "__esModule", { value: true });
 interpreter.nextPossibleTokensAfter = interpreter.possiblePathsFrom = interpreter.NextTerminalAfterAtLeastOneSepWalker = interpreter.NextTerminalAfterAtLeastOneWalker = interpreter.NextTerminalAfterManySepWalker = interpreter.NextTerminalAfterManyWalker = interpreter.AbstractNextTerminalAfterProductionWalker = interpreter.NextAfterTokenWalker = interpreter.AbstractNextPossibleTokensWalker = void 0;
 var rest_1 = rest;
 var first_1$1 = __importDefault$4(require$$1$2);
-var isEmpty_1 = __importDefault$4(require$$0$3);
+var isEmpty_1 = __importDefault$4(require$$0$2);
 var dropRight_1 = __importDefault$4(require$$3$4);
 var drop_1 = __importDefault$4(require$$0$1);
 var last_1 = __importDefault$4(require$$4$3);
@@ -55660,7 +56498,7 @@ function expandTopLevelRule(topRule, currIdx, currRuleStack, currOccurrenceStack
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.areTokenCategoriesNotUsed = exports.isStrictPrefixOfPath = exports.containsPath = exports.getLookaheadPathsForOptionalProd = exports.getLookaheadPathsForOr = exports.lookAheadSequenceFromAlternatives = exports.buildSingleAlternativeLookaheadFunction = exports.buildAlternativesLookAheadFunc = exports.buildLookaheadFuncForOptionalProd = exports.buildLookaheadFuncForOr = exports.getLookaheadPaths = exports.getProdType = exports.PROD_TYPE = void 0;
-  var isEmpty_12 = __importDefault2(require$$0$3);
+  var isEmpty_12 = __importDefault2(require$$0$2);
   var flatten_12 = __importDefault2(require$$3$1);
   var every_12 = __importDefault2(require$$2$2);
   var map_12 = __importDefault2(require$$2);
@@ -56124,7 +56962,7 @@ function requireChecks() {
   Object.defineProperty(checks, "__esModule", { value: true });
   checks.checkPrefixAlternativesAmbiguities = checks.validateSomeNonEmptyLookaheadPath = checks.validateTooManyAlts = checks.RepetitionCollector = checks.validateAmbiguousAlternationAlternatives = checks.validateEmptyOrAlternative = checks.getFirstNoneTerminal = checks.validateNoLeftRecursion = checks.validateRuleIsOverridden = checks.validateRuleDoesNotAlreadyExist = checks.OccurrenceValidationCollector = checks.identifyProductionForDuplicates = checks.validateGrammar = checks.validateLookahead = void 0;
   var first_12 = __importDefault2(require$$1$2);
-  var isEmpty_12 = __importDefault2(require$$0$3);
+  var isEmpty_12 = __importDefault2(require$$0$2);
   var drop_12 = __importDefault2(require$$0$1);
   var flatten_12 = __importDefault2(require$$3$1);
   var filter_1 = __importDefault2(require$$20);
@@ -56779,7 +57617,7 @@ function requireRecoverable() {
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.attemptInRepetitionRecovery = exports.Recoverable = exports.InRuleRecoveryException = exports.IN_RULE_RECOVERY_EXCEPTION = exports.EOF_FOLLOW_KEY = void 0;
     var tokens_public_1 = tokens_public;
-    var isEmpty_12 = __importDefault2(require$$0$3);
+    var isEmpty_12 = __importDefault2(require$$0$2);
     var dropRight_12 = __importDefault2(require$$3$4);
     var flatten_12 = __importDefault2(require$$3$1);
     var map_12 = __importDefault2(require$$2);
@@ -57095,7 +57933,7 @@ function requireLlk_lookahead() {
   Object.defineProperty(llk_lookahead, "__esModule", { value: true });
   llk_lookahead.LLkLookaheadStrategy = void 0;
   var flatMap_1 = __importDefault2(require$$14$1);
-  var isEmpty_12 = __importDefault2(require$$0$3);
+  var isEmpty_12 = __importDefault2(require$$0$2);
   var errors_public_1 = errors_public;
   var parser_1 = requireParser();
   var checks_1 = requireChecks();
@@ -57384,7 +58222,7 @@ lang_extensions.defineNameProp = defineNameProp;
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.validateMissingCstMethods = exports.validateVisitor = exports.CstVisitorDefinitionError = exports.createBaseVisitorConstructorWithDefaults = exports.createBaseSemanticVisitorConstructor = exports.defaultVisit = void 0;
-  var isEmpty_12 = __importDefault2(require$$0$3);
+  var isEmpty_12 = __importDefault2(require$$0$2);
   var compact_1 = __importDefault2(require$$1$3);
   var isArray_12 = __importDefault2(require$$1$1);
   var map_12 = __importDefault2(require$$2);
@@ -58090,7 +58928,7 @@ function requireRecognizer_engine() {
   };
   Object.defineProperty(recognizer_engine, "__esModule", { value: true });
   recognizer_engine.RecognizerEngine = void 0;
-  var isEmpty_12 = __importDefault2(require$$0$3);
+  var isEmpty_12 = __importDefault2(require$$0$2);
   var isArray_12 = __importDefault2(require$$1$1);
   var flatten_12 = __importDefault2(require$$3$1);
   var every_12 = __importDefault2(require$$2$2);
@@ -59077,7 +59915,7 @@ function requireParser() {
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.EmbeddedActionsParser = exports.CstParser = exports.Parser = exports.EMPTY_ALT = exports.ParserDefinitionErrorType = exports.DEFAULT_RULE_CONFIG = exports.DEFAULT_PARSER_CONFIG = exports.END_OF_FILE = void 0;
-    var isEmpty_12 = __importDefault2(require$$0$3);
+    var isEmpty_12 = __importDefault2(require$$0$2);
     var map_12 = __importDefault2(require$$2);
     var forEach_12 = __importDefault2(require$$1);
     var values_12 = __importDefault2(require$$3$2);