function verify(node, pattern, flags, unicodeFixer) {
			let patternNode;

			try {
				patternNode = parser.parsePattern(pattern, 0, pattern.length, {
					unicode: flags.includes("u"),
					unicodeSets: flags.includes("v"),
				});
			} catch {
				// Ignore regular expressions with syntax errors
				return;
			}

			let codeUnits = null;

			/**
			 * Checks whether a specified regexpp character is represented as an acceptable escape sequence.
			 * For the purposes of this rule, an escape sequence is considered acceptable if it consists of one or more backslashes followed by the character being escaped.
			 * @param {Character} char Character to check.
			 * @returns {boolean} Whether the specified regexpp character is represented as an acceptable escape sequence.
			 */
			function isAcceptableEscapeSequence(char) {
				if (node.type === "Literal" && node.regex) {
					return checkForAcceptableEscape(char, char.raw);
				}
				if (node.type === "Literal" && typeof node.value === "string") {
					const nodeSource = node.raw;

					codeUnits ??= parseStringLiteral(nodeSource);

					return checkForAcceptableEscapeInString(
						char,
						nodeSource,
						codeUnits,
					);
				}
				if (astUtils.isStaticTemplateLiteral(node)) {
					const nodeSource = sourceCode.getText(node);

					codeUnits ??= parseTemplateToken(nodeSource);

					return checkForAcceptableEscapeInString(
						char,
						nodeSource,
						codeUnits,
					);
				}
				return false;
			}

			const foundKindMatches = new Map();

			visitRegExpAST(patternNode, {
				onCharacterClassEnter(ccNode) {
					for (const unfilteredChars of iterateCharacterSequence(
						ccNode.elements,
					)) {
						let chars;

						if (allowEscape) {
							// Replace escape sequences with null to avoid having them flagged.
							chars = unfilteredChars.map(char =>
								isAcceptableEscapeSequence(char) ? null : char,
							);
						} else {
							chars = unfilteredChars;
						}
						for (const kind of kinds) {
							const matches = findCharacterSequences[kind](
								chars,
								unfilteredChars,
							);

							if (foundKindMatches.has(kind)) {
								foundKindMatches.get(kind).push(...matches);
							} else {
								foundKindMatches.set(kind, [...matches]);
							}
						}
					}
				},
			});

			/**
			 * Finds the report loc(s) for a range of matches.
			 * Only literals and expression-less templates generate granular errors.
			 * @param {Character[][]} matches Lists of individual characters being reported on.
			 * @returns {Location[]} locs for context.report.
			 * @see https://github.com/eslint/eslint/pull/17515
			 */
			function getNodeReportLocations(matches) {
				if (
					!astUtils.isStaticTemplateLiteral(node) &&
					node.type !== "Literal"
				) {
					return matches.length ? [node.loc] : [];
				}
				return matches.map(chars => {
					const firstIndex = chars[0].start;
					const lastIndex = chars.at(-1).end - 1;
					let start;
					let end;

					if (node.type === "TemplateLiteral") {
						const source = sourceCode.getText(node);
						const offset = node.range[0];

						codeUnits ??= parseTemplateToken(source);
						start = offset + codeUnits[firstIndex].start;
						end = offset + codeUnits[lastIndex].end;
					} else if (typeof node.value === "string") {
						// String Literal
						const source = node.raw;
						const offset = node.range[0];

						codeUnits ??= parseStringLiteral(source);
						start = offset + codeUnits[firstIndex].start;
						end = offset + codeUnits[lastIndex].end;
					} else {
						// RegExp Literal
						const offset = node.range[0] + 1; // Add 1 to skip the leading slash.

						start = offset + firstIndex;
						end = offset + lastIndex + 1;
					}

					return {
						start: sourceCode.getLocFromIndex(start),
						end: sourceCode.getLocFromIndex(end),
					};
				});
			}

			for (const [kind, matches] of foundKindMatches) {
				let suggest;

				if (kind === "surrogatePairWithoutUFlag") {
					suggest = [
						{
							messageId: "suggestUnicodeFlag",
							fix: unicodeFixer,
						},
					];
				}

				const locs = getNodeReportLocations(matches);

				for (const loc of locs) {
					context.report({
						node,
						loc,
						messageId: kind,
						suggest,
					});
				}
			}
		}
Verify a given regular expression.
@param {Node} node The node to report.
@param {string} pattern The regular expression pattern to verify.
@param {string} flags The flags of the regular expression.
@param {Function} unicodeFixer Fixer for missing "u" flag.
@returns {void}