eslint-linter-browserify 8.45.0 → 8.46.0

package/linter.cjs

@@ -6823,7 +6823,7 @@ function requireEslintScope () {
 
 	/* vim: set sw=4 ts=4 et tw=80 : */
 
-	const version = "7.2.0";
+	const version = "7.2.2";
 
 	/*
 	  Copyright (C) 2012-2014 Yusuke Suzuki <utatane.tea@gmail.com>
@@ -14140,7 +14140,6 @@ function requireEspree () {
 	 * @fileoverview Translates tokens between Acorn format and Esprima format.
 	 * @author Nicholas C. Zakas
 	 */
-	/* eslint no-underscore-dangle: 0 */
 
 	//------------------------------------------------------------------------------
 	// Requirements
@@ -14318,8 +14317,7 @@ function requireEspree () {
 	     */
 	    onToken(token, extra) {
 
-	        const that = this,
-	            tt = this._acornTokTypes,
+	        const tt = this._acornTokTypes,
 	            tokens = extra.tokens,
 	            templateTokens = this._tokens;
 
@@ -14329,10 +14327,10 @@ function requireEspree () {
 	         * @returns {void}
 	         * @private
 	         */
-	        function translateTemplateTokens() {
-	            tokens.push(convertTemplatePart(that._tokens, that._code));
-	            that._tokens = [];
-	        }
+	        const translateTemplateTokens = () => {
+	            tokens.push(convertTemplatePart(this._tokens, this._code));
+	            this._tokens = [];
+	        };
 
 	        if (token.type === tt.eof) {
 
@@ -14520,7 +14518,7 @@ function requireEspree () {
 	    });
 	}
 
-	/* eslint-disable no-param-reassign*/
+	/* eslint no-param-reassign: 0 -- stylistic choice */
 
 
 	const STATE = Symbol("espree's internal state");
@@ -14629,7 +14627,7 @@ function requireEspree () {
 	                allowReturnOutsideFunction: options.allowReturnOutsideFunction,
 
 	                // Collect tokens
-	                onToken: token => {
+	                onToken(token) {
 	                    if (tokenTranslator) {
 
 	                        // Use `tokens`, `ecmaVersion`, and `jsxAttrValueToken` in the state.
@@ -14641,7 +14639,7 @@ function requireEspree () {
 	                },
 
 	                // Collect comments
-	                onComment: (block, text, start, end, startLoc, endLoc) => {
+	                onComment(block, text, start, end, startLoc, endLoc) {
 	                    if (state.comments) {
 	                        const comment = convertAcornCommentToEsprimaComment(block, text, start, end, startLoc, endLoc, code);
 
@@ -14834,7 +14832,7 @@ function requireEspree () {
 	        * on extra so that when tokens are converted, the next token will be switched
 	        * to JSXText via onToken.
 	        */
-	        jsx_readString(quote) { // eslint-disable-line camelcase
+	        jsx_readString(quote) { // eslint-disable-line camelcase -- required by API
 	            const result = super.jsx_readString(quote);
 
 	            if (this.type === tokTypes.string) {
@@ -14867,64 +14865,9 @@ function requireEspree () {
 	    };
 	};
 
-	const version$1 = "9.6.0";
+	const version$1 = "9.6.1";
 
-	/**
-	 * @fileoverview Main Espree file that converts Acorn into Esprima output.
-	 *
-	 * This file contains code from the following MIT-licensed projects:
-	 * 1. Acorn
-	 * 2. Babylon
-	 * 3. Babel-ESLint
-	 *
-	 * This file also contains code from Esprima, which is BSD licensed.
-	 *
-	 * Acorn is Copyright 2012-2015 Acorn Contributors (https://github.com/marijnh/acorn/blob/master/AUTHORS)
-	 * Babylon is Copyright 2014-2015 various contributors (https://github.com/babel/babel/blob/master/packages/babylon/AUTHORS)
-	 * Babel-ESLint is Copyright 2014-2015 Sebastian McKenzie <sebmck@gmail.com>
-	 *
-	 * Redistribution and use in source and binary forms, with or without
-	 * modification, are permitted provided that the following conditions are met:
-	 *
-	 * * Redistributions of source code must retain the above copyright
-	 *   notice, this list of conditions and the following disclaimer.
-	 * * Redistributions in binary form must reproduce the above copyright
-	 *   notice, this list of conditions and the following disclaimer in the
-	 *   documentation and/or other materials provided with the distribution.
-	 *
-	 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-	 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-	 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-	 * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-	 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-	 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-	 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-	 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-	 *
-	 * Esprima is Copyright (c) jQuery Foundation, Inc. and Contributors, All Rights Reserved.
-	 *
-	 * Redistribution and use in source and binary forms, with or without
-	 * modification, are permitted provided that the following conditions are met:
-	 *
-	 *   * Redistributions of source code must retain the above copyright
-	 *     notice, this list of conditions and the following disclaimer.
-	 *   * Redistributions in binary form must reproduce the above copyright
-	 *     notice, this list of conditions and the following disclaimer in the
-	 *     documentation and/or other materials provided with the distribution.
-	 *
-	 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-	 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-	 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-	 * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-	 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-	 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-	 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-	 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-	 */
+	/* eslint-disable jsdoc/no-multi-asterisks -- needed to preserve original formatting of licences */
 
 
 	// To initialize lazily.
@@ -14974,7 +14917,7 @@ function requireEspree () {
 
 	    // Ensure to collect tokens.
 	    if (!options || options.tokens !== true) {
-	        options = Object.assign({}, options, { tokens: true }); // eslint-disable-line no-param-reassign
+	        options = Object.assign({}, options, { tokens: true }); // eslint-disable-line no-param-reassign -- stylistic choice
 	    }
 
 	    return new Parser(options, code).tokenize();
@@ -17038,7 +16981,7 @@ function requireLodash_merge () {
 }
 
 var name$1 = "eslint";
-var version$1 = "8.45.0";
+var version$1 = "8.46.0";
 var author = "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>";
 var description$3 = "An AST-based pattern checker for JavaScript.";
 var bin = {
@@ -17086,21 +17029,21 @@ var homepage$1 = "https://eslint.org";
 var bugs = "https://github.com/eslint/eslint/issues/";
 var dependencies$3 = {
 	"@eslint-community/eslint-utils": "^4.2.0",
-	"@eslint-community/regexpp": "^4.4.0",
-	"@eslint/eslintrc": "^2.1.0",
-	"@eslint/js": "8.44.0",
+	"@eslint-community/regexpp": "^4.6.1",
+	"@eslint/eslintrc": "^2.1.1",
+	"@eslint/js": "^8.46.0",
 	"@humanwhocodes/config-array": "^0.11.10",
 	"@humanwhocodes/module-importer": "^1.0.1",
 	"@nodelib/fs.walk": "^1.2.8",
-	ajv: "^6.10.0",
+	ajv: "^6.12.4",
 	chalk: "^4.0.0",
 	"cross-spawn": "^7.0.2",
 	debug: "^4.3.2",
 	doctrine: "^3.0.0",
 	"escape-string-regexp": "^4.0.0",
-	"eslint-scope": "^7.2.0",
-	"eslint-visitor-keys": "^3.4.1",
-	espree: "^9.6.0",
+	"eslint-scope": "^7.2.2",
+	"eslint-visitor-keys": "^3.4.2",
+	espree: "^9.6.1",
 	esquery: "^1.4.2",
 	esutils: "^2.0.2",
 	"fast-deep-equal": "^3.1.3",
@@ -77778,6 +77721,8 @@ function requireRegexpp () {
 	    __proto__: null
 	});
 
+	const latestEcmaVersion = 2024;
+
 	let largeIdStartRanges = undefined;
 	let largeIdContinueRanges = undefined;
 	function isIdStart(cp) {
@@ -77844,13 +77789,14 @@ function requireRegexpp () {
 	}
 
 	class DataSet {
-	    constructor(raw2018, raw2019, raw2020, raw2021, raw2022, raw2023) {
+	    constructor(raw2018, raw2019, raw2020, raw2021, raw2022, raw2023, raw2024) {
 	        this._raw2018 = raw2018;
 	        this._raw2019 = raw2019;
 	        this._raw2020 = raw2020;
 	        this._raw2021 = raw2021;
 	        this._raw2022 = raw2022;
 	        this._raw2023 = raw2023;
+	        this._raw2024 = raw2024;
 	    }
 	    get es2018() {
 	        var _a;
@@ -77876,12 +77822,16 @@ function requireRegexpp () {
 	        var _a;
 	        return ((_a = this._set2023) !== null && _a !== void 0 ? _a : (this._set2023 = new Set(this._raw2023.split(" "))));
 	    }
+	    get es2024() {
+	        var _a;
+	        return ((_a = this._set2024) !== null && _a !== void 0 ? _a : (this._set2024 = new Set(this._raw2024.split(" "))));
+	    }
 	}
 	const gcNameSet = new Set(["General_Category", "gc"]);
 	const scNameSet = new Set(["Script", "Script_Extensions", "sc", "scx"]);
-	const gcValueSets = new DataSet("C Cased_Letter Cc Cf Close_Punctuation Cn Co Combining_Mark Connector_Punctuation Control Cs Currency_Symbol Dash_Punctuation Decimal_Number Enclosing_Mark Final_Punctuation Format Initial_Punctuation L LC Letter Letter_Number Line_Separator Ll Lm Lo Lowercase_Letter Lt Lu M Mark Math_Symbol Mc Me Mn Modifier_Letter Modifier_Symbol N Nd Nl No Nonspacing_Mark Number Open_Punctuation Other Other_Letter Other_Number Other_Punctuation Other_Symbol P Paragraph_Separator Pc Pd Pe Pf Pi Po Private_Use Ps Punctuation S Sc Separator Sk Sm So Space_Separator Spacing_Mark Surrogate Symbol Titlecase_Letter Unassigned Uppercase_Letter Z Zl Zp Zs cntrl digit punct", "", "", "", "", "");
-	const scValueSets = new DataSet("Adlam Adlm Aghb Ahom Anatolian_Hieroglyphs Arab Arabic Armenian Armi Armn Avestan Avst Bali Balinese Bamu Bamum Bass Bassa_Vah Batak Batk Beng Bengali Bhaiksuki Bhks Bopo Bopomofo Brah Brahmi Brai Braille Bugi Buginese Buhd Buhid Cakm Canadian_Aboriginal Cans Cari Carian Caucasian_Albanian Chakma Cham Cher Cherokee Common Copt Coptic Cprt Cuneiform Cypriot Cyrillic Cyrl Deseret Deva Devanagari Dsrt Dupl Duployan Egyp Egyptian_Hieroglyphs Elba Elbasan Ethi Ethiopic Geor Georgian Glag Glagolitic Gonm Goth Gothic Gran Grantha Greek Grek Gujarati Gujr Gurmukhi Guru Han Hang Hangul Hani Hano Hanunoo Hatr Hatran Hebr Hebrew Hira Hiragana Hluw Hmng Hung Imperial_Aramaic Inherited Inscriptional_Pahlavi Inscriptional_Parthian Ital Java Javanese Kaithi Kali Kana Kannada Katakana Kayah_Li Khar Kharoshthi Khmer Khmr Khoj Khojki Khudawadi Knda Kthi Lana Lao Laoo Latin Latn Lepc Lepcha Limb Limbu Lina Linb Linear_A Linear_B Lisu Lyci Lycian Lydi Lydian Mahajani Mahj Malayalam Mand Mandaic Mani Manichaean Marc Marchen Masaram_Gondi Meetei_Mayek Mend Mende_Kikakui Merc Mero Meroitic_Cursive Meroitic_Hieroglyphs Miao Mlym Modi Mong Mongolian Mro Mroo Mtei Mult Multani Myanmar Mymr Nabataean Narb Nbat New_Tai_Lue Newa Nko Nkoo Nshu Nushu Ogam Ogham Ol_Chiki Olck Old_Hungarian Old_Italic Old_North_Arabian Old_Permic Old_Persian Old_South_Arabian Old_Turkic Oriya Orkh Orya Osage Osge Osma Osmanya Pahawh_Hmong Palm Palmyrene Pau_Cin_Hau Pauc Perm Phag Phags_Pa Phli Phlp Phnx Phoenician Plrd Prti Psalter_Pahlavi Qaac Qaai Rejang Rjng Runic Runr Samaritan Samr Sarb Saur Saurashtra Sgnw Sharada Shavian Shaw Shrd Sidd Siddham SignWriting Sind Sinh Sinhala Sora Sora_Sompeng Soyo Soyombo Sund Sundanese Sylo Syloti_Nagri Syrc Syriac Tagalog Tagb Tagbanwa Tai_Le Tai_Tham Tai_Viet Takr Takri Tale Talu Tamil Taml Tang Tangut Tavt Telu Telugu Tfng Tglg Thaa Thaana Thai Tibetan Tibt Tifinagh Tirh Tirhuta Ugar Ugaritic Vai Vaii Wara Warang_Citi Xpeo Xsux Yi Yiii Zanabazar_Square Zanb Zinh Zyyy", "Dogr Dogra Gong Gunjala_Gondi Hanifi_Rohingya Maka Makasar Medefaidrin Medf Old_Sogdian Rohg Sogd Sogdian Sogo", "Elym Elymaic Hmnp Nand Nandinagari Nyiakeng_Puachue_Hmong Wancho Wcho", "Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi", "Cpmn Cypro_Minoan Old_Uyghur Ougr Tangsa Tnsa Toto Vith Vithkuqi", "");
-	const binPropertySets = new DataSet("AHex ASCII ASCII_Hex_Digit Alpha Alphabetic Any Assigned Bidi_C Bidi_Control Bidi_M Bidi_Mirrored CI CWCF CWCM CWKCF CWL CWT CWU Case_Ignorable Cased Changes_When_Casefolded Changes_When_Casemapped Changes_When_Lowercased Changes_When_NFKC_Casefolded Changes_When_Titlecased Changes_When_Uppercased DI Dash Default_Ignorable_Code_Point Dep Deprecated Dia Diacritic Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Ext Extender Gr_Base Gr_Ext Grapheme_Base Grapheme_Extend Hex Hex_Digit IDC IDS IDSB IDST IDS_Binary_Operator IDS_Trinary_Operator ID_Continue ID_Start Ideo Ideographic Join_C Join_Control LOE Logical_Order_Exception Lower Lowercase Math NChar Noncharacter_Code_Point Pat_Syn Pat_WS Pattern_Syntax Pattern_White_Space QMark Quotation_Mark RI Radical Regional_Indicator SD STerm Sentence_Terminal Soft_Dotted Term Terminal_Punctuation UIdeo Unified_Ideograph Upper Uppercase VS Variation_Selector White_Space XIDC XIDS XID_Continue XID_Start space", "Extended_Pictographic", "", "EBase EComp EMod EPres ExtPict", "", "");
+	const gcValueSets = new DataSet("C Cased_Letter Cc Cf Close_Punctuation Cn Co Combining_Mark Connector_Punctuation Control Cs Currency_Symbol Dash_Punctuation Decimal_Number Enclosing_Mark Final_Punctuation Format Initial_Punctuation L LC Letter Letter_Number Line_Separator Ll Lm Lo Lowercase_Letter Lt Lu M Mark Math_Symbol Mc Me Mn Modifier_Letter Modifier_Symbol N Nd Nl No Nonspacing_Mark Number Open_Punctuation Other Other_Letter Other_Number Other_Punctuation Other_Symbol P Paragraph_Separator Pc Pd Pe Pf Pi Po Private_Use Ps Punctuation S Sc Separator Sk Sm So Space_Separator Spacing_Mark Surrogate Symbol Titlecase_Letter Unassigned Uppercase_Letter Z Zl Zp Zs cntrl digit punct", "", "", "", "", "", "");
+	const scValueSets = new DataSet("Adlam Adlm Aghb Ahom Anatolian_Hieroglyphs Arab Arabic Armenian Armi Armn Avestan Avst Bali Balinese Bamu Bamum Bass Bassa_Vah Batak Batk Beng Bengali Bhaiksuki Bhks Bopo Bopomofo Brah Brahmi Brai Braille Bugi Buginese Buhd Buhid Cakm Canadian_Aboriginal Cans Cari Carian Caucasian_Albanian Chakma Cham Cher Cherokee Common Copt Coptic Cprt Cuneiform Cypriot Cyrillic Cyrl Deseret Deva Devanagari Dsrt Dupl Duployan Egyp Egyptian_Hieroglyphs Elba Elbasan Ethi Ethiopic Geor Georgian Glag Glagolitic Gonm Goth Gothic Gran Grantha Greek Grek Gujarati Gujr Gurmukhi Guru Han Hang Hangul Hani Hano Hanunoo Hatr Hatran Hebr Hebrew Hira Hiragana Hluw Hmng Hung Imperial_Aramaic Inherited Inscriptional_Pahlavi Inscriptional_Parthian Ital Java Javanese Kaithi Kali Kana Kannada Katakana Kayah_Li Khar Kharoshthi Khmer Khmr Khoj Khojki Khudawadi Knda Kthi Lana Lao Laoo Latin Latn Lepc Lepcha Limb Limbu Lina Linb Linear_A Linear_B Lisu Lyci Lycian Lydi Lydian Mahajani Mahj Malayalam Mand Mandaic Mani Manichaean Marc Marchen Masaram_Gondi Meetei_Mayek Mend Mende_Kikakui Merc Mero Meroitic_Cursive Meroitic_Hieroglyphs Miao Mlym Modi Mong Mongolian Mro Mroo Mtei Mult Multani Myanmar Mymr Nabataean Narb Nbat New_Tai_Lue Newa Nko Nkoo Nshu Nushu Ogam Ogham Ol_Chiki Olck Old_Hungarian Old_Italic Old_North_Arabian Old_Permic Old_Persian Old_South_Arabian Old_Turkic Oriya Orkh Orya Osage Osge Osma Osmanya Pahawh_Hmong Palm Palmyrene Pau_Cin_Hau Pauc Perm Phag Phags_Pa Phli Phlp Phnx Phoenician Plrd Prti Psalter_Pahlavi Qaac Qaai Rejang Rjng Runic Runr Samaritan Samr Sarb Saur Saurashtra Sgnw Sharada Shavian Shaw Shrd Sidd Siddham SignWriting Sind Sinh Sinhala Sora Sora_Sompeng Soyo Soyombo Sund Sundanese Sylo Syloti_Nagri Syrc Syriac Tagalog Tagb Tagbanwa Tai_Le Tai_Tham Tai_Viet Takr Takri Tale Talu Tamil Taml Tang Tangut Tavt Telu Telugu Tfng Tglg Thaa Thaana Thai Tibetan Tibt Tifinagh Tirh Tirhuta Ugar Ugaritic Vai Vaii Wara Warang_Citi Xpeo Xsux Yi Yiii Zanabazar_Square Zanb Zinh Zyyy", "Dogr Dogra Gong Gunjala_Gondi Hanifi_Rohingya Maka Makasar Medefaidrin Medf Old_Sogdian Rohg Sogd Sogdian Sogo", "Elym Elymaic Hmnp Nand Nandinagari Nyiakeng_Puachue_Hmong Wancho Wcho", "Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi", "Cpmn Cypro_Minoan Old_Uyghur Ougr Tangsa Tnsa Toto Vith Vithkuqi", "Hrkt Katakana_Or_Hiragana Kawi Nag_Mundari Nagm Unknown Zzzz", "");
+	const binPropertySets = new DataSet("AHex ASCII ASCII_Hex_Digit Alpha Alphabetic Any Assigned Bidi_C Bidi_Control Bidi_M Bidi_Mirrored CI CWCF CWCM CWKCF CWL CWT CWU Case_Ignorable Cased Changes_When_Casefolded Changes_When_Casemapped Changes_When_Lowercased Changes_When_NFKC_Casefolded Changes_When_Titlecased Changes_When_Uppercased DI Dash Default_Ignorable_Code_Point Dep Deprecated Dia Diacritic Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Ext Extender Gr_Base Gr_Ext Grapheme_Base Grapheme_Extend Hex Hex_Digit IDC IDS IDSB IDST IDS_Binary_Operator IDS_Trinary_Operator ID_Continue ID_Start Ideo Ideographic Join_C Join_Control LOE Logical_Order_Exception Lower Lowercase Math NChar Noncharacter_Code_Point Pat_Syn Pat_WS Pattern_Syntax Pattern_White_Space QMark Quotation_Mark RI Radical Regional_Indicator SD STerm Sentence_Terminal Soft_Dotted Term Terminal_Punctuation UIdeo Unified_Ideograph Upper Uppercase VS Variation_Selector White_Space XIDC XIDS XID_Continue XID_Start space", "Extended_Pictographic", "", "EBase EComp EMod EPres ExtPict", "", "", "");
 	function isValidUnicodeProperty(version, name, value) {
 	    if (gcNameSet.has(name)) {
 	        return version >= 2018 && gcValueSets.es2018.has(value);
@@ -77891,7 +77841,8 @@ function requireRegexpp () {
 	            (version >= 2019 && scValueSets.es2019.has(value)) ||
 	            (version >= 2020 && scValueSets.es2020.has(value)) ||
 	            (version >= 2021 && scValueSets.es2021.has(value)) ||
-	            (version >= 2022 && scValueSets.es2022.has(value)));
+	            (version >= 2022 && scValueSets.es2022.has(value)) ||
+	            (version >= 2023 && scValueSets.es2023.has(value)));
 	    }
 	    return false;
 	}
@@ -77908,7 +77859,10 @@ function requireRegexpp () {
 	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;
@@ -77922,10 +77876,12 @@ function requireRegexpp () {
 	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;
@@ -77946,6 +77902,7 @@ function requireRegexpp () {
 	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;
@@ -77959,9 +77916,11 @@ function requireRegexpp () {
 	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;
@@ -78116,41 +78075,120 @@ function requireRegexpp () {
 	}
 
 	class RegExpSyntaxError extends SyntaxError {
-	    constructor(source, uFlag, index, message) {
-	        if (source) {
-	            if (!source.startsWith("/")) {
-	                source = `/${source}/${uFlag ? "u" : ""}`;
+	    constructor(srcCtx, flags, index, message) {
+	        let source = "";
+	        if (srcCtx.kind === "literal") {
+	            const literal = srcCtx.source.slice(srcCtx.start, srcCtx.end);
+	            if (literal) {
+	                source = `: ${literal}`;
 	            }
-	            source = `: ${source}`;
+	        }
+	        else if (srcCtx.kind === "pattern") {
+	            const pattern = srcCtx.source.slice(srcCtx.start, srcCtx.end);
+	            const flagsText = `${flags.unicode ? "u" : ""}${flags.unicodeSets ? "v" : ""}`;
+	            source = `: /${pattern}/${flagsText}`;
 	        }
 	        super(`Invalid regular expression${source}: ${message}`);
 	        this.index = index;
 	    }
 	}
 
+	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);
-	}
-	function isRegExpIdentifierStart(cp) {
+	    return SYNTAX_CHARACTER.has(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);
 	}
@@ -78163,29 +78201,36 @@ function requireRegexpp () {
 	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();
 	        this._backreferenceNames = new Set();
+	        this._srcCtx = null;
 	        this._options = options !== null && options !== void 0 ? options : {};
 	    }
 	    validateLiteral(source, start = 0, end = source.length) {
-	        this._uFlag = this._nFlag = false;
+	        this._srcCtx = { source, start, end, kind: "literal" };
+	        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);
-	            this.validateFlags(source, flagStart, end);
-	            this.validatePattern(source, start + 1, flagStart - 1, uFlag);
+	            const unicode = source.includes("u", flagStart);
+	            const unicodeSets = source.includes("v", flagStart);
+	            this.validateFlagsInternal(source, flagStart, end);
+	            this.validatePatternInternal(source, start + 1, flagStart - 1, {
+	                unicode,
+	                unicodeSets,
+	            });
 	        }
 	        else if (start >= end) {
 	            this.raise("Empty");
@@ -78197,6 +78242,29 @@ function requireRegexpp () {
 	        this.onLiteralLeave(start, end);
 	    }
 	    validateFlags(source, start = 0, end = source.length) {
+	        this._srcCtx = { source, start, end, kind: "flags" };
+	        this.validateFlagsInternal(source, start, end);
+	    }
+	    validatePattern(source, start = 0, end = source.length, uFlagOrFlags = undefined) {
+	        this._srcCtx = { source, start, end, kind: "pattern" };
+	        this.validatePatternInternal(source, start, end, uFlagOrFlags);
+	    }
+	    validatePatternInternal(source, start = 0, end = source.length, uFlagOrFlags = undefined) {
+	        const mode = this._parseFlagsOptionToMode(uFlagOrFlags, end);
+	        this._unicodeMode = mode.unicodeMode;
+	        this._nFlag = mode.nFlag;
+	        this._unicodeSetsMode = mode.unicodeSetsMode;
+	        this.reset(source, start, end);
+	        this.consumePattern();
+	        if (!this._nFlag &&
+	            this.ecmaVersion >= 2018 &&
+	            this._groupNames.size > 0) {
+	            this._nFlag = true;
+	            this.rewind(start);
+	            this.consumePattern();
+	        }
+	    }
+	    validateFlagsInternal(source, start, end) {
 	        const existingFlags = new Set();
 	        let global = false;
 	        let ignoreCase = false;
@@ -78205,10 +78273,11 @@ function requireRegexpp () {
 	        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)) {
-	                this.raise(`Duplicated flag '${source[i]}'`);
+	                this.raise(`Duplicated flag '${source[i]}'`, { index: start });
 	            }
 	            existingFlags.add(flag);
 	            if (flag === LATIN_SMALL_LETTER_G) {
@@ -78236,8 +78305,12 @@ function requireRegexpp () {
 	                this.ecmaVersion >= 2022) {
 	                hasIndices = true;
 	            }
+	            else if (flag === LATIN_SMALL_LETTER_V &&
+	                this.ecmaVersion >= 2024) {
+	                unicodeSets = true;
+	            }
 	            else {
-	                this.raise(`Invalid flag '${source[i]}'`);
+	                this.raise(`Invalid flag '${source[i]}'`, { index: start });
 	            }
 	        }
 	        this.onRegExpFlags(start, end, {
@@ -78248,27 +78321,43 @@ function requireRegexpp () {
 	            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;
-	        this.reset(source, start, end);
-	        this.consumePattern();
-	        if (!this._nFlag &&
-	            this.ecmaVersion >= 2018 &&
-	            this._groupNames.size > 0) {
-	            this._nFlag = true;
-	            this.rewind(start);
-	            this.consumePattern();
+	    _parseFlagsOptionToMode(uFlagOrFlags, 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) {
+	            this.raise("Invalid regular expression flags", {
+	                index: sourceEnd + 1,
+	                unicode,
+	                unicodeSets,
+	            });
+	        }
+	        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 : 2022;
+	        return (_a = this._options.ecmaVersion) !== null && _a !== void 0 ? _a : latestEcmaVersion;
 	    }
 	    onLiteralEnter(start) {
 	        if (this._options.onLiteralEnter) {
@@ -78373,9 +78462,9 @@ function requireRegexpp () {
 	            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) {
@@ -78388,9 +78477,9 @@ function requireRegexpp () {
 	            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) {
@@ -78403,8 +78492,35 @@ function requireRegexpp () {
 	            this._options.onCharacterClassRange(start, end, min, max);
 	        }
 	    }
-	    get source() {
-	        return this._reader.source;
+	    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 index() {
 	        return this._reader.index;
@@ -78422,7 +78538,7 @@ function requireRegexpp () {
 	        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);
@@ -78439,8 +78555,12 @@ function requireRegexpp () {
 	    eat3(cp1, cp2, cp3) {
 	        return this._reader.eat3(cp1, cp2, cp3);
 	    }
-	    raise(message) {
-	        throw new RegExpSyntaxError(this.source, this._uFlag, this.index, message);
+	    raise(message, context) {
+	        var _a, _b, _c;
+	        throw new RegExpSyntaxError(this._srcCtx, {
+	            unicode: (_a = context === null || context === void 0 ? void 0 : context.unicode) !== null && _a !== void 0 ? _a : (this._unicodeMode && !this._unicodeSetsMode),
+	            unicodeSets: (_b = context === null || context === void 0 ? void 0 : context.unicodeSets) !== null && _b !== void 0 ? _b : this._unicodeSetsMode,
+	        }, (_c = context === null || context === void 0 ? void 0 : context.index) !== null && _c !== void 0 ? _c : this.index, message);
 	    }
 	    eatRegExpBody() {
 	        const start = this.index;
@@ -78555,7 +78675,7 @@ function requireRegexpp () {
 	        this.onAlternativeLeave(start, this.index, i);
 	    }
 	    consumeTerm() {
-	        if (this._uFlag || this.strict) {
+	        if (this._unicodeMode || this.strict) {
 	            return (this.consumeAssertion() ||
 	                (this.consumeAtom() && this.consumeOptionalQuantifier()));
 	        }
@@ -78624,8 +78744,7 @@ function requireRegexpp () {
 	            max = 1;
 	        }
 	        else if (this.eatBracedQuantifier(noConsume)) {
-	            min = this._lastMinValue;
-	            max = this._lastMaxValue;
+	            ({ min, max } = this._lastRange);
 	        }
 	        else {
 	            return false;
@@ -78639,23 +78758,23 @@ function requireRegexpp () {
 	    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);
@@ -78666,7 +78785,7 @@ function requireRegexpp () {
 	        return (this.consumePatternCharacter() ||
 	            this.consumeDot() ||
 	            this.consumeReverseSolidusAtomEscape() ||
-	            this.consumeCharacterClass() ||
+	            Boolean(this.consumeCharacterClass()) ||
 	            this.consumeUncapturingGroup() ||
 	            this.consumeCapturingGroup());
 	    }
@@ -78726,7 +78845,7 @@ function requireRegexpp () {
 	        return (this.consumeDot() ||
 	            this.consumeReverseSolidusAtomEscape() ||
 	            this.consumeReverseSolidusFollowedByC() ||
-	            this.consumeCharacterClass() ||
+	            Boolean(this.consumeCharacterClass()) ||
 	            this.consumeUncapturingGroup() ||
 	            this.consumeCapturingGroup() ||
 	            this.consumeInvalidBracedQuantifier() ||
@@ -78800,7 +78919,7 @@ function requireRegexpp () {
 	            (this._nFlag && this.consumeKGroupName())) {
 	            return true;
 	        }
-	        if (this.strict || this._uFlag) {
+	        if (this.strict || this._unicodeMode) {
 	            this.raise("Invalid escape");
 	        }
 	        return false;
@@ -78813,7 +78932,7 @@ function requireRegexpp () {
 	                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);
@@ -78821,52 +78940,57 @@ function requireRegexpp () {
 	        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;
@@ -78876,7 +79000,7 @@ function requireRegexpp () {
 	            this.eatHexEscapeSequence() ||
 	            this.eatRegExpUnicodeEscapeSequence() ||
 	            (!this.strict &&
-	                !this._uFlag &&
+	                !this._unicodeMode &&
 	                this.eatLegacyOctalEscapeSequence()) ||
 	            this.eatIdentityEscape()) {
 	            this.onCharacter(start - 1, this.index, this._lastIntValue);
@@ -78901,18 +79025,31 @@ function requireRegexpp () {
 	        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()) {
@@ -78938,6 +79075,7 @@ function requireRegexpp () {
 	            }
 	            this.onCharacterClassRange(rangeStart, this.index, min, max);
 	        }
+	        return {};
 	    }
 	    consumeClassAtom() {
 	        const start = this.index;
@@ -78960,7 +79098,7 @@ function requireRegexpp () {
 	                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);
@@ -78974,14 +79112,14 @@ function requireRegexpp () {
 	            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();
@@ -78990,7 +79128,196 @@ function requireRegexpp () {
 	            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)) {
@@ -79013,7 +79340,7 @@ function requireRegexpp () {
 	    }
 	    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 &&
@@ -79026,7 +79353,7 @@ function requireRegexpp () {
 	            cp = combineSurrogatePair(cp, this.currentCodePoint);
 	            this.advance();
 	        }
-	        if (isRegExpIdentifierStart(cp)) {
+	        if (isIdentifierStartChar(cp)) {
 	            this._lastIntValue = cp;
 	            return true;
 	        }
@@ -79037,7 +79364,7 @@ function requireRegexpp () {
 	    }
 	    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 &&
@@ -79050,7 +79377,7 @@ function requireRegexpp () {
 	            cp = combineSurrogatePair(cp, this.currentCodePoint);
 	            this.advance();
 	        }
-	        if (isRegExpIdentifierPart(cp)) {
+	        if (isIdentifierPartChar(cp)) {
 	            this._lastIntValue = cp;
 	            return true;
 	        }
@@ -79112,7 +79439,7 @@ function requireRegexpp () {
 	    }
 	    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) ||
@@ -79168,7 +79495,7 @@ function requireRegexpp () {
 	        if (cp === -1) {
 	            return false;
 	        }
-	        if (this._uFlag) {
+	        if (this._unicodeMode) {
 	            return isSyntaxCharacter(cp) || cp === SOLIDUS;
 	        }
 	        if (this.strict) {
@@ -79195,11 +79522,14 @@ function requireRegexpp () {
 	    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");
 	            }
@@ -79208,18 +79538,28 @@ function requireRegexpp () {
 	        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 = "";
@@ -79246,7 +79586,7 @@ function requireRegexpp () {
 	            if (this.eatFixedHexDigits(2)) {
 	                return true;
 	            }
-	            if (this._uFlag || this.strict) {
+	            if (this._unicodeMode || this.strict) {
 	                this.raise("Invalid escape");
 	            }
 	            this.rewind(start);
@@ -79321,16 +79661,24 @@ function requireRegexpp () {
 	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 : 2022;
+	        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") {
@@ -79344,7 +79692,7 @@ function requireRegexpp () {
 	        }
 	        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,
@@ -79358,6 +79706,7 @@ function requireRegexpp () {
 	            sticky,
 	            dotAll,
 	            hasIndices,
+	            unicodeSets,
 	        };
 	    }
 	    onPatternEnter(start) {
@@ -79572,26 +79921,33 @@ function requireRegexpp () {
 	            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({
@@ -79620,31 +79976,66 @@ function requireRegexpp () {
 	        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;
@@ -79653,15 +80044,19 @@ function requireRegexpp () {
 	        }
 	        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 = {
@@ -79677,6 +80072,111 @@ function requireRegexpp () {
 	        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) {
@@ -79706,9 +80206,9 @@ function requireRegexpp () {
 	        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;
 	    }
 	}
@@ -79743,6 +80243,18 @@ function requireRegexpp () {
 	            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;
@@ -79758,6 +80270,9 @@ function requireRegexpp () {
 	            case "RegExpLiteral":
 	                this.visitRegExpLiteral(node);
 	                break;
+	            case "StringAlternative":
+	                this.visitStringAlternative(node);
+	                break;
 	            default:
 	                throw new Error(`Unknown type: ${node.type}`);
 	        }
@@ -79834,6 +80349,44 @@ function requireRegexpp () {
 	            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);
@@ -79879,6 +80432,15 @@ function requireRegexpp () {
 	            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) {
@@ -79922,6 +80484,16 @@ function requireNoControlRegex () {
 	    }
 
 	    onPatternEnter() {
+
+	        /*
+	         * `RegExpValidator` may parse the pattern twice in one `validatePattern`.
+	         * So `this._controlChars` should be cleared here as well.
+	         *
+	         * For example, the `/(?<a>\x1f)/` regex will parse the pattern twice.
+	         * This is based on the content described in Annex B.
+	         * If the regex contains a `GroupName` and the `u` flag is not used, `ParseText` will be called twice.
+	         * See https://tc39.es/ecma262/2023/multipage/additional-ecmascript-features-for-web-browsers.html#sec-parsepattern-annexb
+	         */
 	        this._controlChars = [];
 	    }
 
@@ -79940,10 +80512,13 @@ function requireNoControlRegex () {
 
 	    collectControlChars(regexpStr, flags) {
 	        const uFlag = typeof flags === "string" && flags.includes("u");
+	        const vFlag = typeof flags === "string" && flags.includes("v");
+
+	        this._controlChars = [];
+	        this._source = regexpStr;
 
 	        try {
-	            this._source = regexpStr;
-	            this._validator.validatePattern(regexpStr, void 0, void 0, uFlag); // Call onCharacter hook
+	            this._validator.validatePattern(regexpStr, void 0, void 0, { unicode: uFlag, unicodeSets: vFlag }); // Call onCharacter hook
 	        } catch {
 
 	            // Ignore syntax errors in RegExp.
@@ -81716,20 +82291,18 @@ function requireNoEmptyCharacterClass () {
 	if (hasRequiredNoEmptyCharacterClass) return noEmptyCharacterClass;
 	hasRequiredNoEmptyCharacterClass = 1;
 
+	//------------------------------------------------------------------------------
+	// Requirements
+	//------------------------------------------------------------------------------
+
+	const { RegExpParser, visitRegExpAST } = requireRegexpp();
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
 
-	/*
-	 * plain-English description of the following regexp:
-	 * 0. `^` fix the match at the beginning of the string
-	 * 1. `([^\\[]|\\.|\[([^\\\]]|\\.)+\])*`: regexp contents; 0 or more of the following
-	 * 1.0. `[^\\[]`: any character that's not a `\` or a `[` (anything but escape sequences and character classes)
-	 * 1.1. `\\.`: an escape sequence
-	 * 1.2. `\[([^\\\]]|\\.)+\]`: a character class that isn't empty
-	 * 2. `$`: fix the match at the end of the string
-	 */
-	const regex = /^([^\\[]|\\.|\[([^\\\]]|\\.)+\])*$/u;
+	const parser = new RegExpParser();
+	const QUICK_TEST_REGEX = /\[\]/u;
 
 	//------------------------------------------------------------------------------
 	// Rule Definition
@@ -81756,9 +82329,32 @@ function requireNoEmptyCharacterClass () {
 	    create(context) {
 	        return {
 	            "Literal[regex]"(node) {
-	                if (!regex.test(node.regex.pattern)) {
-	                    context.report({ node, messageId: "unexpected" });
+	                const { pattern, flags } = node.regex;
+
+	                if (!QUICK_TEST_REGEX.test(pattern)) {
+	                    return;
+	                }
+
+	                let regExpAST;
+
+	                try {
+	                    regExpAST = parser.parsePattern(pattern, 0, pattern.length, {
+	                        unicode: flags.includes("u"),
+	                        unicodeSets: flags.includes("v")
+	                    });
+	                } catch {
+
+	                    // Ignore regular expressions that regexpp cannot parse
+	                    return;
 	                }
+
+	                visitRegExpAST(regExpAST, {
+	                    onCharacterClassEnter(characterClass) {
+	                        if (!characterClass.negate && characterClass.elements.length === 0) {
+	                            context.report({ node, messageId: "unexpected" });
+	                        }
+	                    }
+	                });
 	            }
 	        };
 
@@ -81954,6 +82550,8 @@ function requireNoEmptyPattern () {
 	if (hasRequiredNoEmptyPattern) return noEmptyPattern;
 	hasRequiredNoEmptyPattern = 1;
 
+	const astUtils = requireAstUtils();
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -81969,7 +82567,18 @@ function requireNoEmptyPattern () {
 	            url: "https://eslint.org/docs/latest/rules/no-empty-pattern"
 	        },
 
-	        schema: [],
+	        schema: [
+	            {
+	                type: "object",
+	                properties: {
+	                    allowObjectPatternsAsParameters: {
+	                        type: "boolean",
+	                        default: false
+	                    }
+	                },
+	                additionalProperties: false
+	            }
+	        ],
 
 	        messages: {
 	            unexpected: "Unexpected empty {{type}} pattern."
@@ -81977,11 +82586,33 @@ function requireNoEmptyPattern () {
 	    },
 
 	    create(context) {
+	        const options = context.options[0] || {},
+	            allowObjectPatternsAsParameters = options.allowObjectPatternsAsParameters || false;
+
 	        return {
 	            ObjectPattern(node) {
-	                if (node.properties.length === 0) {
-	                    context.report({ node, messageId: "unexpected", data: { type: "object" } });
+
+	                if (node.properties.length > 0) {
+	                    return;
 	                }
+
+	                // Allow {} and {} = {} empty object patterns as parameters when allowObjectPatternsAsParameters is true
+	                if (
+	                    allowObjectPatternsAsParameters &&
+	                    (
+	                        astUtils.isFunction(node.parent) ||
+	                        (
+	                            node.parent.type === "AssignmentPattern" &&
+	                            astUtils.isFunction(node.parent.parent) &&
+	                            node.parent.right.type === "ObjectExpression" &&
+	                            node.parent.right.properties.length === 0
+	                        )
+	                    )
+	                ) {
+	                    return;
+	                }
+
+	                context.report({ node, messageId: "unexpected", data: { type: "object" } });
 	            },
 	            ArrayPattern(node) {
 	                if (node.elements.length === 0) {
@@ -86457,7 +87088,7 @@ function requireNoInvalidRegexp () {
 
 	const RegExpValidator = requireRegexpp().RegExpValidator;
 	const validator = new RegExpValidator();
-	const validFlags = /[dgimsuy]/gu;
+	const validFlags = /[dgimsuvy]/gu;
 	const undefined1 = void 0;
 
 	//------------------------------------------------------------------------------
@@ -86555,12 +87186,14 @@ function requireNoInvalidRegexp () {
 	        /**
 	         * Check syntax error in a given pattern.
 	         * @param {string} pattern The RegExp pattern to validate.
-	         * @param {boolean} uFlag The Unicode flag.
+	         * @param {Object} flags The RegExp flags to validate.
+	         * @param {boolean} [flags.unicode] The Unicode flag.
+	         * @param {boolean} [flags.unicodeSets] The UnicodeSets flag.
 	         * @returns {string|null} The syntax error.
 	         */
-	        function validateRegExpPattern(pattern, uFlag) {
+	        function validateRegExpPattern(pattern, flags) {
 	            try {
-	                validator.validatePattern(pattern, undefined1, undefined1, uFlag);
+	                validator.validatePattern(pattern, undefined1, undefined1, flags);
 	                return null;
 	            } catch (err) {
 	                return err.message;
@@ -86578,10 +87211,19 @@ function requireNoInvalidRegexp () {
 	            }
 	            try {
 	                validator.validateFlags(flags);
-	                return null;
 	            } catch {
 	                return `Invalid flags supplied to RegExp constructor '${flags}'`;
 	            }
+
+	            /*
+	             * `regexpp` checks the combination of `u` and `v` flags when parsing `Pattern` according to `ecma262`,
+	             * but this rule may check only the flag when the pattern is unidentifiable, so check it here.
+	             * https://tc39.es/ecma262/multipage/text-processing.html#sec-parsepattern
+	             */
+	            if (flags.includes("u") && flags.includes("v")) {
+	                return "Regex 'u' and 'v' flags cannot be used together";
+	            }
+	            return null;
 	        }
 
 	        return {
@@ -86613,8 +87255,12 @@ function requireNoInvalidRegexp () {
 
 	                    // If flags are unknown, report the regex only if its pattern is invalid both with and without the "u" flag
 	                    flags === null
-	                        ? validateRegExpPattern(pattern, true) && validateRegExpPattern(pattern, false)
-	                        : validateRegExpPattern(pattern, flags.includes("u"))
+	                        ? (
+	                            validateRegExpPattern(pattern, { unicode: true, unicodeSets: false }) &&
+	                            validateRegExpPattern(pattern, { unicode: false, unicodeSets: true }) &&
+	                            validateRegExpPattern(pattern, { unicode: false, unicodeSets: false })
+	                        )
+	                        : validateRegExpPattern(pattern, { unicode: flags.includes("u"), unicodeSets: flags.includes("v") })
 	                );
 
 	                if (message) {
@@ -87806,7 +88452,7 @@ function requireNoLoopFunc () {
 	            }
 
 	            const references = sourceCode.getScope(node).through;
-	            const unsafeRefs = references.filter(r => !isSafe(loopNode, r)).map(r => r.identifier.name);
+	            const unsafeRefs = references.filter(r => r.resolved && !isSafe(loopNode, r)).map(r => r.identifier.name);
 
 	            if (unsafeRefs.length > 0) {
 	                context.report({
@@ -88424,7 +89070,7 @@ function requireRegularExpressions () {
 
 	const { RegExpValidator } = requireRegexpp();
 
-	const REGEXPP_LATEST_ECMA_VERSION = 2022;
+	const REGEXPP_LATEST_ECMA_VERSION = 2024;
 
 	/**
 	 * Checks if the given regular expression pattern would be valid with the `u` flag.
@@ -88444,7 +89090,7 @@ function requireRegularExpressions () {
 	    });
 
 	    try {
-	        validator.validatePattern(pattern, void 0, void 0, /* uFlag = */ true);
+	        validator.validatePattern(pattern, void 0, void 0, { unicode: /* uFlag = */ true });
 	    } catch {
 	        return false;
 	    }
@@ -88485,7 +89131,7 @@ function requireNoMisleadingCharacterClass () {
 	 *
 	 * CharacterClassRange syntax can steal a part of character sequence,
 	 * so this function reverts CharacterClassRange syntax and restore the sequence.
-	 * @param {regexpp.AST.CharacterClassElement[]} nodes The node list to iterate character sequences.
+	 * @param {import('@eslint-community/regexpp').AST.CharacterClassElement[]} nodes The node list to iterate character sequences.
 	 * @returns {IterableIterator<number[]>} The list of character sequences.
 	 */
 	function *iterateCharacterSequence(nodes) {
@@ -88504,6 +89150,9 @@ function requireNoMisleadingCharacterClass () {
 	                break;
 
 	            case "CharacterSet":
+	            case "CharacterClass": // [[]] nesting character class
+	            case "ClassStringDisjunction": // \q{...}
+	            case "ExpressionCharacterClass": // [A--B]
 	                if (seq.length > 0) {
 	                    yield seq;
 	                    seq = [];
@@ -88611,7 +89260,10 @@ function requireNoMisleadingCharacterClass () {
 	                    pattern,
 	                    0,
 	                    pattern.length,
-	                    flags.includes("u")
+	                    {
+	                        unicode: flags.includes("u"),
+	                        unicodeSets: flags.includes("v")
+	                    }
 	                );
 	            } catch {
 
@@ -91990,7 +92642,7 @@ function requireNoRegexSpaces () {
 	            let regExpAST;
 
 	            try {
-	                regExpAST = regExpParser.parsePattern(pattern, 0, pattern.length, flags.includes("u"));
+	                regExpAST = regExpParser.parsePattern(pattern, 0, pattern.length, { unicode: flags.includes("u"), unicodeSets: flags.includes("v") });
 	            } catch {
 
 	                // Ignore regular expressions with syntax errors
@@ -92068,13 +92720,28 @@ function requireNoRegexSpaces () {
 	            const regExpVar = astUtils.getVariableByName(scope, "RegExp");
 	            const shadowed = regExpVar && regExpVar.defs.length > 0;
 	            const patternNode = node.arguments[0];
-	            const flagsNode = node.arguments[1];
 
 	            if (node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(patternNode) && !shadowed) {
 	                const pattern = patternNode.value;
 	                const rawPattern = patternNode.raw.slice(1, -1);
 	                const rawPatternStartRange = patternNode.range[0] + 1;
-	                const flags = isString(flagsNode) ? flagsNode.value : "";
+	                let flags;
+
+	                if (node.arguments.length < 2) {
+
+	                    // It has no flags.
+	                    flags = "";
+	                } else {
+	                    const flagsNode = node.arguments[1];
+
+	                    if (isString(flagsNode)) {
+	                        flags = flagsNode.value;
+	                    } else {
+
+	                        // The flags cannot be determined.
+	                        return;
+	                    }
+	                }
 
 	                checkRegex(
 	                    node,
@@ -94035,6 +94702,7 @@ function requireNoReturnAssign () {
 /**
  * @fileoverview Disallows unnecessary `return await`
  * @author Jordan Harband
+ * @deprecated in ESLint v8.46.0
  */
 
 var noReturnAwait;
@@ -94066,6 +94734,10 @@ function requireNoReturnAwait () {
 
 	        fixable: null,
 
+	        deprecated: true,
+
+	        replacedBy: [],
+
 	        schema: [
 	        ],
 
@@ -100183,7 +100855,7 @@ function requireNoUselessBackreference () {
 	            let regExpAST;
 
 	            try {
-	                regExpAST = parser.parsePattern(pattern, 0, pattern.length, flags.includes("u"));
+	                regExpAST = parser.parsePattern(pattern, 0, pattern.length, { unicode: flags.includes("u"), unicodeSets: flags.includes("v") });
 	            } catch {
 
 	                // Ignore regular expressions with syntax errors
@@ -100958,7 +101630,12 @@ function requireNoUselessEscape () {
 	hasRequiredNoUselessEscape = 1;
 
 	const astUtils = requireAstUtils();
+	const { RegExpParser, visitRegExpAST } = requireRegexpp();
 
+	/**
+	 * @typedef {import('@eslint-community/regexpp').AST.CharacterClass} CharacterClass
+	 * @typedef {import('@eslint-community/regexpp').AST.ExpressionCharacterClass} ExpressionCharacterClass
+	 */
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -100980,55 +101657,17 @@ function requireNoUselessEscape () {
 	const REGEX_GENERAL_ESCAPES = new Set("\\bcdDfnpPrsStvwWxu0123456789]");
 	const REGEX_NON_CHARCLASS_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set("^/.$*+?[{}|()Bk"));
 
-	/**
-	 * Parses a regular expression into a list of characters with character class info.
-	 * @param {string} regExpText The raw text used to create the regular expression
-	 * @returns {Object[]} A list of characters, each with info on escaping and whether they're in a character class.
-	 * @example
-	 *
-	 * parseRegExp("a\\b[cd-]");
-	 *
-	 * // returns:
-	 * [
-	 *     { text: "a", index: 0, escaped: false, inCharClass: false, startsCharClass: false, endsCharClass: false },
-	 *     { text: "b", index: 2, escaped: true, inCharClass: false, startsCharClass: false, endsCharClass: false },
-	 *     { text: "c", index: 4, escaped: false, inCharClass: true, startsCharClass: true, endsCharClass: false },
-	 *     { text: "d", index: 5, escaped: false, inCharClass: true, startsCharClass: false, endsCharClass: false },
-	 *     { text: "-", index: 6, escaped: false, inCharClass: true, startsCharClass: false, endsCharClass: false }
-	 * ];
-	 *
+	/*
+	 * Set of characters that require escaping in character classes in `unicodeSets` mode.
+	 * ( ) [ ] { } / - \ | are ClassSetSyntaxCharacter
 	 */
-	function parseRegExp(regExpText) {
-	    const charList = [];
-
-	    regExpText.split("").reduce((state, char, index) => {
-	        if (!state.escapeNextChar) {
-	            if (char === "\\") {
-	                return Object.assign(state, { escapeNextChar: true });
-	            }
-	            if (char === "[" && !state.inCharClass) {
-	                return Object.assign(state, { inCharClass: true, startingCharClass: true });
-	            }
-	            if (char === "]" && state.inCharClass) {
-	                if (charList.length && charList[charList.length - 1].inCharClass) {
-	                    charList[charList.length - 1].endsCharClass = true;
-	                }
-	                return Object.assign(state, { inCharClass: false, startingCharClass: false });
-	            }
-	        }
-	        charList.push({
-	            text: char,
-	            index,
-	            escaped: state.escapeNextChar,
-	            inCharClass: state.inCharClass,
-	            startsCharClass: state.startingCharClass,
-	            endsCharClass: false
-	        });
-	        return Object.assign(state, { escapeNextChar: false, startingCharClass: false });
-	    }, { escapeNextChar: false, inCharClass: false, startingCharClass: false });
+	const REGEX_CLASSSET_CHARACTER_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set("q/[{}|()-"));
 
-	    return charList;
-	}
+	/*
+	 * A single character set of ClassSetReservedDoublePunctuator.
+	 * && !! ## $$ %% ** ++ ,, .. :: ;; << == >> ?? @@ ^^ `` ~~ are ClassSetReservedDoublePunctuator
+	 */
+	const REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR = new Set("!#$%&*+,.:;<=>?@^`~");
 
 	/** @type {import('../shared/types').Rule} */
 	noUselessEscape = {
@@ -101055,15 +101694,17 @@ function requireNoUselessEscape () {
 
 	    create(context) {
 	        const sourceCode = context.sourceCode;
+	        const parser = new RegExpParser();
 
 	        /**
 	         * Reports a node
 	         * @param {ASTNode} node The node to report
 	         * @param {number} startOffset The backslash's offset from the start of the node
 	         * @param {string} character The uselessly escaped character (not including the backslash)
+	         * @param {boolean} [disableEscapeBackslashSuggest] `true` if escapeBackslash suggestion should be turned off.
 	         * @returns {void}
 	         */
-	        function report(node, startOffset, character) {
+	        function report(node, startOffset, character, disableEscapeBackslashSuggest) {
 	            const rangeStart = node.range[0] + startOffset;
 	            const range = [rangeStart, rangeStart + 1];
 	            const start = sourceCode.getLocFromIndex(rangeStart);
@@ -101086,12 +101727,16 @@ function requireNoUselessEscape () {
 	                            return fixer.removeRange(range);
 	                        }
 	                    },
-	                    {
-	                        messageId: "escapeBackslash",
-	                        fix(fixer) {
-	                            return fixer.insertTextBeforeRange(range, "\\");
-	                        }
-	                    }
+	                    ...disableEscapeBackslashSuggest
+	                        ? []
+	                        : [
+	                            {
+	                                messageId: "escapeBackslash",
+	                                fix(fixer) {
+	                                    return fixer.insertTextBeforeRange(range, "\\");
+	                                }
+	                            }
+	                        ]
 	                ]
 	            });
 	        }
@@ -101134,6 +101779,133 @@ function requireNoUselessEscape () {
 	            }
 	        }
 
+	        /**
+	         * Checks if the escape character in given regexp is unnecessary.
+	         * @private
+	         * @param {ASTNode} node node to validate.
+	         * @returns {void}
+	         */
+	        function validateRegExp(node) {
+	            const { pattern, flags } = node.regex;
+	            let patternNode;
+	            const unicode = flags.includes("u");
+	            const unicodeSets = flags.includes("v");
+
+	            try {
+	                patternNode = parser.parsePattern(pattern, 0, pattern.length, { unicode, unicodeSets });
+	            } catch {
+
+	                // Ignore regular expressions with syntax errors
+	                return;
+	            }
+
+	            /** @type {(CharacterClass | ExpressionCharacterClass)[]} */
+	            const characterClassStack = [];
+
+	            visitRegExpAST(patternNode, {
+	                onCharacterClassEnter: characterClassNode => characterClassStack.unshift(characterClassNode),
+	                onCharacterClassLeave: () => characterClassStack.shift(),
+	                onExpressionCharacterClassEnter: characterClassNode => characterClassStack.unshift(characterClassNode),
+	                onExpressionCharacterClassLeave: () => characterClassStack.shift(),
+	                onCharacterEnter(characterNode) {
+	                    if (!characterNode.raw.startsWith("\\")) {
+
+	                        // It's not an escaped character.
+	                        return;
+	                    }
+
+	                    const escapedChar = characterNode.raw.slice(1);
+
+	                    if (escapedChar !== String.fromCodePoint(characterNode.value)) {
+
+	                        // It's a valid escape.
+	                        return;
+	                    }
+	                    let allowedEscapes;
+
+	                    if (characterClassStack.length) {
+	                        allowedEscapes = unicodeSets ? REGEX_CLASSSET_CHARACTER_ESCAPES : REGEX_GENERAL_ESCAPES;
+	                    } else {
+	                        allowedEscapes = REGEX_NON_CHARCLASS_ESCAPES;
+	                    }
+	                    if (allowedEscapes.has(escapedChar)) {
+	                        return;
+	                    }
+
+	                    const reportedIndex = characterNode.start + 1;
+	                    let disableEscapeBackslashSuggest = false;
+
+	                    if (characterClassStack.length) {
+	                        const characterClassNode = characterClassStack[0];
+
+	                        if (escapedChar === "^") {
+
+	                            /*
+	                             * The '^' character is also a special case; it must always be escaped outside of character classes, but
+	                             * it only needs to be escaped in character classes if it's at the beginning of the character class. To
+	                             * account for this, consider it to be a valid escape character outside of character classes, and filter
+	                             * out '^' characters that appear at the start of a character class.
+	                             */
+	                            if (characterClassNode.start + 1 === characterNode.start) {
+
+	                                return;
+	                            }
+	                        }
+	                        if (!unicodeSets) {
+	                            if (escapedChar === "-") {
+
+	                                /*
+	                                 * The '-' character is a special case, because it's only valid to escape it if it's in a character
+	                                 * class, and is not at either edge of the character class. To account for this, don't consider '-'
+	                                 * characters to be valid in general, and filter out '-' characters that appear in the middle of a
+	                                 * character class.
+	                                 */
+	                                if (characterClassNode.start + 1 !== characterNode.start && characterNode.end !== characterClassNode.end - 1) {
+
+	                                    return;
+	                                }
+	                            }
+	                        } else { // unicodeSets mode
+	                            if (REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR.has(escapedChar)) {
+
+	                                // Escaping is valid if it is a ClassSetReservedDoublePunctuator.
+	                                if (pattern[characterNode.end] === escapedChar) {
+	                                    return;
+	                                }
+	                                if (pattern[characterNode.start - 1] === escapedChar) {
+	                                    if (escapedChar !== "^") {
+	                                        return;
+	                                    }
+
+	                                    // If the previous character is a `negate` caret(`^`), escape to caret is unnecessary.
+
+	                                    if (!characterClassNode.negate) {
+	                                        return;
+	                                    }
+	                                    const negateCaretIndex = characterClassNode.start + 1;
+
+	                                    if (negateCaretIndex < characterNode.start - 1) {
+	                                        return;
+	                                    }
+	                                }
+	                            }
+
+	                            if (characterNode.parent.type === "ClassIntersection" || characterNode.parent.type === "ClassSubtraction") {
+	                                disableEscapeBackslashSuggest = true;
+	                            }
+	                        }
+	                    }
+
+	                    report(
+	                        node,
+	                        reportedIndex,
+	                        escapedChar,
+	                        disableEscapeBackslashSuggest
+	                    );
+	                }
+	            });
+	        }
+
 	        /**
 	         * Checks if a node has an escape.
 	         * @param {ASTNode} node node to check.
@@ -101172,32 +101944,7 @@ function requireNoUselessEscape () {
 	                    validateString(node, match);
 	                }
 	            } else if (node.regex) {
-	                parseRegExp(node.regex.pattern)
-
-	                    /*
-	                     * The '-' character is a special case, because it's only valid to escape it if it's in a character
-	                     * class, and is not at either edge of the character class. To account for this, don't consider '-'
-	                     * characters to be valid in general, and filter out '-' characters that appear in the middle of a
-	                     * character class.
-	                     */
-	                    .filter(charInfo => !(charInfo.text === "-" && charInfo.inCharClass && !charInfo.startsCharClass && !charInfo.endsCharClass))
-
-	                    /*
-	                     * The '^' character is also a special case; it must always be escaped outside of character classes, but
-	                     * it only needs to be escaped in character classes if it's at the beginning of the character class. To
-	                     * account for this, consider it to be a valid escape character outside of character classes, and filter
-	                     * out '^' characters that appear at the start of a character class.
-	                     */
-	                    .filter(charInfo => !(charInfo.text === "^" && charInfo.startsCharClass))
-
-	                    // Filter out characters that aren't escaped.
-	                    .filter(charInfo => charInfo.escaped)
-
-	                    // Filter out characters that are valid to escape, based on their position in the regular expression.
-	                    .filter(charInfo => !(charInfo.inCharClass ? REGEX_GENERAL_ESCAPES : REGEX_NON_CHARCLASS_ESCAPES).has(charInfo.text))
-
-	                    // Report all the remaining characters.
-	                    .forEach(charInfo => report(node, charInfo.index, charInfo.text));
+	                validateRegExp(node);
 	            }
 
 	        }
@@ -107524,14 +108271,17 @@ function requirePreferNamedCaptureGroup () {
 	         * @param {string} pattern The regular expression pattern to be checked.
 	         * @param {ASTNode} node AST node which contains the regular expression or a call/new expression.
 	         * @param {ASTNode} regexNode AST node which contains the regular expression.
-	         * @param {boolean} uFlag Flag indicates whether unicode mode is enabled or not.
+	         * @param {string|null} flags The regular expression flags to be checked.
 	         * @returns {void}
 	         */
-	        function checkRegex(pattern, node, regexNode, uFlag) {
+	        function checkRegex(pattern, node, regexNode, flags) {
 	            let ast;
 
 	            try {
-	                ast = parser.parsePattern(pattern, 0, pattern.length, uFlag);
+	                ast = parser.parsePattern(pattern, 0, pattern.length, {
+	                    unicode: Boolean(flags && flags.includes("u")),
+	                    unicodeSets: Boolean(flags && flags.includes("v"))
+	                });
 	            } catch {
 
 	                // ignore regex syntax errors
@@ -107560,7 +108310,7 @@ function requirePreferNamedCaptureGroup () {
 	        return {
 	            Literal(node) {
 	                if (node.regex) {
-	                    checkRegex(node.regex.pattern, node, node, node.regex.flags.includes("u"));
+	                    checkRegex(node.regex.pattern, node, node, node.regex.flags);
 	                }
 	            },
 	            Program(node) {
@@ -107578,7 +108328,7 @@ function requirePreferNamedCaptureGroup () {
 	                    const flags = getStringIfConstant(refNode.arguments[1]);
 
 	                    if (regex) {
-	                        checkRegex(regex, refNode, refNode.arguments[0], flags && flags.includes("u"));
+	                        checkRegex(regex, refNode, refNode.arguments[0], flags);
 	                    }
 	                }
 	            }
@@ -108697,7 +109447,7 @@ function requirePreferRegexLiterals () {
 	        /**
 	         * Returns a ecmaVersion compatible for regexpp.
 	         * @param {number} ecmaVersion The ecmaVersion to convert.
-	         * @returns {import("regexpp/ecma-versions").EcmaVersion} The resulting ecmaVersion compatible for regexpp.
+	         * @returns {import("@eslint-community/regexpp/ecma-versions").EcmaVersion} The resulting ecmaVersion compatible for regexpp.
 	         */
 	        function getRegexppEcmaVersion(ecmaVersion) {
 	            if (ecmaVersion <= 5) {
@@ -108753,7 +109503,10 @@ function requirePreferRegexLiterals () {
 	            const validator = new RegExpValidator({ ecmaVersion: regexppEcmaVersion });
 
 	            try {
-	                validator.validatePattern(pattern, 0, pattern.length, flags ? flags.includes("u") : false);
+	                validator.validatePattern(pattern, 0, pattern.length, {
+	                    unicode: flags ? flags.includes("u") : false,
+	                    unicodeSets: flags ? flags.includes("v") : false
+	                });
 	                if (flags) {
 	                    validator.validateFlags(flags);
 	                }
@@ -108917,7 +109670,10 @@ function requirePreferRegexLiterals () {
 	                        if (regexContent && !noFix) {
 	                            let charIncrease = 0;
 
-	                            const ast = new RegExpParser({ ecmaVersion: regexppEcmaVersion }).parsePattern(regexContent, 0, regexContent.length, flags ? flags.includes("u") : false);
+	                            const ast = new RegExpParser({ ecmaVersion: regexppEcmaVersion }).parsePattern(regexContent, 0, regexContent.length, {
+	                                unicode: flags ? flags.includes("u") : false,
+	                                unicodeSets: flags ? flags.includes("v") : false
+	                            });
 
 	                            visitRegExpAST(ast, {
 	                                onCharacterEnter(characterNode) {
@@ -110952,7 +111708,7 @@ function requireRequireUnicodeRegexp () {
 	        type: "suggestion",
 
 	        docs: {
-	            description: "Enforce the use of `u` flag on RegExp",
+	            description: "Enforce the use of `u` or `v` flag on RegExp",
 	            recommended: false,
 	            url: "https://eslint.org/docs/latest/rules/require-unicode-regexp"
 	        },
@@ -110975,7 +111731,7 @@ function requireRequireUnicodeRegexp () {
 	            "Literal[regex]"(node) {
 	                const flags = node.regex.flags || "";
 
-	                if (!flags.includes("u")) {
+	                if (!flags.includes("u") && !flags.includes("v")) {
 	                    context.report({
 	                        messageId: "requireUFlag",
 	                        node,
@@ -111009,7 +111765,7 @@ function requireRequireUnicodeRegexp () {
 	                    const pattern = getStringIfConstant(patternNode, scope);
 	                    const flags = getStringIfConstant(flagsNode, scope);
 
-	                    if (!flagsNode || (typeof flags === "string" && !flags.includes("u"))) {
+	                    if (!flagsNode || (typeof flags === "string" && !flags.includes("u") && !flags.includes("v"))) {
 	                        context.report({
 	                            messageId: "requireUFlag",
 	                            node: refNode,
@@ -123207,6 +123963,38 @@ function requireFlatConfigSchema () {
 	    }
 	}
 
+	/**
+	 * The error type when there's an eslintrc-style options in a flat config.
+	 */
+	class IncompatibleKeyError extends Error {
+
+	    /**
+	     * @param {string} key The invalid key.
+	     */
+	    constructor(key) {
+	        super("This appears to be in eslintrc format rather than flat config format.");
+	        this.messageTemplate = "eslintrc-incompat";
+	        this.messageData = { key };
+	    }
+	}
+
+	/**
+	 * The error type when there's an eslintrc-style plugins array found.
+	 */
+	class IncompatiblePluginsError extends Error {
+
+	    /**
+	     * Creates a new instance.
+	     * @param {Array<string>} plugins The plugins array.
+	     */
+	    constructor(plugins) {
+	        super("This appears to be in eslintrc format (array of strings) rather than flat config format (object).");
+	        this.messageTemplate = "eslintrc-plugins";
+	        this.messageData = { plugins };
+	    }
+	}
+
+
 	//-----------------------------------------------------------------------------
 	// Low-Level Schemas
 	//-----------------------------------------------------------------------------
@@ -123298,6 +124086,11 @@ function requireFlatConfigSchema () {
 	            throw new TypeError("Expected an object.");
 	        }
 
+	        // make sure it's not an array, which would mean eslintrc-style is used
+	        if (Array.isArray(value)) {
+	            throw new IncompatiblePluginsError(value);
+	        }
+
 	        // second check the keys to make sure they are objects
 	        for (const key of Object.keys(value)) {
 
@@ -123433,11 +124226,44 @@ function requireFlatConfigSchema () {
 	    }
 	};
 
+	/**
+	 * Creates a schema that always throws an error. Useful for warning
+	 * about eslintrc-style keys.
+	 * @param {string} key The eslintrc key to create a schema for.
+	 * @returns {ObjectPropertySchema} The schema.
+	 */
+	function createEslintrcErrorSchema(key) {
+	    return {
+	        merge: "replace",
+	        validate() {
+	            throw new IncompatibleKeyError(key);
+	        }
+	    };
+	}
+
+	const eslintrcKeys = [
+	    "env",
+	    "extends",
+	    "globals",
+	    "ignorePatterns",
+	    "noInlineConfig",
+	    "overrides",
+	    "parser",
+	    "parserOptions",
+	    "reportUnusedDisableDirectives",
+	    "root"
+	];
+
 	//-----------------------------------------------------------------------------
 	// Full schema
 	//-----------------------------------------------------------------------------
 
 	flatConfigSchema.flatConfigSchema = {
+
+	    // eslintrc-style keys that should always error
+	    ...Object.fromEntries(eslintrcKeys.map(key => [key, createEslintrcErrorSchema(key)])),
+
+	    // flat config keys
 	    settings: deepObjectAssignSchema,
 	    linterOptions: {
 	        schema: {
@@ -124164,7 +124990,6 @@ function requireEslintAll () {
 	        "no-restricted-properties": "error",
 	        "no-restricted-syntax": "error",
 	        "no-return-assign": "error",
-	        "no-return-await": "error",
 	        "no-script-url": "error",
 	        "no-self-assign": "error",
 	        "no-self-compare": "error",