re2js 2.8.0 → 2.8.1

package/build/index.d.cts

@@ -0,0 +1,932 @@
+// Generated by dts-bundle-generator v9.5.1
+
+declare class DFA {
+	static MAX_CACHE_CLEARS: number;
+	constructor(prog: any);
+	prog: any;
+	stateCache: Map<any, any>;
+	stateCount: number;
+	startState: any;
+	stateLimit: number;
+	cacheClears: number;
+	failed: boolean;
+	clock: number;
+	computeClosure(pcs: any): {
+		pcs: Int32Array<ArrayBuffer>;
+		isMatch: boolean;
+		matchIDs: any[];
+	};
+	getState(pcs: any): any;
+	evictCache(): void;
+	step(state: any, charCode: any, anchor: any): any;
+	match(input: any, pos: any, anchor: any): boolean;
+	matchSet(input: any, pos: any, anchor: any): any[];
+}
+declare class Prog {
+	inst: any[];
+	start: number;
+	numCap: number;
+	lbStarts: any[];
+	numLb: number;
+	getInst(pc: any): any;
+	numInst(): number;
+	addInst(op: any): void;
+	skipNop(pc: any): any;
+	prefix(): (string | boolean)[];
+	startCond(): number;
+	patch(l: any, val: any): void;
+	append(l1: any, l2: any): any;
+	/**
+	 *
+	 * @returns {string}
+	 */
+	toString(): string;
+}
+export class RE2Set {
+	/** @type {number} */
+	static UNANCHORED: number;
+	/** @type {number} */
+	static ANCHOR_START: number;
+	/** @type {number} */
+	static ANCHOR_BOTH: number;
+	/**
+	 * Constructs a new RE2Set with the specified anchor mode and flags.
+	 * @param {number} [anchor=RE2Set.UNANCHORED] - The anchoring mode (e.g., RE2Set.UNANCHORED).
+	 * @param {number} [flags=0] - The public flags to apply to all patterns in the set.
+	 */
+	constructor(anchor?: number, flags?: number);
+	anchor: number;
+	jsFlags: number;
+	re2Flags: number;
+	regexps: any[];
+	prog: Prog;
+	dfa: DFA;
+	dummyRe2: {
+		prog: Prog;
+		cond: number;
+		prefix: string;
+		prefixRune: number;
+		longest: boolean;
+	};
+	/**
+	 * Adds a new regular expression pattern to the set.
+	 * Patterns cannot be added after the set has been compiled.
+	 * @param {string} pattern - The regular expression pattern to add.
+	 * @returns {number} The integer index assigned to the added pattern.
+	 * @throws {RE2JSCompileException} If patterns are added after compilation.
+	 */
+	add(pattern: string): number;
+	/**
+	 * Compiles the added patterns into a single state machine.
+	 * This is automatically called on the first match if not called explicitly.
+	 * @returns {void}
+	 */
+	compile(): void;
+	/**
+	 * Matches the input against the compiled set of regular expressions.
+	 * @param {string|number[]|Uint8Array} input - The input string or UTF-8 byte array to match against.
+	 * @returns {number[]} An array of indices representing the patterns that successfully matched the input.
+	 */
+	match(input: string | number[] | Uint8Array): number[];
+}
+export class MatcherInput {
+	/**
+	 * Return the MatcherInput for UTF_16 encoding.
+	 * @returns {Utf16MatcherInput}
+	 */
+	static utf16(charSequence: any): Utf16MatcherInput;
+	/**
+	 * Return the MatcherInput for UTF_8 encoding.
+	 * @returns {Utf8MatcherInput}
+	 */
+	static utf8(input: any): Utf8MatcherInput;
+}
+/**
+ * Abstract the representations of input text supplied to Matcher.
+ */
+export class MatcherInputBase {
+	static Encoding: any;
+	getEncoding(): void;
+	/** @returns {string} */
+	asCharSequence(): string;
+	/** @returns {Uint8Array|number[]} */
+	asBytes(): Uint8Array | number[];
+	/** @returns {number} */
+	length(): number;
+	/**
+	 *
+	 * @returns {boolean}
+	 */
+	isUTF8Encoding(): boolean;
+	/**
+	 *
+	 * @returns {boolean}
+	 */
+	isUTF16Encoding(): boolean;
+}
+declare class Utf16MatcherInput extends MatcherInputBase {
+	/** @param {string|null} charSequence */
+	constructor(charSequence?: string | null);
+	charSequence: string;
+	getEncoding(): any;
+	/**
+	 *
+	 * @returns {number[]}
+	 */
+	asBytes(): number[];
+}
+declare class Utf8MatcherInput extends MatcherInputBase {
+	/** @param {Uint8Array|number[]|null} bytes */
+	constructor(bytes?: Uint8Array | number[] | null);
+	bytes: number[] | Uint8Array<ArrayBufferLike>;
+	getEncoding(): any;
+}
+/**
+ * A stateful iterator that interprets a regex {@code RE2JS} on a specific input.
+ *
+ * Conceptually, a Matcher consists of four parts:
+ * <ol>
+ * <li>A compiled regular expression {@code RE2JS}, set at construction and fixed for the lifetime
+ * of the matcher.</li>
+ *
+ * <li>The remainder of the input string, set at construction or {@link #reset()} and advanced by
+ * each match operation such as {@link #find}, {@link #matches} or {@link #lookingAt}.</li>
+ *
+ * <li>The current match information, accessible via {@link #start}, {@link #end}, and
+ * {@link #group}, and updated by each match operation.</li>
+ *
+ * <li>The append position, used and advanced by {@link #appendReplacement} and {@link #appendTail}
+ * if performing a search and replace from the input to an external {@code StringBuffer}.
+ *
+ * </ol>
+ *
+ *
+ * @author rsc@google.com (Russ Cox)
+ */
+export class Matcher {
+	/**
+	 * V8 and WebKit have historical hard limits on the number of arguments
+	 * that can be passed to a function. We cap replacer arguments to prevent
+	 * Call Stack Overflow (DoS) vulnerabilities on massive ASTs.
+	 */
+	static MAX_REPLACER_ARGS: number;
+	/**
+	 * Quotes '\' and '$' in {@code s}, so that the returned string could be used in
+	 * {@link #appendReplacement} as a literal replacement of {@code s}.
+	 *
+	 * @param {string} str the string to be quoted
+	 * @param {boolean} [javaMode=false] whether the replacement will be used in javaMode
+	 * @returns {string} the quoted string
+	 */
+	static quoteReplacement(str: string, javaMode?: boolean): string;
+	/**
+	 *
+	 * @param {import('./index.js').RE2JS} pattern
+	 * @param {string|number[]|Uint8Array|MatcherInputBase} input
+	 */
+	constructor(pattern: RE2JS, input: string | number[] | Uint8Array | MatcherInputBase);
+	/**
+	 * The pattern being matched.
+	 * @type {import('./index.js').RE2JS}
+	 */
+	patternInput: RE2JS;
+	/** @type {number} */
+	patternGroupCount: number;
+	/** @type {number[]} */
+	groups: number[];
+	/** @type {Record<string, number>} */
+	namedGroups: Record<string, number>;
+	/** @type {number} */
+	numberOfInstructions: number;
+	/**
+	 * Returns the {@code RE2JS} associated with this {@code Matcher}.
+	 * @returns {import('./index.js').RE2JS}
+	 */
+	pattern(): RE2JS;
+	/**
+	 * Resets the {@code Matcher}, rewinding input and discarding any match information.
+	 *
+	 * @returns {Matcher} the {@code Matcher} itself, for chained method calls
+	 */
+	reset(): Matcher;
+	/** @type {number} */
+	matcherInputLength: number;
+	/** @type {number} */
+	appendPos: number;
+	hasMatch: boolean;
+	hasGroups: boolean;
+	anchorFlag: number;
+	/**
+	 * Resets the {@code Matcher} and changes the input.
+	 * @param {MatcherInputBase} input
+	 * @returns {Matcher} the {@code Matcher} itself, for chained method calls
+	 */
+	resetMatcherInput(input: MatcherInputBase): Matcher;
+	matcherInput: MatcherInputBase;
+	/**
+	 * Returns the start of the named group of the most recent match, or -1 if the group was not
+	 * matched.
+	 * @param {string|number} [group=0]
+	 * @returns {number}
+	 */
+	start(group?: string | number): number;
+	/**
+	 * Returns the end of the named group of the most recent match, or -1 if the group was not
+	 * matched.
+	 * @param {string|number} [group=0]
+	 * @returns {number}
+	 */
+	end(group?: string | number): number;
+	/**
+	 * Returns the program size of this pattern.
+	 *
+	 * <p>
+	 * Similar to the C++ implementation, the program size is a very approximate measure of a regexp's
+	 * "cost". Larger numbers are more expensive than smaller numbers.
+	 * </p>
+	 *
+	 * @returns {number} the program size of this pattern
+	 */
+	programSize(): number;
+	/**
+	 * Returns the named group of the most recent match, or {@code null} if the group was not matched.
+	 * @param {string|number} [group=0]
+	 * @returns {string|null}
+	 */
+	group(group?: string | number): string | null;
+	/**
+	 * Returns a dictionary map of all named capturing groups and their matched values.
+	 * If a group was not matched, its value will be `null`.
+	 * @returns {Record<string, string|null>}
+	 */
+	getNamedGroups(): Record<string, string | null>;
+	/**
+	 * Returns the number of subgroups in this pattern.
+	 *
+	 * @returns {number} the number of subgroups; the overall match (group 0) does not count
+	 */
+	groupCount(): number;
+	/**
+	 * Helper: finds subgroup information if needed for group.
+	 * @param {number} group
+	 * @private
+	 */
+	private loadGroup;
+	/**
+	 * Matches the entire input against the pattern (anchored start and end). If there is a match,
+	 * {@code matches} sets the match state to describe it.
+	 *
+	 * @returns {boolean} true if the entire input matches the pattern
+	 */
+	matches(): boolean;
+	/**
+	 * Matches the beginning of input against the pattern (anchored start). If there is a match,
+	 * {@code lookingAt} sets the match state to describe it.
+	 *
+	 * @returns {boolean} true if the beginning of the input matches the pattern
+	 */
+	lookingAt(): boolean;
+	/**
+	 * Matches the input against the pattern (unanchored), starting at a specified position. If there
+	 * is a match, {@code find} sets the match state to describe it.
+	 *
+	 * @param {number|null} [start=null] the input position where the search begins
+	 * @returns {boolean} if it finds a match
+	 * @throws IndexOutOfBoundsException if start is not a valid input position
+	 */
+	find(start?: number | null): boolean;
+	/**
+	 * Helper: does match starting at start, with RE2 anchor flag.
+	 * @param {number} startByte
+	 * @param {number} anchor
+	 * @returns {boolean}
+	 * @private
+	 */
+	private genMatch;
+	/**
+	 * Helper: return substring for [start, end).
+	 * @param {number} start
+	 * @param {number} end
+	 * @returns {string}
+	 */
+	substring(start: number, end: number): string;
+	/**
+	 * Helper for Pattern: return input length.
+	 * @returns {number}
+	 */
+	inputLength(): number;
+	/**
+	 * Appends to result two strings: the text from the append position up to the beginning of the
+	 * most recent match, and then the replacement with submatch groups substituted for references of
+	 * the form {@code $n}, where {@code n} is the group number in decimal. It advances the append
+	 * position to where the most recent match ended.
+	 *
+	 * To embed a literal {@code $}, use \$ (actually {@code "\\$"} with string escapes). The escape
+	 * is only necessary when {@code $} is followed by a digit, but it is always allowed. Only
+	 * {@code $} and {@code \} need escaping, but any character can be escaped.
+	 *
+	 * The group number {@code n} in {@code $n} is always at least one digit and expands to use more
+	 * digits as long as the resulting number is a valid group number for this pattern. To cut it off
+	 * earlier, escape the first digit that should not be used.
+	 *
+	 * @param {string} replacement the replacement string
+	 * @param {boolean} [javaMode=false] activate java mode (different behaviour for capture groups and special characters)
+	 * @returns {string}
+	 * @throws IllegalStateException if there was no most recent match
+	 * @throws IndexOutOfBoundsException if replacement refers to an invalid group
+	 * @private
+	 */
+	private appendReplacement;
+	/**
+	 * @param {string} replacement - the replacement string
+	 * @returns {string}
+	 * @private
+	 */
+	private appendReplacementInternalJava;
+	/**
+	 * @param {string} replacement - the replacement string
+	 * @returns {string}
+	 * @private
+	 */
+	private appendReplacementInternalJs;
+	/**
+	 * Return the substring of the input from the append position to the end of the
+	 * input.
+	 * @returns {string}
+	 */
+	appendTail(): string;
+	/**
+	 * Returns the input with all matches replaced by {@code replacement}, interpreted as for
+	 * {@code appendReplacement}.
+	 *
+	 * @param {string|((...args: any[]) => string)} replacement - the replacement string or a replacer function
+	 * @param {boolean} [javaMode=false] - activate java mode (different behaviour for capture groups and special characters)
+	 * @returns {string} the input string with the matches replaced
+	 * @throws IndexOutOfBoundsException if replacement refers to an invalid group and javaMode is true
+	 */
+	replaceAll(replacement: string | ((...args: any[]) => string), javaMode?: boolean): string;
+	/**
+	 * Returns the input with the first match replaced by {@code replacement}, interpreted as for
+	 * {@code appendReplacement}.
+	 *
+	 * @param {string|((...args: any[]) => string)} replacement - the replacement string or a replacer function
+	 * @param {boolean} [javaMode=false] - activate java mode (different behaviour for capture groups and special characters)
+	 * @returns {string} the input string with the first match replaced
+	 * @throws IndexOutOfBoundsException if replacement refers to an invalid group and javaMode is true
+	 */
+	replaceFirst(replacement: string | ((...args: any[]) => string), javaMode?: boolean): string;
+	/**
+	 * Helper: replaceAll/replaceFirst hybrid.
+	 * @param {string|((...args: any[]) => string)} replacement - the replacement string or a replacer function
+	 * @param {boolean} [all=true] - replace all matches
+	 * @param {boolean} [javaMode=false] - activate java mode (different behaviour for capture groups and special characters)
+	 * @returns {string}
+	 * @private
+	 */
+	private replace;
+	/**
+	 * Evaluates a replacer function for the current match and appends the result,
+	 * along with any un-matched preceding text, advancing the append position.
+	 * @param {Function} replacer - the replacer function
+	 * @param {boolean} hasNamedGroups - cached flag if pattern has named groups
+	 * @param {string|Uint8Array|number[]} originalInput - the cached original input reference
+	 * @returns {string} the evaluated string to append
+	 * @private
+	 */
+	private appendReplacementFunc;
+	/**
+	 * Builds the argument array for the replacer function matching the standard
+	 * JS String.prototype.replace(regex, replacer) signature.
+	 * @param {number} matchStart - the start index of the match
+	 * @param {boolean} hasNamedGroups - cached flag if pattern has named groups
+	 * @param {string|Uint8Array|number[]} originalInput - the cached original input reference
+	 * @returns {Array} array of arguments
+	 * @private
+	 */
+	private buildReplacerArgs;
+}
+export class RE2JSException extends Error {
+	/** @param {string} message */
+	constructor(message: string);
+}
+/**
+ * An exception thrown by the parser if the pattern was invalid.
+ */
+export class RE2JSSyntaxException extends RE2JSException {
+	/**
+	 * @param {string} error
+	 * @param {string|null} [input=null]
+	 */
+	constructor(error: string, input?: string | null);
+	/** @type {string} */
+	error: string;
+	/** @type {string|null} */
+	input: string | null;
+	/**
+	 * Retrieves the description of the error.
+	 * @returns {string}
+	 */
+	getDescription(): string;
+	/**
+	 * Retrieves the erroneous regular-expression pattern.
+	 * @returns {string|null}
+	 */
+	getPattern(): string | null;
+}
+/**
+ * An exception thrown by the compiler
+ */
+export class RE2JSCompileException extends RE2JSException {
+}
+/**
+ * An exception thrown by using groups
+ */
+export class RE2JSGroupException extends RE2JSException {
+}
+/**
+ * An exception thrown by flags
+ */
+export class RE2JSFlagsException extends RE2JSException {
+}
+/**
+ * An exception thrown for internal engine errors, such as corrupted bytecodes.
+ */
+export class RE2JSInternalException extends RE2JSException {
+}
+declare class RE2 {
+	static initTest(expr: any): RE2;
+	/**
+	 * Parses a regular expression and returns, if successful, an {@code RE2} instance that can be
+	 * used to match against text.
+	 *
+	 * When matching against text, the regexp returns a match that begins as early as possible in the
+	 * input (leftmost), and among those it chooses the one that a backtracking search would have
+	 * found first. This so-called leftmost-first matching is the same semantics that Perl, Python,
+	 * and other implementations use, although this package implements it without the expense of
+	 * backtracking. For POSIX leftmost-longest matching, see {@link #compilePOSIX}.
+	 */
+	static compile(expr: any): RE2;
+	/**
+	 * {@code compilePOSIX} is like {@link #compile} but restricts the regular expression to POSIX ERE
+	 * (egrep) syntax and changes the match semantics to leftmost-longest.
+	 *
+	 * That is, when matching against text, the regexp returns a match that begins as early as
+	 * possible in the input (leftmost), and among those it chooses a match that is as long as
+	 * possible. This so-called leftmost-longest matching is the same semantics that early regular
+	 * expression implementations used and that POSIX specifies.
+	 *
+	 * However, there can be multiple leftmost-longest matches, with different submatch choices, and
+	 * here this package diverges from POSIX. Among the possible leftmost-longest matches, this
+	 * package chooses the one that a backtracking search would have found first, while POSIX
+	 * specifies that the match be chosen to maximize the length of the first subexpression, then the
+	 * second, and so on from left to right. The POSIX rule is computationally prohibitive and not
+	 * even well-defined. See http://swtch.com/~rsc/regexp/regexp2.html#posix
+	 */
+	static compilePOSIX(expr: any): RE2;
+	static compileImpl(expr: any, mode: any, longest: any): RE2;
+	/**
+	 * Returns true iff textual regular expression {@code pattern} matches string {@code s}.
+	 *
+	 * More complicated queries need to use {@link #compile} and the full {@code RE2} interface.
+	 */
+	static match(pattern: any, s: any): boolean;
+	constructor(expr: any, prog: any, numSubexp?: number, longest?: number);
+	expr: any;
+	prog: any;
+	numSubexp: number;
+	longest: number;
+	cond: any;
+	prefix: any;
+	prefixUTF8: any;
+	prefixComplete: boolean;
+	prefixRune: number;
+	pooled: AtomicReference;
+	dfa: DFA;
+	onepass: {
+		start: any;
+		numCap: any;
+		inst: any[];
+	};
+	prefilter: any;
+	matchPrefixComplete(input: any, pos: any, anchor: any, ncap: any): number[];
+	executeEngine(input: any, pos: any, anchor: any, ncap: any): any;
+	/**
+	 * Returns the number of parenthesized subexpressions in this regular expression.
+	 */
+	numberOfCapturingGroups(): number;
+	/**
+	 * Returns the number of instructions in this compiled regular expression program.
+	 */
+	numberOfInstructions(): any;
+	get(): any;
+	reset(): void;
+	put(m: any, isNew: any): void;
+	toString(): any;
+	doExecuteNFA(input: any, pos: any, anchor: any, ncap: any): any;
+	match(s: any): boolean;
+	/**
+	 * Matches the regular expression against input starting at position start and ending at position
+	 * end, with the given anchoring. Records the submatch boundaries in group, which is [start, end)
+	 * pairs of byte offsets. The number of boundaries needed is inferred from the size of the group
+	 * array. It is most efficient not to ask for submatch boundaries.
+	 *
+	 * @param input the input byte array
+	 * @param start the beginning position in the input
+	 * @param end the end position in the input
+	 * @param anchor the anchoring flag (UNANCHORED, ANCHOR_START, ANCHOR_BOTH)
+	 * @param group the array to fill with submatch positions
+	 * @param ngroup the number of array pairs to fill in
+	 * @returns true if a match was found
+	 */
+	matchWithGroup(input: any, start: any, end: any, anchor: any, ngroup: any): any[];
+	matchMachineInput(input: any, start: any, end: any, anchor: any, ngroup: any): any[];
+	/**
+	 * Returns true iff this regexp matches the UTF-8 byte array {@code b}.
+	 */
+	matchUTF8(b: any): boolean;
+	/**
+	 * Returns a copy of {@code src} in which all matches for this regexp have been replaced by
+	 * {@code repl}. No support is provided for expressions (e.g. {@code \1} or {@code $1}) in the
+	 * replacement string.
+	 */
+	replaceAll(src: any, repl: any): string;
+	/**
+	 * Returns a copy of {@code src} in which only the first match for this regexp has been replaced
+	 * by {@code repl}. No support is provided for expressions (e.g. {@code \1} or {@code $1}) in the
+	 * replacement string.
+	 */
+	replaceFirst(src: any, repl: any): string;
+	/**
+	 * Returns a copy of {@code src} in which at most {@code maxReplaces} matches for this regexp have
+	 * been replaced by the return value of of function {@code repl} (whose first argument is the
+	 * matched string). No support is provided for expressions (e.g. {@code \1} or {@code $1}) in the
+	 * replacement string.
+	 */
+	replaceAllFunc(src: any, replFunc: any, maxReplaces: any): string;
+	pad(a: any): any;
+	allMatches(input: any, n: any, deliverFun?: (v: any) => any): any[];
+	/**
+	 * Returns an array holding the text of the leftmost match in {@code b} of this regular
+	 * expression.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findUTF8(b: any): any;
+	/**
+	 * Returns a two-element array of integers defining the location of the leftmost match in
+	 * {@code b} of this regular expression. The match itself is at {@code b[loc[0]...loc[1]]}.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findUTF8Index(b: any): any;
+	/**
+	 * Returns a string holding the text of the leftmost match in {@code s} of this regular
+	 * expression.
+	 *
+	 * If there is no match, the return value is an empty string, but it will also be empty if the
+	 * regular expression successfully matches an empty string. Use {@link #findIndex} or
+	 * {@link #findSubmatch} if it is necessary to distinguish these cases.
+	 */
+	find(s: any): any;
+	/**
+	 * Returns a two-element array of integers defining the location of the leftmost match in
+	 * {@code s} of this regular expression. The match itself is at
+	 * {@code s.substring(loc[0], loc[1])}.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findIndex(s: any): any;
+	/**
+	 * Returns an array of arrays the text of the leftmost match of the regular expression in
+	 * {@code b} and the matches, if any, of its subexpressions, as defined by the <a
+	 * href='#submatch'>Submatch</a> description above.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findUTF8Submatch(b: any): any[];
+	/**
+	 * Returns an array holding the index pairs identifying the leftmost match of this regular
+	 * expression in {@code b} and the matches, if any, of its subexpressions, as defined by the the
+	 * <a href='#submatch'>Submatch</a> and <a href='#index'>Index</a> descriptions above.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findUTF8SubmatchIndex(b: any): any;
+	/**
+	 * Returns an array of strings holding the text of the leftmost match of the regular expression in
+	 * {@code s} and the matches, if any, of its subexpressions, as defined by the <a
+	 * href='#submatch'>Submatch</a> description above.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findSubmatch(s: any): any[];
+	/**
+	 * Returns an array holding the index pairs identifying the leftmost match of this regular
+	 * expression in {@code s} and the matches, if any, of its subexpressions, as defined by the <a
+	 * href='#submatch'>Submatch</a> description above.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findSubmatchIndex(s: any): any;
+	/**
+	 * {@code findAllUTF8()} is the <a href='#all'>All</a> version of {@link #findUTF8}; it returns a
+	 * list of up to {@code n} successive matches of the expression, as defined by the <a
+	 * href='#all'>All</a> description above.
+	 *
+	 * A return value of null indicates no match.
+	 *
+	 * TODO(adonovan): think about defining a byte slice view class, like a read-only Go slice backed
+	 * by |b|.
+	 */
+	findAllUTF8(b: any, n: any): any[];
+	/**
+	 * {@code findAllUTF8Index} is the <a href='#all'>All</a> version of {@link #findUTF8Index}; it
+	 * returns a list of up to {@code n} successive matches of the expression, as defined by the <a
+	 * href='#all'>All</a> description above.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findAllUTF8Index(b: any, n: any): any[];
+	/**
+	 * {@code findAll} is the <a href='#all'>All</a> version of {@link #find}; it returns a list of up
+	 * to {@code n} successive matches of the expression, as defined by the <a href='#all'>All</a>
+	 * description above.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findAll(s: any, n: any): any[];
+	/**
+	 * {@code findAllIndex} is the <a href='#all'>All</a> version of {@link #findIndex}; it returns a
+	 * list of up to {@code n} successive matches of the expression, as defined by the <a
+	 * href='#all'>All</a> description above.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findAllIndex(s: any, n: any): any[];
+	/**
+	 * {@code findAllUTF8Submatch} is the <a href='#all'>All</a> version of {@link #findUTF8Submatch};
+	 * it returns a list of up to {@code n} successive matches of the expression, as defined by the <a
+	 * href='#all'>All</a> description above.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findAllUTF8Submatch(b: any, n: any): any[];
+	/**
+	 * {@code findAllUTF8SubmatchIndex} is the <a href='#all'>All</a> version of
+	 * {@link #findUTF8SubmatchIndex}; it returns a list of up to {@code n} successive matches of the
+	 * expression, as defined by the <a href='#all'>All</a> description above.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findAllUTF8SubmatchIndex(b: any, n: any): any[];
+	/**
+	 * {@code findAllSubmatch} is the <a href='#all'>All</a> version of {@link #findSubmatch}; it
+	 * returns a list of up to {@code n} successive matches of the expression, as defined by the <a
+	 * href='#all'>All</a> description above.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findAllSubmatch(s: any, n: any): any[];
+	/**
+	 * {@code findAllSubmatchIndex} is the <a href='#all'>All</a> version of
+	 * {@link #findSubmatchIndex}; it returns a list of up to {@code n} successive matches of the
+	 * expression, as defined by the <a href='#all'>All</a> description above.
+	 *
+	 * A return value of null indicates no match.
+	 */
+	findAllSubmatchIndex(s: any, n: any): any[];
+}
+declare class AtomicReference {
+	constructor(initialValue: any);
+	value: any;
+	get(): any;
+	set(newValue: any): void;
+	compareAndSet(expect: any, update: any): boolean;
+}
+/**
+ * Creates an RE2JS regex directly from a template literal.
+ * @overload
+ * @param {TemplateStringsArray} stringsOrFlags - The raw string segments of the template literal.
+ * @param {...any} values - The interpolated values.
+ * @returns {RE2JS}
+ */
+export function re(stringsOrFlags: TemplateStringsArray, ...values: any[]): RE2JS;
+/**
+ * Creates a template literal tag function with specific RE2JS flags.
+ * @overload
+ * @param {number} stringsOrFlags - The RE2JS flags to apply (e.g., RE2JS.CASE_INSENSITIVE).
+ * @returns {(strings: TemplateStringsArray, ...tagValues: any[]) => RE2JS}
+ */
+export function re(stringsOrFlags: number): (strings: TemplateStringsArray, ...tagValues: any[]) => RE2JS;
+/**
+ * A compiled representation of an RE2 regular expression
+ *
+ * The matching functions take {@code String} arguments instead of the more general Java
+ * {@code CharSequence} since the latter doesn't provide UTF-16 decoding.
+ *
+ *
+ * @author rsc@google.com (Russ Cox)
+ * @class
+ */
+export class RE2JS {
+	/**
+	 * Flag: case insensitive matching.
+	 */
+	static CASE_INSENSITIVE: number;
+	/**
+	 * Flag: dot ({@code .}) matches all characters, including newline.
+	 */
+	static DOTALL: number;
+	/**
+	 * Flag: multiline matching: {@code ^} and {@code $} match at beginning and end of line, not just
+	 * beginning and end of input.
+	 */
+	static MULTILINE: number;
+	/**
+	 * Flag: Unicode groups (e.g. {@code \p\ Greek\} ) will be syntax errors.
+	 */
+	static DISABLE_UNICODE_GROUPS: number;
+	/**
+	 * Flag: matches longest possible string.
+	 */
+	static LONGEST_MATCH: number;
+	/**
+	 * Flag: enable linear-time captureless lookbehinds.
+	 */
+	static LOOKBEHINDS: number;
+	/**
+	 * Returns a literal pattern string for the specified string.
+	 *
+	 * This method produces a string that can be used to create a <code>RE2JS</code> that would
+	 * match the string <code>s</code> as if it were a literal pattern.
+	 *
+	 * Metacharacters or escape sequences in the input sequence will be given no special meaning.
+	 *
+	 * @param {string} str The string to be literalized
+	 * @returns {string} A literal string replacement
+	 */
+	static quote(str: string): string;
+	/**
+	 * Quotes '\' and '$' in {@code str}, so that the returned string could be used in
+	 * replacement methods as a literal replacement of {@code str}.
+	 *
+	 * This is a convenience delegation to {@link Matcher.quoteReplacement}.
+	 *
+	 * @param {string} str the string to be quoted
+	 * @param {boolean} [javaMode=false] whether the replacement will be used in javaMode
+	 * @returns {string} the quoted string
+	 */
+	static quoteReplacement(str: string, javaMode?: boolean): string;
+	/**
+	 * Translates a given regular expression string to ensure compatibility with RE2JS.
+	 *
+	 * This function preprocesses the input regex string by applying necessary transformations,
+	 * such as escaping special characters (e.g., `/`), converting named capture groups to
+	 * RE2JS-compatible syntax, and handling Unicode sequences properly. It ensures that the
+	 * resulting regex is safe and properly formatted before compilation.
+	 *
+	 * @param {string|RegExp} expr - The regular expression string to be translated.
+	 * @returns {string} - The transformed regular expression string, ready for compilation.
+	 */
+	static translateRegExp(expr: string | RegExp): string;
+	/**
+	 * Helper: create new RE2JS with given regex and flags. Flregex is the regex with flags applied.
+	 * @param {string} regex
+	 * @param {number} [flags=0]
+	 * @returns {RE2JS}
+	 */
+	static compile(regex: string, flags?: number): RE2JS;
+	/**
+	 * Matches a string against a regular expression.
+	 *
+	 * @param {string} regex the regular expression
+	 * @param {string|number[]|Uint8Array} input the input
+	 * @returns {boolean} true if the regular expression matches the entire input
+	 * @throws RE2JSSyntaxException if the regular expression is malformed
+	 */
+	static matches(regex: string, input: string | number[] | Uint8Array): boolean;
+	/**
+	 * This is visible for testing.
+	 * @private
+	 */
+	private static initTest;
+	/**
+	 *
+	 * @param {string} pattern
+	 * @param {number} flags
+	 */
+	constructor(pattern: string, flags: number);
+	patternInput: string;
+	flagsInput: number;
+	/** @type {import('./RE2.js').RE2} */
+	re2Input: RE2;
+	/**
+	 * Releases memory used by internal caches associated with this pattern. Does not change the
+	 * observable behaviour. Useful for tests that detect memory leaks via allocation tracking.
+	 */
+	reset(): void;
+	/**
+	 * Returns the flags used in the constructor.
+	 * @returns {number}
+	 */
+	flags(): number;
+	/**
+	 * Returns the pattern used in the constructor.
+	 * @returns {string}
+	 */
+	pattern(): string;
+	re2(): RE2;
+	/**
+	 * Matches a string against a regular expression.
+	 *
+	 * @param {string|number[]|Uint8Array} input the input
+	 * @returns {boolean} true if the regular expression matches the entire input
+	 */
+	matches(input: string | number[] | Uint8Array): boolean;
+	/**
+	 * Creates a new {@code Matcher} matching the pattern against the input.
+	 *
+	 * @param {string|number[]|Uint8Array|MatcherInputBase} input the input string
+	 * @returns {Matcher}
+	 */
+	matcher(input: string | number[] | Uint8Array | MatcherInputBase): Matcher;
+	/**
+	 * Tests whether the regular expression matches any part of the input string.
+	 * Performance Note: This method is highly optimized. Because it only returns
+	 * a boolean and does not extract capture groups, it bypasses the `Matcher` overhead
+	 * and guarantees execution on the high-speed DFA engine whenever possible.
+	 *
+	 * @param {string|number[]|Uint8Array} input - The input string or UTF-8 byte array to test against.
+	 * @returns {boolean} `true` if the pattern is found anywhere in the input, `false` otherwise.
+	 */
+	test(input: string | number[] | Uint8Array): boolean;
+	/**
+	 * Tests whether the regular expression matches the ENTIRE input string.
+	 * * **Performance Note:** This operates identically to `.matches()`, but is significantly
+	 * faster because it does not request capture group data. By requesting 0 capture groups,
+	 * it securely routes execution through the DFA fast-path.
+	 *
+	 * @param {string|number[]|Uint8Array} input - The input string or UTF-8 byte array to test against.
+	 * @returns {boolean} `true` if the exact input string fully matches the pattern, `false` otherwise.
+	 */
+	testExact(input: string | number[] | Uint8Array): boolean;
+	/**
+	 * Splits input around instances of the regular expression. It returns an array giving the strings
+	 * that occur before, between, and after instances of the regular expression.
+	 *
+	 * If {@code limit <= 0}, there is no limit on the size of the returned array. If
+	 * {@code limit == 0}, empty strings that would occur at the end of the array are omitted. If
+	 * {@code limit > 0}, at most limit strings are returned. The final string contains the remainder
+	 * of the input, possibly including additional matches of the pattern.
+	 *
+	 * @param {string} input the input string to be split
+	 * @param {number} [limit=0] the limit
+	 * @returns {string[]} the split strings
+	 */
+	split(input: string, limit?: number): string[];
+	/**
+	 * Returns an iterator of all results matching a string against the regular expression,
+	 * including capturing groups.
+	 *
+	 * @param {string|number[]|Uint8Array} input the input string or byte array
+	 * @returns {IterableIterator<Array>}
+	 */
+	matchAll(input: string | number[] | Uint8Array): IterableIterator<any[]>;
+	/**
+	 *
+	 * @returns {string}
+	 */
+	toString(): string;
+	/**
+	 * Returns the program size of this pattern.
+	 *
+	 * <p>
+	 * Similar to the C++ implementation, the program size is a very approximate measure of a regexp's
+	 * "cost". Larger numbers are more expensive than smaller numbers.
+	 * </p>
+	 *
+	 * @returns {number} the program size of this pattern
+	 */
+	programSize(): number;
+	/**
+	 * Returns the number of capturing groups in this matcher's pattern. Group zero denotes the entire
+	 * pattern and is excluded from this count.
+	 *
+	 * @returns {number} the number of capturing groups in this pattern
+	 */
+	groupCount(): number;
+	/**
+	 * Return a map of the capturing groups in this matcher's pattern, where key is the name and value
+	 * is the index of the group in the pattern.
+	 * @returns {Record<string, number>}
+	 */
+	namedGroups(): Record<string, number>;
+	/**
+	 *
+	 * @param {*} other
+	 * @returns {boolean}
+	 */
+	equals(other: any): boolean;
+}
+
+export {};