@eslint-community/regexpp 4.5.1 → 4.6.1

package/index.mjs

@@ -2,6 +2,8 @@ var ast = /*#__PURE__*/Object.freeze({
     __proto__: null
 });
 
+const latestEcmaVersion = 2024;
+
 let largeIdStartRanges = undefined;
 let largeIdContinueRanges = undefined;
 function isIdStart(cp) {
@@ -138,7 +140,10 @@ const LINE_TABULATION = 0x0b;
 const FORM_FEED = 0x0c;
 const CARRIAGE_RETURN = 0x0d;
 const EXCLAMATION_MARK = 0x21;
+const NUMBER_SIGN = 0x23;
 const DOLLAR_SIGN = 0x24;
+const PERCENT_SIGN = 0x25;
+const AMPERSAND = 0x26;
 const LEFT_PARENTHESIS = 0x28;
 const RIGHT_PARENTHESIS = 0x29;
 const ASTERISK = 0x2a;
@@ -152,10 +157,12 @@ const DIGIT_ONE = 0x31;
 const DIGIT_SEVEN = 0x37;
 const DIGIT_NINE = 0x39;
 const COLON = 0x3a;
+const SEMICOLON = 0x3b;
 const LESS_THAN_SIGN = 0x3c;
 const EQUALS_SIGN = 0x3d;
 const GREATER_THAN_SIGN = 0x3e;
 const QUESTION_MARK = 0x3f;
+const COMMERCIAL_AT = 0x40;
 const LATIN_CAPITAL_LETTER_A = 0x41;
 const LATIN_CAPITAL_LETTER_B = 0x42;
 const LATIN_CAPITAL_LETTER_D = 0x44;
@@ -176,6 +183,7 @@ 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_Q = 0x71;
 const LATIN_SMALL_LETTER_R = 0x72;
 const LATIN_SMALL_LETTER_S = 0x73;
 const LATIN_SMALL_LETTER_T = 0x74;
@@ -189,9 +197,11 @@ const LEFT_SQUARE_BRACKET = 0x5b;
 const REVERSE_SOLIDUS = 0x5c;
 const RIGHT_SQUARE_BRACKET = 0x5d;
 const CIRCUMFLEX_ACCENT = 0x5e;
+const GRAVE_ACCENT = 0x60;
 const LEFT_CURLY_BRACKET = 0x7b;
 const VERTICAL_LINE = 0x7c;
 const RIGHT_CURLY_BRACKET = 0x7d;
+const TILDE = 0x7e;
 const ZERO_WIDTH_NON_JOINER = 0x200c;
 const ZERO_WIDTH_JOINER = 0x200d;
 const LINE_SEPARATOR = 0x2028;
@@ -346,10 +356,10 @@ class Reader {
 }
 
 class RegExpSyntaxError extends SyntaxError {
-    constructor(source, uFlag, index, message) {
+    constructor(source, flags, index, message) {
         if (source) {
             if (!source.startsWith("/")) {
-                source = `/${source}/${uFlag ? "u" : ""}`;
+                source = `/${source}/${flags.unicode ? "u" : ""}${flags.unicodeSets ? "v" : ""}`;
             }
             source = `: ${source}`;
         }
@@ -358,29 +368,102 @@ class RegExpSyntaxError extends SyntaxError {
     }
 }
 
+const binPropertyOfStringSets = new Set([
+    "Basic_Emoji",
+    "Emoji_Keycap_Sequence",
+    "RGI_Emoji_Modifier_Sequence",
+    "RGI_Emoji_Flag_Sequence",
+    "RGI_Emoji_Tag_Sequence",
+    "RGI_Emoji_ZWJ_Sequence",
+    "RGI_Emoji",
+]);
+function isValidLoneUnicodePropertyOfString(version, value) {
+    return version >= 2024 && binPropertyOfStringSets.has(value);
+}
+
+const SYNTAX_CHARACTER = new Set([
+    CIRCUMFLEX_ACCENT,
+    DOLLAR_SIGN,
+    REVERSE_SOLIDUS,
+    FULL_STOP,
+    ASTERISK,
+    PLUS_SIGN,
+    QUESTION_MARK,
+    LEFT_PARENTHESIS,
+    RIGHT_PARENTHESIS,
+    LEFT_SQUARE_BRACKET,
+    RIGHT_SQUARE_BRACKET,
+    LEFT_CURLY_BRACKET,
+    RIGHT_CURLY_BRACKET,
+    VERTICAL_LINE,
+]);
+const CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR_CHARACTER = new Set([
+    AMPERSAND,
+    EXCLAMATION_MARK,
+    NUMBER_SIGN,
+    DOLLAR_SIGN,
+    PERCENT_SIGN,
+    ASTERISK,
+    PLUS_SIGN,
+    COMMA,
+    FULL_STOP,
+    COLON,
+    SEMICOLON,
+    LESS_THAN_SIGN,
+    EQUALS_SIGN,
+    GREATER_THAN_SIGN,
+    QUESTION_MARK,
+    COMMERCIAL_AT,
+    CIRCUMFLEX_ACCENT,
+    GRAVE_ACCENT,
+    TILDE,
+]);
+const CLASS_SET_SYNTAX_CHARACTER = new Set([
+    LEFT_PARENTHESIS,
+    RIGHT_PARENTHESIS,
+    LEFT_SQUARE_BRACKET,
+    RIGHT_SQUARE_BRACKET,
+    LEFT_CURLY_BRACKET,
+    RIGHT_CURLY_BRACKET,
+    SOLIDUS,
+    HYPHEN_MINUS,
+    REVERSE_SOLIDUS,
+    VERTICAL_LINE,
+]);
+const CLASS_SET_RESERVED_PUNCTUATOR = new Set([
+    AMPERSAND,
+    HYPHEN_MINUS,
+    EXCLAMATION_MARK,
+    NUMBER_SIGN,
+    PERCENT_SIGN,
+    COMMA,
+    COLON,
+    SEMICOLON,
+    LESS_THAN_SIGN,
+    EQUALS_SIGN,
+    GREATER_THAN_SIGN,
+    COMMERCIAL_AT,
+    GRAVE_ACCENT,
+    TILDE,
+]);
 function isSyntaxCharacter(cp) {
-    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);
+    return SYNTAX_CHARACTER.has(cp);
 }
-function isRegExpIdentifierStart(cp) {
+function isClassSetReservedDoublePunctuatorCharacter(cp) {
+    return CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR_CHARACTER.has(cp);
+}
+function isClassSetSyntaxCharacter(cp) {
+    return CLASS_SET_SYNTAX_CHARACTER.has(cp);
+}
+function isClassSetReservedPunctuator(cp) {
+    return CLASS_SET_RESERVED_PUNCTUATOR.has(cp);
+}
+function isIdentifierStartChar(cp) {
     return isIdStart(cp) || cp === DOLLAR_SIGN || cp === LOW_LINE;
 }
-function isRegExpIdentifierPart(cp) {
+function isIdentifierPartChar(cp) {
     return (isIdContinue(cp) ||
         cp === DOLLAR_SIGN ||
-        cp === LOW_LINE ||
         cp === ZERO_WIDTH_NON_JOINER ||
         cp === ZERO_WIDTH_JOINER);
 }
@@ -393,14 +476,15 @@ function isUnicodePropertyValueCharacter(cp) {
 class RegExpValidator {
     constructor(options) {
         this._reader = new Reader();
-        this._uFlag = false;
+        this._unicodeMode = false;
+        this._unicodeSetsMode = false;
         this._nFlag = false;
         this._lastIntValue = 0;
-        this._lastMinValue = 0;
-        this._lastMaxValue = 0;
+        this._lastRange = {
+            min: 0,
+            max: Number.POSITIVE_INFINITY,
+        };
         this._lastStrValue = "";
-        this._lastKeyValue = "";
-        this._lastValValue = "";
         this._lastAssertionIsQuantifiable = false;
         this._numCapturingParens = 0;
         this._groupNames = new Set();
@@ -408,14 +492,18 @@ class RegExpValidator {
         this._options = options !== null && options !== void 0 ? options : {};
     }
     validateLiteral(source, start = 0, end = source.length) {
-        this._uFlag = this._nFlag = false;
+        this._unicodeSetsMode = this._unicodeMode = this._nFlag = false;
         this.reset(source, start, end);
         this.onLiteralEnter(start);
         if (this.eat(SOLIDUS) && this.eatRegExpBody() && this.eat(SOLIDUS)) {
             const flagStart = this.index;
-            const uFlag = source.includes("u", flagStart);
+            const unicode = source.includes("u", flagStart);
+            const unicodeSets = source.includes("v", flagStart);
             this.validateFlags(source, flagStart, end);
-            this.validatePattern(source, start + 1, flagStart - 1, uFlag);
+            this.validatePattern(source, start + 1, flagStart - 1, {
+                unicode,
+                unicodeSets,
+            });
         }
         else if (start >= end) {
             this.raise("Empty");
@@ -435,6 +523,7 @@ class RegExpValidator {
         let unicode = false;
         let dotAll = false;
         let hasIndices = false;
+        let unicodeSets = false;
         for (let i = start; i < end; ++i) {
             const flag = source.charCodeAt(i);
             if (existingFlags.has(flag)) {
@@ -466,6 +555,10 @@ class RegExpValidator {
                 this.ecmaVersion >= 2022) {
                 hasIndices = true;
             }
+            else if (flag === LATIN_SMALL_LETTER_V &&
+                this.ecmaVersion >= 2024) {
+                unicodeSets = true;
+            }
             else {
                 this.raise(`Invalid flag '${source[i]}'`);
             }
@@ -478,13 +571,14 @@ class RegExpValidator {
             sticky,
             dotAll,
             hasIndices,
+            unicodeSets,
         });
     }
-    validatePattern(source, start = 0, end = source.length, uFlag = false) {
-        this._uFlag = uFlag && this.ecmaVersion >= 2015;
-        this._nFlag =
-            (uFlag && this.ecmaVersion >= 2018) ||
-                Boolean(this._options.strict && this.ecmaVersion >= 2023);
+    validatePattern(source, start = 0, end = source.length, uFlagOrFlags = undefined) {
+        const mode = this._parseFlagsOptionToMode(uFlagOrFlags, source, end);
+        this._unicodeMode = mode.unicodeMode;
+        this._nFlag = mode.nFlag;
+        this._unicodeSetsMode = mode.unicodeSetsMode;
         this.reset(source, start, end);
         this.consumePattern();
         if (!this._nFlag &&
@@ -495,12 +589,36 @@ class RegExpValidator {
             this.consumePattern();
         }
     }
+    _parseFlagsOptionToMode(uFlagOrFlags, source, sourceEnd) {
+        let unicode = false;
+        let unicodeSets = false;
+        if (uFlagOrFlags && this.ecmaVersion >= 2015) {
+            if (typeof uFlagOrFlags === "object") {
+                unicode = Boolean(uFlagOrFlags.unicode);
+                if (this.ecmaVersion >= 2024) {
+                    unicodeSets = Boolean(uFlagOrFlags.unicodeSets);
+                }
+            }
+            else {
+                unicode = uFlagOrFlags;
+            }
+        }
+        if (unicode && unicodeSets) {
+            throw new RegExpSyntaxError(source, { unicode, unicodeSets }, sourceEnd + 1, "Invalid regular expression flags");
+        }
+        const unicodeMode = unicode || unicodeSets;
+        const nFlag = (unicode && this.ecmaVersion >= 2018) ||
+            unicodeSets ||
+            Boolean(this._options.strict && this.ecmaVersion >= 2023);
+        const unicodeSetsMode = unicodeSets;
+        return { unicodeMode, nFlag, unicodeSetsMode };
+    }
     get strict() {
-        return Boolean(this._options.strict) || this._uFlag;
+        return Boolean(this._options.strict) || this._unicodeMode;
     }
     get ecmaVersion() {
         var _a;
-        return (_a = this._options.ecmaVersion) !== null && _a !== void 0 ? _a : 2023;
+        return (_a = this._options.ecmaVersion) !== null && _a !== void 0 ? _a : latestEcmaVersion;
     }
     onLiteralEnter(start) {
         if (this._options.onLiteralEnter) {
@@ -605,9 +723,9 @@ class RegExpValidator {
             this._options.onEscapeCharacterSet(start, end, kind, negate);
         }
     }
-    onUnicodePropertyCharacterSet(start, end, kind, key, value, negate) {
+    onUnicodePropertyCharacterSet(start, end, kind, key, value, negate, strings) {
         if (this._options.onUnicodePropertyCharacterSet) {
-            this._options.onUnicodePropertyCharacterSet(start, end, kind, key, value, negate);
+            this._options.onUnicodePropertyCharacterSet(start, end, kind, key, value, negate, strings);
         }
     }
     onCharacter(start, end, value) {
@@ -620,9 +738,9 @@ class RegExpValidator {
             this._options.onBackreference(start, end, ref);
         }
     }
-    onCharacterClassEnter(start, negate) {
+    onCharacterClassEnter(start, negate, unicodeSets) {
         if (this._options.onCharacterClassEnter) {
-            this._options.onCharacterClassEnter(start, negate);
+            this._options.onCharacterClassEnter(start, negate, unicodeSets);
         }
     }
     onCharacterClassLeave(start, end, negate) {
@@ -635,6 +753,36 @@ class RegExpValidator {
             this._options.onCharacterClassRange(start, end, min, max);
         }
     }
+    onClassIntersection(start, end) {
+        if (this._options.onClassIntersection) {
+            this._options.onClassIntersection(start, end);
+        }
+    }
+    onClassSubtraction(start, end) {
+        if (this._options.onClassSubtraction) {
+            this._options.onClassSubtraction(start, end);
+        }
+    }
+    onClassStringDisjunctionEnter(start) {
+        if (this._options.onClassStringDisjunctionEnter) {
+            this._options.onClassStringDisjunctionEnter(start);
+        }
+    }
+    onClassStringDisjunctionLeave(start, end) {
+        if (this._options.onClassStringDisjunctionLeave) {
+            this._options.onClassStringDisjunctionLeave(start, end);
+        }
+    }
+    onStringAlternativeEnter(start, index) {
+        if (this._options.onStringAlternativeEnter) {
+            this._options.onStringAlternativeEnter(start, index);
+        }
+    }
+    onStringAlternativeLeave(start, end, index) {
+        if (this._options.onStringAlternativeLeave) {
+            this._options.onStringAlternativeLeave(start, end, index);
+        }
+    }
     get source() {
         return this._reader.source;
     }
@@ -654,7 +802,7 @@ class RegExpValidator {
         return this._reader.nextCodePoint3;
     }
     reset(source, start, end) {
-        this._reader.reset(source, start, end, this._uFlag);
+        this._reader.reset(source, start, end, this._unicodeMode);
     }
     rewind(index) {
         this._reader.rewind(index);
@@ -672,7 +820,10 @@ class RegExpValidator {
         return this._reader.eat3(cp1, cp2, cp3);
     }
     raise(message) {
-        throw new RegExpSyntaxError(this.source, this._uFlag, this.index, message);
+        throw new RegExpSyntaxError(this.source, {
+            unicode: this._unicodeMode && !this._unicodeSetsMode,
+            unicodeSets: this._unicodeSetsMode,
+        }, this.index, message);
     }
     eatRegExpBody() {
         const start = this.index;
@@ -787,7 +938,7 @@ class RegExpValidator {
         this.onAlternativeLeave(start, this.index, i);
     }
     consumeTerm() {
-        if (this._uFlag || this.strict) {
+        if (this._unicodeMode || this.strict) {
             return (this.consumeAssertion() ||
                 (this.consumeAtom() && this.consumeOptionalQuantifier()));
         }
@@ -856,8 +1007,7 @@ class RegExpValidator {
             max = 1;
         }
         else if (this.eatBracedQuantifier(noConsume)) {
-            min = this._lastMinValue;
-            max = this._lastMaxValue;
+            ({ min, max } = this._lastRange);
         }
         else {
             return false;
@@ -871,23 +1021,23 @@ class RegExpValidator {
     eatBracedQuantifier(noError) {
         const start = this.index;
         if (this.eat(LEFT_CURLY_BRACKET)) {
-            this._lastMinValue = 0;
-            this._lastMaxValue = Number.POSITIVE_INFINITY;
             if (this.eatDecimalDigits()) {
-                this._lastMinValue = this._lastMaxValue = this._lastIntValue;
+                const min = this._lastIntValue;
+                let max = min;
                 if (this.eat(COMMA)) {
-                    this._lastMaxValue = this.eatDecimalDigits()
+                    max = this.eatDecimalDigits()
                         ? this._lastIntValue
                         : Number.POSITIVE_INFINITY;
                 }
                 if (this.eat(RIGHT_CURLY_BRACKET)) {
-                    if (!noError && this._lastMaxValue < this._lastMinValue) {
+                    if (!noError && max < min) {
                         this.raise("numbers out of order in {} quantifier");
                     }
+                    this._lastRange = { min, max };
                     return true;
                 }
             }
-            if (!noError && (this._uFlag || this.strict)) {
+            if (!noError && (this._unicodeMode || this.strict)) {
                 this.raise("Incomplete quantifier");
             }
             this.rewind(start);
@@ -898,7 +1048,7 @@ class RegExpValidator {
         return (this.consumePatternCharacter() ||
             this.consumeDot() ||
             this.consumeReverseSolidusAtomEscape() ||
-            this.consumeCharacterClass() ||
+            Boolean(this.consumeCharacterClass()) ||
             this.consumeUncapturingGroup() ||
             this.consumeCapturingGroup());
     }
@@ -958,7 +1108,7 @@ class RegExpValidator {
         return (this.consumeDot() ||
             this.consumeReverseSolidusAtomEscape() ||
             this.consumeReverseSolidusFollowedByC() ||
-            this.consumeCharacterClass() ||
+            Boolean(this.consumeCharacterClass()) ||
             this.consumeUncapturingGroup() ||
             this.consumeCapturingGroup() ||
             this.consumeInvalidBracedQuantifier() ||
@@ -1032,7 +1182,7 @@ class RegExpValidator {
             (this._nFlag && this.consumeKGroupName())) {
             return true;
         }
-        if (this.strict || this._uFlag) {
+        if (this.strict || this._unicodeMode) {
             this.raise("Invalid escape");
         }
         return false;
@@ -1045,7 +1195,7 @@ class RegExpValidator {
                 this.onBackreference(start - 1, this.index, n);
                 return true;
             }
-            if (this.strict || this._uFlag) {
+            if (this.strict || this._unicodeMode) {
                 this.raise("Invalid escape");
             }
             this.rewind(start);
@@ -1053,52 +1203,57 @@ class RegExpValidator {
         return false;
     }
     consumeCharacterClassEscape() {
+        var _a;
         const start = this.index;
         if (this.eat(LATIN_SMALL_LETTER_D)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "digit", false);
-            return true;
+            return {};
         }
         if (this.eat(LATIN_CAPITAL_LETTER_D)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "digit", true);
-            return true;
+            return {};
         }
         if (this.eat(LATIN_SMALL_LETTER_S)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "space", false);
-            return true;
+            return {};
         }
         if (this.eat(LATIN_CAPITAL_LETTER_S)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "space", true);
-            return true;
+            return {};
         }
         if (this.eat(LATIN_SMALL_LETTER_W)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "word", false);
-            return true;
+            return {};
         }
         if (this.eat(LATIN_CAPITAL_LETTER_W)) {
             this._lastIntValue = -1;
             this.onEscapeCharacterSet(start - 1, this.index, "word", true);
-            return true;
+            return {};
         }
         let negate = false;
-        if (this._uFlag &&
+        if (this._unicodeMode &&
             this.ecmaVersion >= 2018 &&
             (this.eat(LATIN_SMALL_LETTER_P) ||
                 (negate = this.eat(LATIN_CAPITAL_LETTER_P)))) {
             this._lastIntValue = -1;
+            let result = null;
             if (this.eat(LEFT_CURLY_BRACKET) &&
-                this.eatUnicodePropertyValueExpression() &&
+                (result = this.eatUnicodePropertyValueExpression()) &&
                 this.eat(RIGHT_CURLY_BRACKET)) {
-                this.onUnicodePropertyCharacterSet(start - 1, this.index, "property", this._lastKeyValue, this._lastValValue || null, negate);
-                return true;
+                if (negate && result.strings) {
+                    this.raise("Invalid property name");
+                }
+                this.onUnicodePropertyCharacterSet(start - 1, this.index, "property", result.key, result.value, negate, (_a = result.strings) !== null && _a !== void 0 ? _a : false);
+                return { mayContainStrings: result.strings };
             }
             this.raise("Invalid property name");
         }
-        return false;
+        return null;
     }
     consumeCharacterEscape() {
         const start = this.index;
@@ -1108,7 +1263,7 @@ class RegExpValidator {
             this.eatHexEscapeSequence() ||
             this.eatRegExpUnicodeEscapeSequence() ||
             (!this.strict &&
-                !this._uFlag &&
+                !this._unicodeMode &&
                 this.eatLegacyOctalEscapeSequence()) ||
             this.eatIdentityEscape()) {
             this.onCharacter(start - 1, this.index, this._lastIntValue);
@@ -1133,18 +1288,31 @@ class RegExpValidator {
         const start = this.index;
         if (this.eat(LEFT_SQUARE_BRACKET)) {
             const negate = this.eat(CIRCUMFLEX_ACCENT);
-            this.onCharacterClassEnter(start, negate);
-            this.consumeClassRanges();
+            this.onCharacterClassEnter(start, negate, this._unicodeSetsMode);
+            const result = this.consumeClassContents();
             if (!this.eat(RIGHT_SQUARE_BRACKET)) {
-                this.raise("Unterminated character class");
+                if (this.currentCodePoint === -1) {
+                    this.raise("Unterminated character class");
+                }
+                this.raise("Invalid character in character class");
+            }
+            if (negate && result.mayContainStrings) {
+                this.raise("Negated character class may contain strings");
             }
             this.onCharacterClassLeave(start, this.index, negate);
-            return true;
+            return result;
         }
-        return false;
+        return null;
     }
-    consumeClassRanges() {
-        const strict = this.strict || this._uFlag;
+    consumeClassContents() {
+        if (this._unicodeSetsMode) {
+            if (this.currentCodePoint === RIGHT_SQUARE_BRACKET) {
+                return {};
+            }
+            const result = this.consumeClassSetExpression();
+            return result;
+        }
+        const strict = this.strict || this._unicodeMode;
         for (;;) {
             const rangeStart = this.index;
             if (!this.consumeClassAtom()) {
@@ -1170,6 +1338,7 @@ class RegExpValidator {
             }
             this.onCharacterClassRange(rangeStart, this.index, min, max);
         }
+        return {};
     }
     consumeClassAtom() {
         const start = this.index;
@@ -1192,7 +1361,7 @@ class RegExpValidator {
                 this.onCharacter(start, this.index, this._lastIntValue);
                 return true;
             }
-            if (this.strict || this._uFlag) {
+            if (this.strict || this._unicodeMode) {
                 this.raise("Invalid escape");
             }
             this.rewind(start);
@@ -1206,14 +1375,14 @@ class RegExpValidator {
             this.onCharacter(start - 1, this.index, this._lastIntValue);
             return true;
         }
-        if (this._uFlag && this.eat(HYPHEN_MINUS)) {
+        if (this._unicodeMode && 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._unicodeMode &&
             this.currentCodePoint === LATIN_SMALL_LETTER_C &&
             (isDecimalDigit((cp = this.nextCodePoint)) || cp === LOW_LINE)) {
             this.advance();
@@ -1222,7 +1391,196 @@ class RegExpValidator {
             this.onCharacter(start - 1, this.index, this._lastIntValue);
             return true;
         }
-        return (this.consumeCharacterClassEscape() || this.consumeCharacterEscape());
+        return (Boolean(this.consumeCharacterClassEscape()) ||
+            this.consumeCharacterEscape());
+    }
+    consumeClassSetExpression() {
+        const start = this.index;
+        let mayContainStrings = false;
+        let result = null;
+        if (this.consumeClassSetCharacter()) {
+            if (this.consumeClassSetRangeFromOperator(start)) {
+                this.consumeClassUnionRight({});
+                return {};
+            }
+            mayContainStrings = false;
+        }
+        else if ((result = this.consumeClassSetOperand())) {
+            mayContainStrings = result.mayContainStrings;
+        }
+        else {
+            const cp = this.currentCodePoint;
+            if (cp === REVERSE_SOLIDUS) {
+                this.advance();
+                this.raise("Invalid escape");
+            }
+            if (cp === this.nextCodePoint &&
+                isClassSetReservedDoublePunctuatorCharacter(cp)) {
+                this.raise("Invalid set operation in character class");
+            }
+            this.raise("Invalid character in character class");
+        }
+        if (this.eat2(AMPERSAND, AMPERSAND)) {
+            while (this.currentCodePoint !== AMPERSAND &&
+                (result = this.consumeClassSetOperand())) {
+                this.onClassIntersection(start, this.index);
+                if (!result.mayContainStrings) {
+                    mayContainStrings = false;
+                }
+                if (this.eat2(AMPERSAND, AMPERSAND)) {
+                    continue;
+                }
+                return { mayContainStrings };
+            }
+            this.raise("Invalid character in character class");
+        }
+        if (this.eat2(HYPHEN_MINUS, HYPHEN_MINUS)) {
+            while (this.consumeClassSetOperand()) {
+                this.onClassSubtraction(start, this.index);
+                if (this.eat2(HYPHEN_MINUS, HYPHEN_MINUS)) {
+                    continue;
+                }
+                return { mayContainStrings };
+            }
+            this.raise("Invalid character in character class");
+        }
+        return this.consumeClassUnionRight({ mayContainStrings });
+    }
+    consumeClassUnionRight(leftResult) {
+        let mayContainStrings = leftResult.mayContainStrings;
+        for (;;) {
+            const start = this.index;
+            if (this.consumeClassSetCharacter()) {
+                this.consumeClassSetRangeFromOperator(start);
+                continue;
+            }
+            const result = this.consumeClassSetOperand();
+            if (result) {
+                if (result.mayContainStrings) {
+                    mayContainStrings = true;
+                }
+                continue;
+            }
+            break;
+        }
+        return { mayContainStrings };
+    }
+    consumeClassSetRangeFromOperator(start) {
+        const currentStart = this.index;
+        const min = this._lastIntValue;
+        if (this.eat(HYPHEN_MINUS)) {
+            if (this.consumeClassSetCharacter()) {
+                const max = this._lastIntValue;
+                if (min === -1 || max === -1) {
+                    this.raise("Invalid character class");
+                }
+                if (min > max) {
+                    this.raise("Range out of order in character class");
+                }
+                this.onCharacterClassRange(start, this.index, min, max);
+                return true;
+            }
+            this.rewind(currentStart);
+        }
+        return false;
+    }
+    consumeClassSetOperand() {
+        let result = null;
+        if ((result = this.consumeNestedClass())) {
+            return result;
+        }
+        if ((result = this.consumeClassStringDisjunction())) {
+            return result;
+        }
+        if (this.consumeClassSetCharacter()) {
+            return {};
+        }
+        return null;
+    }
+    consumeNestedClass() {
+        const start = this.index;
+        if (this.eat(LEFT_SQUARE_BRACKET)) {
+            const negate = this.eat(CIRCUMFLEX_ACCENT);
+            this.onCharacterClassEnter(start, negate, true);
+            const result = this.consumeClassContents();
+            if (!this.eat(RIGHT_SQUARE_BRACKET)) {
+                this.raise("Unterminated character class");
+            }
+            if (negate && result.mayContainStrings) {
+                this.raise("Negated character class may contain strings");
+            }
+            this.onCharacterClassLeave(start, this.index, negate);
+            return result;
+        }
+        if (this.eat(REVERSE_SOLIDUS)) {
+            const result = this.consumeCharacterClassEscape();
+            if (result) {
+                return result;
+            }
+            this.rewind(start);
+        }
+        return null;
+    }
+    consumeClassStringDisjunction() {
+        const start = this.index;
+        if (this.eat3(REVERSE_SOLIDUS, LATIN_SMALL_LETTER_Q, LEFT_CURLY_BRACKET)) {
+            this.onClassStringDisjunctionEnter(start);
+            let i = 0;
+            let mayContainStrings = false;
+            do {
+                if (this.consumeClassString(i++).mayContainStrings) {
+                    mayContainStrings = true;
+                }
+            } while (this.eat(VERTICAL_LINE));
+            if (this.eat(RIGHT_CURLY_BRACKET)) {
+                this.onClassStringDisjunctionLeave(start, this.index);
+                return { mayContainStrings };
+            }
+            this.raise("Unterminated class string disjunction");
+        }
+        return null;
+    }
+    consumeClassString(i) {
+        const start = this.index;
+        let count = 0;
+        this.onStringAlternativeEnter(start, i);
+        while (this.currentCodePoint !== -1 &&
+            this.consumeClassSetCharacter()) {
+            count++;
+        }
+        this.onStringAlternativeLeave(start, this.index, i);
+        return { mayContainStrings: count !== 1 };
+    }
+    consumeClassSetCharacter() {
+        const start = this.index;
+        const cp = this.currentCodePoint;
+        if (cp !== this.nextCodePoint ||
+            !isClassSetReservedDoublePunctuatorCharacter(cp)) {
+            if (cp !== -1 && !isClassSetSyntaxCharacter(cp)) {
+                this._lastIntValue = cp;
+                this.advance();
+                this.onCharacter(start, this.index, this._lastIntValue);
+                return true;
+            }
+        }
+        if (this.eat(REVERSE_SOLIDUS)) {
+            if (this.consumeCharacterEscape()) {
+                return true;
+            }
+            if (isClassSetReservedPunctuator(this.currentCodePoint)) {
+                this._lastIntValue = this.currentCodePoint;
+                this.advance();
+                this.onCharacter(start, this.index, this._lastIntValue);
+                return true;
+            }
+            if (this.eat(LATIN_SMALL_LETTER_B)) {
+                this._lastIntValue = BACKSPACE;
+                this.onCharacter(start, this.index, this._lastIntValue);
+                return true;
+            }
+            this.rewind(start);
+        }
+        return false;
     }
     eatGroupName() {
         if (this.eat(LESS_THAN_SIGN)) {
@@ -1245,7 +1603,7 @@ class RegExpValidator {
     }
     eatRegExpIdentifierStart() {
         const start = this.index;
-        const forceUFlag = !this._uFlag && this.ecmaVersion >= 2020;
+        const forceUFlag = !this._unicodeMode && this.ecmaVersion >= 2020;
         let cp = this.currentCodePoint;
         this.advance();
         if (cp === REVERSE_SOLIDUS &&
@@ -1258,7 +1616,7 @@ class RegExpValidator {
             cp = combineSurrogatePair(cp, this.currentCodePoint);
             this.advance();
         }
-        if (isRegExpIdentifierStart(cp)) {
+        if (isIdentifierStartChar(cp)) {
             this._lastIntValue = cp;
             return true;
         }
@@ -1269,7 +1627,7 @@ class RegExpValidator {
     }
     eatRegExpIdentifierPart() {
         const start = this.index;
-        const forceUFlag = !this._uFlag && this.ecmaVersion >= 2020;
+        const forceUFlag = !this._unicodeMode && this.ecmaVersion >= 2020;
         let cp = this.currentCodePoint;
         this.advance();
         if (cp === REVERSE_SOLIDUS &&
@@ -1282,7 +1640,7 @@ class RegExpValidator {
             cp = combineSurrogatePair(cp, this.currentCodePoint);
             this.advance();
         }
-        if (isRegExpIdentifierPart(cp)) {
+        if (isIdentifierPartChar(cp)) {
             this._lastIntValue = cp;
             return true;
         }
@@ -1344,7 +1702,7 @@ class RegExpValidator {
     }
     eatRegExpUnicodeEscapeSequence(forceUFlag = false) {
         const start = this.index;
-        const uFlag = forceUFlag || this._uFlag;
+        const uFlag = forceUFlag || this._unicodeMode;
         if (this.eat(LATIN_SMALL_LETTER_U)) {
             if ((uFlag && this.eatRegExpUnicodeSurrogatePairEscape()) ||
                 this.eatFixedHexDigits(4) ||
@@ -1400,7 +1758,7 @@ class RegExpValidator {
         if (cp === -1) {
             return false;
         }
-        if (this._uFlag) {
+        if (this._unicodeMode) {
             return isSyntaxCharacter(cp) || cp === SOLIDUS;
         }
         if (this.strict) {
@@ -1427,11 +1785,14 @@ class RegExpValidator {
     eatUnicodePropertyValueExpression() {
         const start = this.index;
         if (this.eatUnicodePropertyName() && this.eat(EQUALS_SIGN)) {
-            this._lastKeyValue = this._lastStrValue;
+            const key = this._lastStrValue;
             if (this.eatUnicodePropertyValue()) {
-                this._lastValValue = this._lastStrValue;
-                if (isValidUnicodeProperty(this.ecmaVersion, this._lastKeyValue, this._lastValValue)) {
-                    return true;
+                const value = this._lastStrValue;
+                if (isValidUnicodeProperty(this.ecmaVersion, key, value)) {
+                    return {
+                        key,
+                        value: value || null,
+                    };
                 }
                 this.raise("Invalid property name");
             }
@@ -1440,18 +1801,28 @@ class RegExpValidator {
         if (this.eatLoneUnicodePropertyNameOrValue()) {
             const nameOrValue = this._lastStrValue;
             if (isValidUnicodeProperty(this.ecmaVersion, "General_Category", nameOrValue)) {
-                this._lastKeyValue = "General_Category";
-                this._lastValValue = nameOrValue;
-                return true;
+                return {
+                    key: "General_Category",
+                    value: nameOrValue || null,
+                };
             }
             if (isValidLoneUnicodeProperty(this.ecmaVersion, nameOrValue)) {
-                this._lastKeyValue = nameOrValue;
-                this._lastValValue = "";
-                return true;
+                return {
+                    key: nameOrValue,
+                    value: null,
+                };
+            }
+            if (this._unicodeSetsMode &&
+                isValidLoneUnicodePropertyOfString(this.ecmaVersion, nameOrValue)) {
+                return {
+                    key: nameOrValue,
+                    value: null,
+                    strings: true,
+                };
             }
             this.raise("Invalid property name");
         }
-        return false;
+        return null;
     }
     eatUnicodePropertyName() {
         this._lastStrValue = "";
@@ -1478,7 +1849,7 @@ class RegExpValidator {
             if (this.eatFixedHexDigits(2)) {
                 return true;
             }
-            if (this._uFlag || this.strict) {
+            if (this._unicodeMode || this.strict) {
                 this.raise("Invalid escape");
             }
             this.rewind(start);
@@ -1553,16 +1924,24 @@ class RegExpValidator {
 const DUMMY_PATTERN = {};
 const DUMMY_FLAGS = {};
 const DUMMY_CAPTURING_GROUP = {};
+function isClassSetOperand(node) {
+    return (node.type === "Character" ||
+        node.type === "CharacterSet" ||
+        node.type === "CharacterClass" ||
+        node.type === "ExpressionCharacterClass" ||
+        node.type === "ClassStringDisjunction");
+}
 class RegExpParserState {
     constructor(options) {
         var _a;
         this._node = DUMMY_PATTERN;
+        this._expressionBuffer = null;
         this._flags = DUMMY_FLAGS;
         this._backreferences = [];
         this._capturingGroups = [];
         this.source = "";
         this.strict = Boolean(options === null || options === void 0 ? void 0 : options.strict);
-        this.ecmaVersion = (_a = options === null || options === void 0 ? void 0 : options.ecmaVersion) !== null && _a !== void 0 ? _a : 2023;
+        this.ecmaVersion = (_a = options === null || options === void 0 ? void 0 : options.ecmaVersion) !== null && _a !== void 0 ? _a : latestEcmaVersion;
     }
     get pattern() {
         if (this._node.type !== "Pattern") {
@@ -1576,7 +1955,7 @@ class RegExpParserState {
         }
         return this._flags;
     }
-    onRegExpFlags(start, end, { global, ignoreCase, multiline, unicode, sticky, dotAll, hasIndices, }) {
+    onRegExpFlags(start, end, { global, ignoreCase, multiline, unicode, sticky, dotAll, hasIndices, unicodeSets, }) {
         this._flags = {
             type: "Flags",
             parent: null,
@@ -1590,6 +1969,7 @@ class RegExpParserState {
             sticky,
             dotAll,
             hasIndices,
+            unicodeSets,
         };
     }
     onPatternEnter(start) {
@@ -1804,26 +2184,33 @@ class RegExpParserState {
             negate,
         });
     }
-    onUnicodePropertyCharacterSet(start, end, kind, key, value, negate) {
+    onUnicodePropertyCharacterSet(start, end, kind, key, value, negate, strings) {
         const parent = this._node;
-        if (parent.type !== "Alternative" && parent.type !== "CharacterClass") {
+        if ((parent.type !== "Alternative" &&
+            parent.type !== "CharacterClass") ||
+            (strings && (negate || value))) {
             throw new Error("UnknownError");
         }
-        parent.elements.push({
+        const base = {
             type: "CharacterSet",
             parent,
             start,
             end,
             raw: this.source.slice(start, end),
             kind,
+            strings,
             key,
-            value,
-            negate,
-        });
+        };
+        const node = strings
+            ? Object.assign(Object.assign({}, base), { value: null, negate: false, strings: true }) : Object.assign(Object.assign({}, base), { value,
+            negate, strings: false });
+        parent.elements.push(node);
     }
     onCharacter(start, end, value) {
         const parent = this._node;
-        if (parent.type !== "Alternative" && parent.type !== "CharacterClass") {
+        if (parent.type !== "Alternative" &&
+            parent.type !== "CharacterClass" &&
+            parent.type !== "StringAlternative") {
             throw new Error("UnknownError");
         }
         parent.elements.push({
@@ -1852,31 +2239,66 @@ class RegExpParserState {
         parent.elements.push(node);
         this._backreferences.push(node);
     }
-    onCharacterClassEnter(start, negate) {
+    onCharacterClassEnter(start, negate, unicodeSets) {
         const parent = this._node;
-        if (parent.type !== "Alternative") {
-            throw new Error("UnknownError");
-        }
-        this._node = {
+        const base = {
             type: "CharacterClass",
             parent,
             start,
             end: start,
             raw: "",
+            unicodeSets,
             negate,
             elements: [],
         };
-        parent.elements.push(this._node);
+        if (parent.type === "Alternative") {
+            const node = Object.assign(Object.assign({}, base), { parent });
+            this._node = node;
+            parent.elements.push(node);
+        }
+        else if (parent.type === "CharacterClass" &&
+            parent.unicodeSets &&
+            unicodeSets) {
+            const node = Object.assign(Object.assign({}, base), { parent,
+                unicodeSets });
+            this._node = node;
+            parent.elements.push(node);
+        }
+        else {
+            throw new Error("UnknownError");
+        }
     }
     onCharacterClassLeave(start, end) {
         const node = this._node;
         if (node.type !== "CharacterClass" ||
-            node.parent.type !== "Alternative") {
+            (node.parent.type !== "Alternative" &&
+                node.parent.type !== "CharacterClass") ||
+            (this._expressionBuffer && node.elements.length > 0)) {
             throw new Error("UnknownError");
         }
+        const parent = node.parent;
         node.end = end;
         node.raw = this.source.slice(start, end);
-        this._node = node.parent;
+        this._node = parent;
+        const expression = this._expressionBuffer;
+        this._expressionBuffer = null;
+        if (!expression) {
+            return;
+        }
+        const newNode = {
+            type: "ExpressionCharacterClass",
+            parent,
+            start: node.start,
+            end: node.end,
+            raw: node.raw,
+            negate: node.negate,
+            expression,
+        };
+        expression.parent = newNode;
+        if (node !== parent.elements.pop()) {
+            throw new Error("UnknownError");
+        }
+        parent.elements.push(newNode);
     }
     onCharacterClassRange(start, end) {
         const parent = this._node;
@@ -1885,15 +2307,19 @@ class RegExpParserState {
         }
         const elements = parent.elements;
         const max = elements.pop();
-        const hyphen = elements.pop();
+        if (!max || max.type !== "Character") {
+            throw new Error("UnknownError");
+        }
+        if (!parent.unicodeSets) {
+            const hyphen = elements.pop();
+            if (!hyphen ||
+                hyphen.type !== "Character" ||
+                hyphen.value !== HYPHEN_MINUS) {
+                throw new Error("UnknownError");
+            }
+        }
         const min = elements.pop();
-        if (!min ||
-            !max ||
-            !hyphen ||
-            min.type !== "Character" ||
-            max.type !== "Character" ||
-            hyphen.type !== "Character" ||
-            hyphen.value !== HYPHEN_MINUS) {
+        if (!min || min.type !== "Character") {
             throw new Error("UnknownError");
         }
         const node = {
@@ -1909,6 +2335,111 @@ class RegExpParserState {
         max.parent = node;
         elements.push(node);
     }
+    onClassIntersection(start, end) {
+        var _a;
+        const parent = this._node;
+        if (parent.type !== "CharacterClass" || !parent.unicodeSets) {
+            throw new Error("UnknownError");
+        }
+        const right = parent.elements.pop();
+        const left = (_a = this._expressionBuffer) !== null && _a !== void 0 ? _a : parent.elements.pop();
+        if (!left ||
+            !right ||
+            left.type === "ClassSubtraction" ||
+            (left.type !== "ClassIntersection" && !isClassSetOperand(left)) ||
+            !isClassSetOperand(right)) {
+            throw new Error("UnknownError");
+        }
+        const node = {
+            type: "ClassIntersection",
+            parent: parent,
+            start,
+            end,
+            raw: this.source.slice(start, end),
+            left,
+            right,
+        };
+        left.parent = node;
+        right.parent = node;
+        this._expressionBuffer = node;
+    }
+    onClassSubtraction(start, end) {
+        var _a;
+        const parent = this._node;
+        if (parent.type !== "CharacterClass" || !parent.unicodeSets) {
+            throw new Error("UnknownError");
+        }
+        const right = parent.elements.pop();
+        const left = (_a = this._expressionBuffer) !== null && _a !== void 0 ? _a : parent.elements.pop();
+        if (!left ||
+            !right ||
+            left.type === "ClassIntersection" ||
+            (left.type !== "ClassSubtraction" && !isClassSetOperand(left)) ||
+            !isClassSetOperand(right)) {
+            throw new Error("UnknownError");
+        }
+        const node = {
+            type: "ClassSubtraction",
+            parent: parent,
+            start,
+            end,
+            raw: this.source.slice(start, end),
+            left,
+            right,
+        };
+        left.parent = node;
+        right.parent = node;
+        this._expressionBuffer = node;
+    }
+    onClassStringDisjunctionEnter(start) {
+        const parent = this._node;
+        if (parent.type !== "CharacterClass" || !parent.unicodeSets) {
+            throw new Error("UnknownError");
+        }
+        this._node = {
+            type: "ClassStringDisjunction",
+            parent,
+            start,
+            end: start,
+            raw: "",
+            alternatives: [],
+        };
+        parent.elements.push(this._node);
+    }
+    onClassStringDisjunctionLeave(start, end) {
+        const node = this._node;
+        if (node.type !== "ClassStringDisjunction" ||
+            node.parent.type !== "CharacterClass") {
+            throw new Error("UnknownError");
+        }
+        node.end = end;
+        node.raw = this.source.slice(start, end);
+        this._node = node.parent;
+    }
+    onStringAlternativeEnter(start) {
+        const parent = this._node;
+        if (parent.type !== "ClassStringDisjunction") {
+            throw new Error("UnknownError");
+        }
+        this._node = {
+            type: "StringAlternative",
+            parent,
+            start,
+            end: start,
+            raw: "",
+            elements: [],
+        };
+        parent.alternatives.push(this._node);
+    }
+    onStringAlternativeLeave(start, end) {
+        const node = this._node;
+        if (node.type !== "StringAlternative") {
+            throw new Error("UnknownError");
+        }
+        node.end = end;
+        node.raw = this.source.slice(start, end);
+        this._node = node.parent;
+    }
 }
 class RegExpParser {
     constructor(options) {
@@ -1938,9 +2469,9 @@ class RegExpParser {
         this._validator.validateFlags(source, start, end);
         return this._state.flags;
     }
-    parsePattern(source, start = 0, end = source.length, uFlag = false) {
+    parsePattern(source, start = 0, end = source.length, uFlagOrFlags = undefined) {
         this._state.source = source;
-        this._validator.validatePattern(source, start, end, uFlag);
+        this._validator.validatePattern(source, start, end, uFlagOrFlags);
         return this._state.pattern;
     }
 }
@@ -1975,6 +2506,18 @@ class RegExpVisitor {
             case "CharacterSet":
                 this.visitCharacterSet(node);
                 break;
+            case "ClassIntersection":
+                this.visitClassIntersection(node);
+                break;
+            case "ClassStringDisjunction":
+                this.visitClassStringDisjunction(node);
+                break;
+            case "ClassSubtraction":
+                this.visitClassSubtraction(node);
+                break;
+            case "ExpressionCharacterClass":
+                this.visitExpressionCharacterClass(node);
+                break;
             case "Flags":
                 this.visitFlags(node);
                 break;
@@ -1990,6 +2533,9 @@ class RegExpVisitor {
             case "RegExpLiteral":
                 this.visitRegExpLiteral(node);
                 break;
+            case "StringAlternative":
+                this.visitStringAlternative(node);
+                break;
             default:
                 throw new Error(`Unknown type: ${node.type}`);
         }
@@ -2066,6 +2612,44 @@ class RegExpVisitor {
             this._handlers.onCharacterSetLeave(node);
         }
     }
+    visitClassIntersection(node) {
+        if (this._handlers.onClassIntersectionEnter) {
+            this._handlers.onClassIntersectionEnter(node);
+        }
+        this.visit(node.left);
+        this.visit(node.right);
+        if (this._handlers.onClassIntersectionLeave) {
+            this._handlers.onClassIntersectionLeave(node);
+        }
+    }
+    visitClassStringDisjunction(node) {
+        if (this._handlers.onClassStringDisjunctionEnter) {
+            this._handlers.onClassStringDisjunctionEnter(node);
+        }
+        node.alternatives.forEach(this.visit, this);
+        if (this._handlers.onClassStringDisjunctionLeave) {
+            this._handlers.onClassStringDisjunctionLeave(node);
+        }
+    }
+    visitClassSubtraction(node) {
+        if (this._handlers.onClassSubtractionEnter) {
+            this._handlers.onClassSubtractionEnter(node);
+        }
+        this.visit(node.left);
+        this.visit(node.right);
+        if (this._handlers.onClassSubtractionLeave) {
+            this._handlers.onClassSubtractionLeave(node);
+        }
+    }
+    visitExpressionCharacterClass(node) {
+        if (this._handlers.onExpressionCharacterClassEnter) {
+            this._handlers.onExpressionCharacterClassEnter(node);
+        }
+        this.visit(node.expression);
+        if (this._handlers.onExpressionCharacterClassLeave) {
+            this._handlers.onExpressionCharacterClassLeave(node);
+        }
+    }
     visitFlags(node) {
         if (this._handlers.onFlagsEnter) {
             this._handlers.onFlagsEnter(node);
@@ -2111,6 +2695,15 @@ class RegExpVisitor {
             this._handlers.onRegExpLiteralLeave(node);
         }
     }
+    visitStringAlternative(node) {
+        if (this._handlers.onStringAlternativeEnter) {
+            this._handlers.onStringAlternativeEnter(node);
+        }
+        node.elements.forEach(this.visit, this);
+        if (this._handlers.onStringAlternativeLeave) {
+            this._handlers.onStringAlternativeLeave(node);
+        }
+    }
 }
 
 function parseRegExpLiteral(source, options) {