@eslint-community/regexpp 4.2.0 → 4.3.0

package/index.mjs

@@ -125,105 +125,105 @@ function isValidLoneUnicodeProperty(version, value) {
         (version >= 2021 && binPropertySets.es2021.has(value)));
 }
 
-const Backspace = 0x08;
-const CharacterTabulation = 0x09;
-const LineFeed = 0x0a;
-const LineTabulation = 0x0b;
-const FormFeed = 0x0c;
-const CarriageReturn = 0x0d;
-const ExclamationMark = 0x21;
-const DollarSign = 0x24;
-const LeftParenthesis = 0x28;
-const RightParenthesis = 0x29;
-const Asterisk = 0x2a;
-const PlusSign = 0x2b;
-const Comma = 0x2c;
-const HyphenMinus = 0x2d;
-const FullStop = 0x2e;
-const Solidus = 0x2f;
-const DigitZero = 0x30;
-const DigitOne = 0x31;
-const DigitSeven = 0x37;
-const DigitNine = 0x39;
-const Colon = 0x3a;
-const LessThanSign = 0x3c;
-const EqualsSign = 0x3d;
-const GreaterThanSign = 0x3e;
-const QuestionMark = 0x3f;
-const LatinCapitalLetterA = 0x41;
-const LatinCapitalLetterB = 0x42;
-const LatinCapitalLetterD = 0x44;
-const LatinCapitalLetterF = 0x46;
-const LatinCapitalLetterP = 0x50;
-const LatinCapitalLetterS = 0x53;
-const LatinCapitalLetterW = 0x57;
-const LatinCapitalLetterZ = 0x5a;
-const LowLine = 0x5f;
-const LatinSmallLetterA = 0x61;
-const LatinSmallLetterB = 0x62;
-const LatinSmallLetterC = 0x63;
-const LatinSmallLetterD = 0x64;
-const LatinSmallLetterF = 0x66;
-const LatinSmallLetterG = 0x67;
-const LatinSmallLetterI = 0x69;
-const LatinSmallLetterK = 0x6b;
-const LatinSmallLetterM = 0x6d;
-const LatinSmallLetterN = 0x6e;
-const LatinSmallLetterP = 0x70;
-const LatinSmallLetterR = 0x72;
-const LatinSmallLetterS = 0x73;
-const LatinSmallLetterT = 0x74;
-const LatinSmallLetterU = 0x75;
-const LatinSmallLetterV = 0x76;
-const LatinSmallLetterW = 0x77;
-const LatinSmallLetterX = 0x78;
-const LatinSmallLetterY = 0x79;
-const LatinSmallLetterZ = 0x7a;
-const LeftSquareBracket = 0x5b;
-const ReverseSolidus = 0x5c;
-const RightSquareBracket = 0x5d;
-const CircumflexAccent = 0x5e;
-const LeftCurlyBracket = 0x7b;
-const VerticalLine = 0x7c;
-const RightCurlyBracket = 0x7d;
-const ZeroWidthNonJoiner = 0x200c;
-const ZeroWidthJoiner = 0x200d;
-const LineSeparator = 0x2028;
-const ParagraphSeparator = 0x2029;
-const MinCodePoint = 0x00;
-const MaxCodePoint = 0x10ffff;
+const BACKSPACE = 0x08;
+const CHARACTER_TABULATION = 0x09;
+const LINE_FEED = 0x0a;
+const LINE_TABULATION = 0x0b;
+const FORM_FEED = 0x0c;
+const CARRIAGE_RETURN = 0x0d;
+const EXCLAMATION_MARK = 0x21;
+const DOLLAR_SIGN = 0x24;
+const LEFT_PARENTHESIS = 0x28;
+const RIGHT_PARENTHESIS = 0x29;
+const ASTERISK = 0x2a;
+const PLUS_SIGN = 0x2b;
+const COMMA = 0x2c;
+const HYPHEN_MINUS = 0x2d;
+const FULL_STOP = 0x2e;
+const SOLIDUS = 0x2f;
+const DIGIT_ZERO = 0x30;
+const DIGIT_ONE = 0x31;
+const DIGIT_SEVEN = 0x37;
+const DIGIT_NINE = 0x39;
+const COLON = 0x3a;
+const LESS_THAN_SIGN = 0x3c;
+const EQUALS_SIGN = 0x3d;
+const GREATER_THAN_SIGN = 0x3e;
+const QUESTION_MARK = 0x3f;
+const LATIN_CAPITAL_LETTER_A = 0x41;
+const LATIN_CAPITAL_LETTER_B = 0x42;
+const LATIN_CAPITAL_LETTER_D = 0x44;
+const LATIN_CAPITAL_LETTER_F = 0x46;
+const LATIN_CAPITAL_LETTER_P = 0x50;
+const LATIN_CAPITAL_LETTER_S = 0x53;
+const LATIN_CAPITAL_LETTER_W = 0x57;
+const LATIN_CAPITAL_LETTER_Z = 0x5a;
+const LOW_LINE = 0x5f;
+const LATIN_SMALL_LETTER_A = 0x61;
+const LATIN_SMALL_LETTER_B = 0x62;
+const LATIN_SMALL_LETTER_C = 0x63;
+const LATIN_SMALL_LETTER_D = 0x64;
+const LATIN_SMALL_LETTER_F = 0x66;
+const LATIN_SMALL_LETTER_G = 0x67;
+const LATIN_SMALL_LETTER_I = 0x69;
+const LATIN_SMALL_LETTER_K = 0x6b;
+const LATIN_SMALL_LETTER_M = 0x6d;
+const LATIN_SMALL_LETTER_N = 0x6e;
+const LATIN_SMALL_LETTER_P = 0x70;
+const LATIN_SMALL_LETTER_R = 0x72;
+const LATIN_SMALL_LETTER_S = 0x73;
+const LATIN_SMALL_LETTER_T = 0x74;
+const LATIN_SMALL_LETTER_U = 0x75;
+const LATIN_SMALL_LETTER_V = 0x76;
+const LATIN_SMALL_LETTER_W = 0x77;
+const LATIN_SMALL_LETTER_X = 0x78;
+const LATIN_SMALL_LETTER_Y = 0x79;
+const LATIN_SMALL_LETTER_Z = 0x7a;
+const LEFT_SQUARE_BRACKET = 0x5b;
+const REVERSE_SOLIDUS = 0x5c;
+const RIGHT_SQUARE_BRACKET = 0x5d;
+const CIRCUMFLEX_ACCENT = 0x5e;
+const LEFT_CURLY_BRACKET = 0x7b;
+const VERTICAL_LINE = 0x7c;
+const RIGHT_CURLY_BRACKET = 0x7d;
+const ZERO_WIDTH_NON_JOINER = 0x200c;
+const ZERO_WIDTH_JOINER = 0x200d;
+const LINE_SEPARATOR = 0x2028;
+const PARAGRAPH_SEPARATOR = 0x2029;
+const MIN_CODE_POINT = 0x00;
+const MAX_CODE_POINT = 0x10ffff;
 function isLatinLetter(code) {
-    return ((code >= LatinCapitalLetterA && code <= LatinCapitalLetterZ) ||
-        (code >= LatinSmallLetterA && code <= LatinSmallLetterZ));
+    return ((code >= LATIN_CAPITAL_LETTER_A && code <= LATIN_CAPITAL_LETTER_Z) ||
+        (code >= LATIN_SMALL_LETTER_A && code <= LATIN_SMALL_LETTER_Z));
 }
 function isDecimalDigit(code) {
-    return code >= DigitZero && code <= DigitNine;
+    return code >= DIGIT_ZERO && code <= DIGIT_NINE;
 }
 function isOctalDigit(code) {
-    return code >= DigitZero && code <= DigitSeven;
+    return code >= DIGIT_ZERO && code <= DIGIT_SEVEN;
 }
 function isHexDigit(code) {
-    return ((code >= DigitZero && code <= DigitNine) ||
-        (code >= LatinCapitalLetterA && code <= LatinCapitalLetterF) ||
-        (code >= LatinSmallLetterA && code <= LatinSmallLetterF));
+    return ((code >= DIGIT_ZERO && code <= DIGIT_NINE) ||
+        (code >= LATIN_CAPITAL_LETTER_A && code <= LATIN_CAPITAL_LETTER_F) ||
+        (code >= LATIN_SMALL_LETTER_A && code <= LATIN_SMALL_LETTER_F));
 }
 function isLineTerminator(code) {
-    return (code === LineFeed ||
-        code === CarriageReturn ||
-        code === LineSeparator ||
-        code === ParagraphSeparator);
+    return (code === LINE_FEED ||
+        code === CARRIAGE_RETURN ||
+        code === LINE_SEPARATOR ||
+        code === PARAGRAPH_SEPARATOR);
 }
 function isValidUnicode(code) {
-    return code >= MinCodePoint && code <= MaxCodePoint;
+    return code >= MIN_CODE_POINT && code <= MAX_CODE_POINT;
 }
 function digitToInt(code) {
-    if (code >= LatinSmallLetterA && code <= LatinSmallLetterF) {
-        return code - LatinSmallLetterA + 10;
+    if (code >= LATIN_SMALL_LETTER_A && code <= LATIN_SMALL_LETTER_F) {
+        return code - LATIN_SMALL_LETTER_A + 10;
     }
-    if (code >= LatinCapitalLetterA && code <= LatinCapitalLetterF) {
-        return code - LatinCapitalLetterA + 10;
+    if (code >= LATIN_CAPITAL_LETTER_A && code <= LATIN_CAPITAL_LETTER_F) {
+        return code - LATIN_CAPITAL_LETTER_A + 10;
     }
-    return code - DigitZero;
+    return code - DIGIT_ZERO;
 }
 function isLeadSurrogate(code) {
     return code >= 0xd800 && code <= 0xdbff;
@@ -353,33 +353,33 @@ class RegExpSyntaxError extends SyntaxError {
 }
 
 function isSyntaxCharacter(cp) {
-    return (cp === CircumflexAccent ||
-        cp === DollarSign ||
-        cp === ReverseSolidus ||
-        cp === FullStop ||
-        cp === Asterisk ||
-        cp === PlusSign ||
-        cp === QuestionMark ||
-        cp === LeftParenthesis ||
-        cp === RightParenthesis ||
-        cp === LeftSquareBracket ||
-        cp === RightSquareBracket ||
-        cp === LeftCurlyBracket ||
-        cp === RightCurlyBracket ||
-        cp === VerticalLine);
+    return (cp === CIRCUMFLEX_ACCENT ||
+        cp === DOLLAR_SIGN ||
+        cp === REVERSE_SOLIDUS ||
+        cp === FULL_STOP ||
+        cp === ASTERISK ||
+        cp === PLUS_SIGN ||
+        cp === QUESTION_MARK ||
+        cp === LEFT_PARENTHESIS ||
+        cp === RIGHT_PARENTHESIS ||
+        cp === LEFT_SQUARE_BRACKET ||
+        cp === RIGHT_SQUARE_BRACKET ||
+        cp === LEFT_CURLY_BRACKET ||
+        cp === RIGHT_CURLY_BRACKET ||
+        cp === VERTICAL_LINE);
 }
 function isRegExpIdentifierStart(cp) {
-    return isIdStart(cp) || cp === DollarSign || cp === LowLine;
+    return isIdStart(cp) || cp === DOLLAR_SIGN || cp === LOW_LINE;
 }
 function isRegExpIdentifierPart(cp) {
     return (isIdContinue(cp) ||
-        cp === DollarSign ||
-        cp === LowLine ||
-        cp === ZeroWidthNonJoiner ||
-        cp === ZeroWidthJoiner);
+        cp === DOLLAR_SIGN ||
+        cp === LOW_LINE ||
+        cp === ZERO_WIDTH_NON_JOINER ||
+        cp === ZERO_WIDTH_JOINER);
 }
 function isUnicodePropertyNameCharacter(cp) {
-    return isLatinLetter(cp) || cp === LowLine;
+    return isLatinLetter(cp) || cp === LOW_LINE;
 }
 function isUnicodePropertyValueCharacter(cp) {
     return isUnicodePropertyNameCharacter(cp) || isDecimalDigit(cp);
@@ -405,7 +405,7 @@ class RegExpValidator {
         this._uFlag = this._nFlag = false;
         this.reset(source, start, end);
         this.onLiteralEnter(start);
-        if (this.eat(Solidus) && this.eatRegExpBody() && this.eat(Solidus)) {
+        if (this.eat(SOLIDUS) && this.eatRegExpBody() && this.eat(SOLIDUS)) {
             const flagStart = this.index;
             const uFlag = source.includes("u", flagStart);
             this.validateFlags(source, flagStart, end);
@@ -435,32 +435,44 @@ class RegExpValidator {
                 this.raise(`Duplicated flag '${source[i]}'`);
             }
             existingFlags.add(flag);
-            if (flag === LatinSmallLetterG) {
+            if (flag === LATIN_SMALL_LETTER_G) {
                 global = true;
             }
-            else if (flag === LatinSmallLetterI) {
+            else if (flag === LATIN_SMALL_LETTER_I) {
                 ignoreCase = true;
             }
-            else if (flag === LatinSmallLetterM) {
+            else if (flag === LATIN_SMALL_LETTER_M) {
                 multiline = true;
             }
-            else if (flag === LatinSmallLetterU && this.ecmaVersion >= 2015) {
+            else if (flag === LATIN_SMALL_LETTER_U &&
+                this.ecmaVersion >= 2015) {
                 unicode = true;
             }
-            else if (flag === LatinSmallLetterY && this.ecmaVersion >= 2015) {
+            else if (flag === LATIN_SMALL_LETTER_Y &&
+                this.ecmaVersion >= 2015) {
                 sticky = true;
             }
-            else if (flag === LatinSmallLetterS && this.ecmaVersion >= 2018) {
+            else if (flag === LATIN_SMALL_LETTER_S &&
+                this.ecmaVersion >= 2018) {
                 dotAll = true;
             }
-            else if (flag === LatinSmallLetterD && this.ecmaVersion >= 2022) {
+            else if (flag === LATIN_SMALL_LETTER_D &&
+                this.ecmaVersion >= 2022) {
                 hasIndices = true;
             }
             else {
                 this.raise(`Invalid flag '${source[i]}'`);
             }
         }
-        this.onFlags(start, end, global, ignoreCase, multiline, unicode, sticky, dotAll, hasIndices);
+        this.onRegExpFlags(start, end, {
+            global,
+            ignoreCase,
+            multiline,
+            unicode,
+            sticky,
+            dotAll,
+            hasIndices,
+        });
     }
     validatePattern(source, start = 0, end = source.length, uFlag = false) {
         this._uFlag = uFlag && this.ecmaVersion >= 2015;
@@ -492,9 +504,12 @@ class RegExpValidator {
             this._options.onLiteralLeave(start, end);
         }
     }
-    onFlags(start, end, global, ignoreCase, multiline, unicode, sticky, dotAll, hasIndices) {
+    onRegExpFlags(start, end, flags) {
+        if (this._options.onRegExpFlags) {
+            this._options.onRegExpFlags(start, end, flags);
+        }
         if (this._options.onFlags) {
-            this._options.onFlags(start, end, global, ignoreCase, multiline, unicode, sticky, dotAll, hasIndices);
+            this._options.onFlags(start, end, flags.global, flags.ignoreCase, flags.multiline, flags.unicode, flags.sticky, flags.dotAll, flags.hasIndices);
         }
     }
     onPatternEnter(start) {
@@ -664,17 +679,17 @@ class RegExpValidator {
             if (escaped) {
                 escaped = false;
             }
-            else if (cp === ReverseSolidus) {
+            else if (cp === REVERSE_SOLIDUS) {
                 escaped = true;
             }
-            else if (cp === LeftSquareBracket) {
+            else if (cp === LEFT_SQUARE_BRACKET) {
                 inClass = true;
             }
-            else if (cp === RightSquareBracket) {
+            else if (cp === RIGHT_SQUARE_BRACKET) {
                 inClass = false;
             }
-            else if ((cp === Solidus && !inClass) ||
-                (cp === Asterisk && this.index === start)) {
+            else if ((cp === SOLIDUS && !inClass) ||
+                (cp === ASTERISK && this.index === start)) {
                 break;
             }
             this.advance();
@@ -690,13 +705,13 @@ class RegExpValidator {
         this.consumeDisjunction();
         const cp = this.currentCodePoint;
         if (this.currentCodePoint !== -1) {
-            if (cp === RightParenthesis) {
+            if (cp === RIGHT_PARENTHESIS) {
                 this.raise("Unmatched ')'");
             }
-            if (cp === ReverseSolidus) {
+            if (cp === REVERSE_SOLIDUS) {
                 this.raise("\\ at end of pattern");
             }
-            if (cp === RightSquareBracket || cp === RightCurlyBracket) {
+            if (cp === RIGHT_SQUARE_BRACKET || cp === RIGHT_CURLY_BRACKET) {
                 this.raise("Lone quantifier brackets");
             }
             const c = String.fromCodePoint(cp);
@@ -719,21 +734,21 @@ class RegExpValidator {
             if (escaped) {
                 escaped = false;
             }
-            else if (cp === ReverseSolidus) {
+            else if (cp === REVERSE_SOLIDUS) {
                 escaped = true;
             }
-            else if (cp === LeftSquareBracket) {
+            else if (cp === LEFT_SQUARE_BRACKET) {
                 inClass = true;
             }
-            else if (cp === RightSquareBracket) {
+            else if (cp === RIGHT_SQUARE_BRACKET) {
                 inClass = false;
             }
-            else if (cp === LeftParenthesis &&
+            else if (cp === LEFT_PARENTHESIS &&
                 !inClass &&
-                (this.nextCodePoint !== QuestionMark ||
-                    (this.nextCodePoint2 === LessThanSign &&
-                        this.nextCodePoint3 !== EqualsSign &&
-                        this.nextCodePoint3 !== ExclamationMark))) {
+                (this.nextCodePoint !== QUESTION_MARK ||
+                    (this.nextCodePoint2 === LESS_THAN_SIGN &&
+                        this.nextCodePoint3 !== EQUALS_SIGN &&
+                        this.nextCodePoint3 !== EXCLAMATION_MARK))) {
                 count += 1;
             }
             this.advance();
@@ -747,11 +762,11 @@ class RegExpValidator {
         this.onDisjunctionEnter(start);
         do {
             this.consumeAlternative(i++);
-        } while (this.eat(VerticalLine));
+        } while (this.eat(VERTICAL_LINE));
         if (this.consumeQuantifier(true)) {
             this.raise("Nothing to repeat");
         }
-        if (this.eat(LeftCurlyBracket)) {
+        if (this.eat(LEFT_CURLY_BRACKET)) {
             this.raise("Lone quantifier brackets");
         }
         this.onDisjunctionLeave(start, this.index);
@@ -780,30 +795,31 @@ class RegExpValidator {
     consumeAssertion() {
         const start = this.index;
         this._lastAssertionIsQuantifiable = false;
-        if (this.eat(CircumflexAccent)) {
+        if (this.eat(CIRCUMFLEX_ACCENT)) {
             this.onEdgeAssertion(start, this.index, "start");
             return true;
         }
-        if (this.eat(DollarSign)) {
+        if (this.eat(DOLLAR_SIGN)) {
             this.onEdgeAssertion(start, this.index, "end");
             return true;
         }
-        if (this.eat2(ReverseSolidus, LatinCapitalLetterB)) {
+        if (this.eat2(REVERSE_SOLIDUS, LATIN_CAPITAL_LETTER_B)) {
             this.onWordBoundaryAssertion(start, this.index, "word", true);
             return true;
         }
-        if (this.eat2(ReverseSolidus, LatinSmallLetterB)) {
+        if (this.eat2(REVERSE_SOLIDUS, LATIN_SMALL_LETTER_B)) {
             this.onWordBoundaryAssertion(start, this.index, "word", false);
             return true;
         }
-        if (this.eat2(LeftParenthesis, QuestionMark)) {
-            const lookbehind = this.ecmaVersion >= 2018 && this.eat(LessThanSign);
+        if (this.eat2(LEFT_PARENTHESIS, QUESTION_MARK)) {
+            const lookbehind = this.ecmaVersion >= 2018 && this.eat(LESS_THAN_SIGN);
             let negate = false;
-            if (this.eat(EqualsSign) || (negate = this.eat(ExclamationMark))) {
+            if (this.eat(EQUALS_SIGN) ||
+                (negate = this.eat(EXCLAMATION_MARK))) {
                 const kind = lookbehind ? "lookbehind" : "lookahead";
                 this.onLookaroundAssertionEnter(start, kind, negate);
                 this.consumeDisjunction();
-                if (!this.eat(RightParenthesis)) {
+                if (!this.eat(RIGHT_PARENTHESIS)) {
                     this.raise("Unterminated group");
                 }
                 this._lastAssertionIsQuantifiable = !lookbehind && !this.strict;
@@ -819,15 +835,15 @@ class RegExpValidator {
         let min = 0;
         let max = 0;
         let greedy = false;
-        if (this.eat(Asterisk)) {
+        if (this.eat(ASTERISK)) {
             min = 0;
             max = Number.POSITIVE_INFINITY;
         }
-        else if (this.eat(PlusSign)) {
+        else if (this.eat(PLUS_SIGN)) {
             min = 1;
             max = Number.POSITIVE_INFINITY;
         }
-        else if (this.eat(QuestionMark)) {
+        else if (this.eat(QUESTION_MARK)) {
             min = 0;
             max = 1;
         }
@@ -838,7 +854,7 @@ class RegExpValidator {
         else {
             return false;
         }
-        greedy = !this.eat(QuestionMark);
+        greedy = !this.eat(QUESTION_MARK);
         if (!noConsume) {
             this.onQuantifier(start, this.index, min, max, greedy);
         }
@@ -846,17 +862,17 @@ class RegExpValidator {
     }
     eatBracedQuantifier(noError) {
         const start = this.index;
-        if (this.eat(LeftCurlyBracket)) {
+        if (this.eat(LEFT_CURLY_BRACKET)) {
             this._lastMinValue = 0;
             this._lastMaxValue = Number.POSITIVE_INFINITY;
             if (this.eatDecimalDigits()) {
                 this._lastMinValue = this._lastMaxValue = this._lastIntValue;
-                if (this.eat(Comma)) {
+                if (this.eat(COMMA)) {
                     this._lastMaxValue = this.eatDecimalDigits()
                         ? this._lastIntValue
                         : Number.POSITIVE_INFINITY;
                 }
-                if (this.eat(RightCurlyBracket)) {
+                if (this.eat(RIGHT_CURLY_BRACKET)) {
                     if (!noError && this._lastMaxValue < this._lastMinValue) {
                         this.raise("numbers out of order in {} quantifier");
                     }
@@ -879,7 +895,7 @@ class RegExpValidator {
             this.consumeCapturingGroup());
     }
     consumeDot() {
-        if (this.eat(FullStop)) {
+        if (this.eat(FULL_STOP)) {
             this.onAnyCharacterSet(this.index - 1, this.index, "any");
             return true;
         }
@@ -887,7 +903,7 @@ class RegExpValidator {
     }
     consumeReverseSolidusAtomEscape() {
         const start = this.index;
-        if (this.eat(ReverseSolidus)) {
+        if (this.eat(REVERSE_SOLIDUS)) {
             if (this.consumeAtomEscape()) {
                 return true;
             }
@@ -897,10 +913,10 @@ class RegExpValidator {
     }
     consumeUncapturingGroup() {
         const start = this.index;
-        if (this.eat3(LeftParenthesis, QuestionMark, Colon)) {
+        if (this.eat3(LEFT_PARENTHESIS, QUESTION_MARK, COLON)) {
             this.onGroupEnter(start);
             this.consumeDisjunction();
-            if (!this.eat(RightParenthesis)) {
+            if (!this.eat(RIGHT_PARENTHESIS)) {
                 this.raise("Unterminated group");
             }
             this.onGroupLeave(start, this.index);
@@ -910,19 +926,19 @@ class RegExpValidator {
     }
     consumeCapturingGroup() {
         const start = this.index;
-        if (this.eat(LeftParenthesis)) {
+        if (this.eat(LEFT_PARENTHESIS)) {
             let name = null;
             if (this.ecmaVersion >= 2018) {
                 if (this.consumeGroupSpecifier()) {
                     name = this._lastStrValue;
                 }
             }
-            else if (this.currentCodePoint === QuestionMark) {
+            else if (this.currentCodePoint === QUESTION_MARK) {
                 this.raise("Invalid group");
             }
             this.onCapturingGroupEnter(start, name);
             this.consumeDisjunction();
-            if (!this.eat(RightParenthesis)) {
+            if (!this.eat(RIGHT_PARENTHESIS)) {
                 this.raise("Unterminated group");
             }
             this.onCapturingGroupLeave(start, this.index, name);
@@ -942,11 +958,11 @@ class RegExpValidator {
     }
     consumeReverseSolidusFollowedByC() {
         const start = this.index;
-        if (this.currentCodePoint === ReverseSolidus &&
-            this.nextCodePoint === LatinSmallLetterC) {
+        if (this.currentCodePoint === REVERSE_SOLIDUS &&
+            this.nextCodePoint === LATIN_SMALL_LETTER_C) {
             this._lastIntValue = this.currentCodePoint;
             this.advance();
-            this.onCharacter(start, this.index, ReverseSolidus);
+            this.onCharacter(start, this.index, REVERSE_SOLIDUS);
             return true;
         }
         return false;
@@ -971,17 +987,17 @@ class RegExpValidator {
         const start = this.index;
         const cp = this.currentCodePoint;
         if (cp !== -1 &&
-            cp !== CircumflexAccent &&
-            cp !== DollarSign &&
-            cp !== ReverseSolidus &&
-            cp !== FullStop &&
-            cp !== Asterisk &&
-            cp !== PlusSign &&
-            cp !== QuestionMark &&
-            cp !== LeftParenthesis &&
-            cp !== RightParenthesis &&
-            cp !== LeftSquareBracket &&
-            cp !== VerticalLine) {
+            cp !== CIRCUMFLEX_ACCENT &&
+            cp !== DOLLAR_SIGN &&
+            cp !== REVERSE_SOLIDUS &&
+            cp !== FULL_STOP &&
+            cp !== ASTERISK &&
+            cp !== PLUS_SIGN &&
+            cp !== QUESTION_MARK &&
+            cp !== LEFT_PARENTHESIS &&
+            cp !== RIGHT_PARENTHESIS &&
+            cp !== LEFT_SQUARE_BRACKET &&
+            cp !== VERTICAL_LINE) {
             this.advance();
             this.onCharacter(start, this.index, cp);
             return true;
@@ -989,7 +1005,7 @@ class RegExpValidator {
         return false;
     }
     consumeGroupSpecifier() {
-        if (this.eat(QuestionMark)) {
+        if (this.eat(QUESTION_MARK)) {
             if (this.eatGroupName()) {
                 if (!this._groupNames.has(this._lastStrValue)) {
                     this._groupNames.add(this._lastStrValue);
@@ -1030,32 +1046,32 @@ class RegExpValidator {
     }
     consumeCharacterClassEscape() {
         const start = this.index;
-        if (this.eat(LatinSmallLetterD)) {
+        if (this.eat(LATIN_SMALL_LETTER_D)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "digit", false);
             return true;
         }
-        if (this.eat(LatinCapitalLetterD)) {
+        if (this.eat(LATIN_CAPITAL_LETTER_D)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "digit", true);
             return true;
         }
-        if (this.eat(LatinSmallLetterS)) {
+        if (this.eat(LATIN_SMALL_LETTER_S)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "space", false);
             return true;
         }
-        if (this.eat(LatinCapitalLetterS)) {
+        if (this.eat(LATIN_CAPITAL_LETTER_S)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "space", true);
             return true;
         }
-        if (this.eat(LatinSmallLetterW)) {
+        if (this.eat(LATIN_SMALL_LETTER_W)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "word", false);
             return true;
         }
-        if (this.eat(LatinCapitalLetterW)) {
+        if (this.eat(LATIN_CAPITAL_LETTER_W)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "word", true);
             return true;
@@ -1063,12 +1079,12 @@ class RegExpValidator {
         let negate = false;
         if (this._uFlag &&
             this.ecmaVersion >= 2018 &&
-            (this.eat(LatinSmallLetterP) ||
-                (negate = this.eat(LatinCapitalLetterP)))) {
+            (this.eat(LATIN_SMALL_LETTER_P) ||
+                (negate = this.eat(LATIN_CAPITAL_LETTER_P)))) {
             this._lastIntValue = -1;
-            if (this.eat(LeftCurlyBracket) &&
+            if (this.eat(LEFT_CURLY_BRACKET) &&
                 this.eatUnicodePropertyValueExpression() &&
-                this.eat(RightCurlyBracket)) {
+                this.eat(RIGHT_CURLY_BRACKET)) {
                 this.onUnicodePropertyCharacterSet(start - 1, this.index, "property", this._lastKeyValue, this._lastValValue || null, negate);
                 return true;
             }
@@ -1094,7 +1110,7 @@ class RegExpValidator {
     }
     consumeKGroupName() {
         const start = this.index;
-        if (this.eat(LatinSmallLetterK)) {
+        if (this.eat(LATIN_SMALL_LETTER_K)) {
             if (this.eatGroupName()) {
                 const groupName = this._lastStrValue;
                 this._backreferenceNames.add(groupName);
@@ -1107,11 +1123,11 @@ class RegExpValidator {
     }
     consumeCharacterClass() {
         const start = this.index;
-        if (this.eat(LeftSquareBracket)) {
-            const negate = this.eat(CircumflexAccent);
+        if (this.eat(LEFT_SQUARE_BRACKET)) {
+            const negate = this.eat(CIRCUMFLEX_ACCENT);
             this.onCharacterClassEnter(start, negate);
             this.consumeClassRanges();
-            if (!this.eat(RightSquareBracket)) {
+            if (!this.eat(RIGHT_SQUARE_BRACKET)) {
                 this.raise("Unterminated character class");
             }
             this.onCharacterClassLeave(start, this.index, negate);
@@ -1127,10 +1143,10 @@ class RegExpValidator {
                 break;
             }
             const min = this._lastIntValue;
-            if (!this.eat(HyphenMinus)) {
+            if (!this.eat(HYPHEN_MINUS)) {
                 continue;
             }
-            this.onCharacter(this.index - 1, this.index, HyphenMinus);
+            this.onCharacter(this.index - 1, this.index, HYPHEN_MINUS);
             if (!this.consumeClassAtom()) {
                 break;
             }
@@ -1150,18 +1166,21 @@ class RegExpValidator {
     consumeClassAtom() {
         const start = this.index;
         const cp = this.currentCodePoint;
-        if (cp !== -1 && cp !== ReverseSolidus && cp !== RightSquareBracket) {
+        if (cp !== -1 &&
+            cp !== REVERSE_SOLIDUS &&
+            cp !== RIGHT_SQUARE_BRACKET) {
             this.advance();
             this._lastIntValue = cp;
             this.onCharacter(start, this.index, this._lastIntValue);
             return true;
         }
-        if (this.eat(ReverseSolidus)) {
+        if (this.eat(REVERSE_SOLIDUS)) {
             if (this.consumeClassEscape()) {
                 return true;
             }
-            if (!this.strict && this.currentCodePoint === LatinSmallLetterC) {
-                this._lastIntValue = ReverseSolidus;
+            if (!this.strict &&
+                this.currentCodePoint === LATIN_SMALL_LETTER_C) {
+                this._lastIntValue = REVERSE_SOLIDUS;
                 this.onCharacter(start, this.index, this._lastIntValue);
                 return true;
             }
@@ -1174,21 +1193,21 @@ class RegExpValidator {
     }
     consumeClassEscape() {
         const start = this.index;
-        if (this.eat(LatinSmallLetterB)) {
-            this._lastIntValue = Backspace;
+        if (this.eat(LATIN_SMALL_LETTER_B)) {
+            this._lastIntValue = BACKSPACE;
             this.onCharacter(start - 1, this.index, this._lastIntValue);
             return true;
         }
-        if (this._uFlag && this.eat(HyphenMinus)) {
-            this._lastIntValue = HyphenMinus;
+        if (this._uFlag && this.eat(HYPHEN_MINUS)) {
+            this._lastIntValue = HYPHEN_MINUS;
             this.onCharacter(start - 1, this.index, this._lastIntValue);
             return true;
         }
         let cp = 0;
         if (!this.strict &&
             !this._uFlag &&
-            this.currentCodePoint === LatinSmallLetterC &&
-            (isDecimalDigit((cp = this.nextCodePoint)) || cp === LowLine)) {
+            this.currentCodePoint === LATIN_SMALL_LETTER_C &&
+            (isDecimalDigit((cp = this.nextCodePoint)) || cp === LOW_LINE)) {
             this.advance();
             this.advance();
             this._lastIntValue = cp % 0x20;
@@ -1198,8 +1217,8 @@ class RegExpValidator {
         return (this.consumeCharacterClassEscape() || this.consumeCharacterEscape());
     }
     eatGroupName() {
-        if (this.eat(LessThanSign)) {
-            if (this.eatRegExpIdentifierName() && this.eat(GreaterThanSign)) {
+        if (this.eat(LESS_THAN_SIGN)) {
+            if (this.eatRegExpIdentifierName() && this.eat(GREATER_THAN_SIGN)) {
                 return true;
             }
             this.raise("Invalid capture group name");
@@ -1221,7 +1240,7 @@ class RegExpValidator {
         const forceUFlag = !this._uFlag && this.ecmaVersion >= 2020;
         let cp = this.currentCodePoint;
         this.advance();
-        if (cp === ReverseSolidus &&
+        if (cp === REVERSE_SOLIDUS &&
             this.eatRegExpUnicodeEscapeSequence(forceUFlag)) {
             cp = this._lastIntValue;
         }
@@ -1245,7 +1264,7 @@ class RegExpValidator {
         const forceUFlag = !this._uFlag && this.ecmaVersion >= 2020;
         let cp = this.currentCodePoint;
         this.advance();
-        if (cp === ReverseSolidus &&
+        if (cp === REVERSE_SOLIDUS &&
             this.eatRegExpUnicodeEscapeSequence(forceUFlag)) {
             cp = this._lastIntValue;
         }
@@ -1266,7 +1285,7 @@ class RegExpValidator {
     }
     eatCControlLetter() {
         const start = this.index;
-        if (this.eat(LatinSmallLetterC)) {
+        if (this.eat(LATIN_SMALL_LETTER_C)) {
             if (this.eatControlLetter()) {
                 return true;
             }
@@ -1275,7 +1294,7 @@ class RegExpValidator {
         return false;
     }
     eatZero() {
-        if (this.currentCodePoint === DigitZero &&
+        if (this.currentCodePoint === DIGIT_ZERO &&
             !isDecimalDigit(this.nextCodePoint)) {
             this._lastIntValue = 0;
             this.advance();
@@ -1284,24 +1303,24 @@ class RegExpValidator {
         return false;
     }
     eatControlEscape() {
-        if (this.eat(LatinSmallLetterF)) {
-            this._lastIntValue = FormFeed;
+        if (this.eat(LATIN_SMALL_LETTER_F)) {
+            this._lastIntValue = FORM_FEED;
             return true;
         }
-        if (this.eat(LatinSmallLetterN)) {
-            this._lastIntValue = LineFeed;
+        if (this.eat(LATIN_SMALL_LETTER_N)) {
+            this._lastIntValue = LINE_FEED;
             return true;
         }
-        if (this.eat(LatinSmallLetterR)) {
-            this._lastIntValue = CarriageReturn;
+        if (this.eat(LATIN_SMALL_LETTER_R)) {
+            this._lastIntValue = CARRIAGE_RETURN;
             return true;
         }
-        if (this.eat(LatinSmallLetterT)) {
-            this._lastIntValue = CharacterTabulation;
+        if (this.eat(LATIN_SMALL_LETTER_T)) {
+            this._lastIntValue = CHARACTER_TABULATION;
             return true;
         }
-        if (this.eat(LatinSmallLetterV)) {
-            this._lastIntValue = LineTabulation;
+        if (this.eat(LATIN_SMALL_LETTER_V)) {
+            this._lastIntValue = LINE_TABULATION;
             return true;
         }
         return false;
@@ -1318,7 +1337,7 @@ class RegExpValidator {
     eatRegExpUnicodeEscapeSequence(forceUFlag = false) {
         const start = this.index;
         const uFlag = forceUFlag || this._uFlag;
-        if (this.eat(LatinSmallLetterU)) {
+        if (this.eat(LATIN_SMALL_LETTER_U)) {
             if ((uFlag && this.eatRegExpUnicodeSurrogatePairEscape()) ||
                 this.eatFixedHexDigits(4) ||
                 (uFlag && this.eatRegExpUnicodeCodePointEscape())) {
@@ -1336,8 +1355,8 @@ class RegExpValidator {
         if (this.eatFixedHexDigits(4)) {
             const lead = this._lastIntValue;
             if (isLeadSurrogate(lead) &&
-                this.eat(ReverseSolidus) &&
-                this.eat(LatinSmallLetterU) &&
+                this.eat(REVERSE_SOLIDUS) &&
+                this.eat(LATIN_SMALL_LETTER_U) &&
                 this.eatFixedHexDigits(4)) {
                 const trail = this._lastIntValue;
                 if (isTrailSurrogate(trail)) {
@@ -1351,9 +1370,9 @@ class RegExpValidator {
     }
     eatRegExpUnicodeCodePointEscape() {
         const start = this.index;
-        if (this.eat(LeftCurlyBracket) &&
+        if (this.eat(LEFT_CURLY_BRACKET) &&
             this.eatHexDigits() &&
-            this.eat(RightCurlyBracket) &&
+            this.eat(RIGHT_CURLY_BRACKET) &&
             isValidUnicode(this._lastIntValue)) {
             return true;
         }
@@ -1374,32 +1393,32 @@ class RegExpValidator {
             return false;
         }
         if (this._uFlag) {
-            return isSyntaxCharacter(cp) || cp === Solidus;
+            return isSyntaxCharacter(cp) || cp === SOLIDUS;
         }
         if (this.strict) {
             return !isIdContinue(cp);
         }
         if (this._nFlag) {
-            return !(cp === LatinSmallLetterC || cp === LatinSmallLetterK);
+            return !(cp === LATIN_SMALL_LETTER_C || cp === LATIN_SMALL_LETTER_K);
         }
-        return cp !== LatinSmallLetterC;
+        return cp !== LATIN_SMALL_LETTER_C;
     }
     eatDecimalEscape() {
         this._lastIntValue = 0;
         let cp = this.currentCodePoint;
-        if (cp >= DigitOne && cp <= DigitNine) {
+        if (cp >= DIGIT_ONE && cp <= DIGIT_NINE) {
             do {
-                this._lastIntValue = 10 * this._lastIntValue + (cp - DigitZero);
+                this._lastIntValue = 10 * this._lastIntValue + (cp - DIGIT_ZERO);
                 this.advance();
-            } while ((cp = this.currentCodePoint) >= DigitZero &&
-                cp <= DigitNine);
+            } while ((cp = this.currentCodePoint) >= DIGIT_ZERO &&
+                cp <= DIGIT_NINE);
             return true;
         }
         return false;
     }
     eatUnicodePropertyValueExpression() {
         const start = this.index;
-        if (this.eatUnicodePropertyName() && this.eat(EqualsSign)) {
+        if (this.eatUnicodePropertyName() && this.eat(EQUALS_SIGN)) {
             this._lastKeyValue = this._lastStrValue;
             if (this.eatUnicodePropertyValue()) {
                 this._lastValValue = this._lastStrValue;
@@ -1447,7 +1466,7 @@ class RegExpValidator {
     }
     eatHexEscapeSequence() {
         const start = this.index;
-        if (this.eat(LatinSmallLetterX)) {
+        if (this.eat(LATIN_SMALL_LETTER_X)) {
             if (this.eatFixedHexDigits(2)) {
                 return true;
             }
@@ -1501,7 +1520,7 @@ class RegExpValidator {
         const cp = this.currentCodePoint;
         if (isOctalDigit(cp)) {
             this.advance();
-            this._lastIntValue = cp - DigitZero;
+            this._lastIntValue = cp - DIGIT_ZERO;
             return true;
         }
         this._lastIntValue = 0;
@@ -1523,14 +1542,14 @@ class RegExpValidator {
     }
 }
 
-const DummyPattern = {};
-const DummyFlags = {};
-const DummyCapturingGroup = {};
+const DUMMY_PATTERN = {};
+const DUMMY_FLAGS = {};
+const DUMMY_CAPTURING_GROUP = {};
 class RegExpParserState {
     constructor(options) {
         var _a;
-        this._node = DummyPattern;
-        this._flags = DummyFlags;
+        this._node = DUMMY_PATTERN;
+        this._flags = DUMMY_FLAGS;
         this._backreferences = [];
         this._capturingGroups = [];
         this.source = "";
@@ -1549,7 +1568,7 @@ class RegExpParserState {
         }
         return this._flags;
     }
-    onFlags(start, end, global, ignoreCase, multiline, unicode, sticky, dotAll, hasIndices) {
+    onRegExpFlags(start, end, { global, ignoreCase, multiline, unicode, sticky, dotAll, hasIndices, }) {
         this._flags = {
             type: "Flags",
             parent: null,
@@ -1820,7 +1839,7 @@ class RegExpParserState {
             end,
             raw: this.source.slice(start, end),
             ref,
-            resolved: DummyCapturingGroup,
+            resolved: DUMMY_CAPTURING_GROUP,
         };
         parent.elements.push(node);
         this._backreferences.push(node);
@@ -1866,7 +1885,7 @@ class RegExpParserState {
             min.type !== "Character" ||
             max.type !== "Character" ||
             hyphen.type !== "Character" ||
-            hyphen.value !== HyphenMinus) {
+            hyphen.value !== HYPHEN_MINUS) {
             throw new Error("UnknownError");
         }
         const node = {