@bufbuild/re2 0.0.1-alpha.1

package/dist/cjs/Utils.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_NO_WORD_BOUNDARY = exports.EMPTY_END_TEXT = exports.EMPTY_BEGIN_TEXT = exports.EMPTY_WORD_BOUNDARY = exports.EMPTY_END_LINE = exports.EMPTY_BEGIN_LINE = void 0;
+exports.emptyInts = emptyInts;
+exports.runeToString = runeToString;
+exports.emptyOpContext = emptyOpContext;
+exports.charCount = charCount;
+exports.stringToRunes = stringToRunes;
+exports.isalnum = isalnum;
+exports.unhex = unhex;
+exports.quoteMeta = quoteMeta;
+const Unicode_js_1 = require("./Unicode.js");
+const chars_js_1 = require("./chars.js");
+/**
+ * Various constants and helper utilities.
+ */
+const METACHARACTERS = "\\.+*?()|[]{}^$";
+//// EMPTY_* flags
+const EMPTY_BEGIN_LINE = 0x01;
+exports.EMPTY_BEGIN_LINE = EMPTY_BEGIN_LINE;
+const EMPTY_END_LINE = 0x02;
+exports.EMPTY_END_LINE = EMPTY_END_LINE;
+const EMPTY_BEGIN_TEXT = 0x04;
+exports.EMPTY_BEGIN_TEXT = EMPTY_BEGIN_TEXT;
+const EMPTY_END_TEXT = 0x08;
+exports.EMPTY_END_TEXT = EMPTY_END_TEXT;
+const EMPTY_WORD_BOUNDARY = 0x10;
+exports.EMPTY_WORD_BOUNDARY = EMPTY_WORD_BOUNDARY;
+const EMPTY_NO_WORD_BOUNDARY = 0x20;
+exports.EMPTY_NO_WORD_BOUNDARY = EMPTY_NO_WORD_BOUNDARY;
+function emptyInts() {
+    return [];
+}
+// Returns true iff |c| is an ASCII letter or decimal digit.
+function isalnum(c) {
+    return ((0x30 <= c && c <= 0x39) ||
+        (0x61 <= c && c <= 0x7a) ||
+        (0x41 <= c && c <= 0x5a));
+}
+// If |c| is an ASCII hex digit, returns its value, otherwise -1.
+function unhex(c) {
+    if (0x30 <= c && c <= 0x39) {
+        return c - 0x30;
+    }
+    if (0x61 <= c && c <= 0x66) {
+        return c - 0x61 + 10;
+    }
+    if (0x41 <= c && c <= 0x46) {
+        return c - 0x41 + 10;
+    }
+    return -1;
+}
+// Returns the array of runes in the specified UTF-16 string.
+function stringToRunes(str) {
+    return Array.from(String(str)).map((s) => (0, chars_js_1.codePointAtOrThrow)(s, 0));
+}
+// Returns the Java UTF-16 string containing the single rune |r|.
+function runeToString(r) {
+    return String.fromCodePoint(r);
+}
+// isWordRune reports whether r is consider a ``word character''
+// during the evaluation of the \b and \B zero-width assertions.
+// These assertions are ASCII-only: the word characters are [A-Za-z0-9_].
+function isWordRune(r) {
+    return ((0x61 <= r && r <= 0x7a) ||
+        (0x41 <= r && r <= 0x5a) ||
+        (0x30 <= r && r <= 0x39) ||
+        r === 0x5f);
+}
+// emptyOpContext returns the zero-width assertions satisfied at the position
+// between the runes r1 and r2, a bitmask of EMPTY_* flags.
+// Passing r1 == -1 indicates that the position is at the beginning of the
+// text.
+// Passing r2 == -1 indicates that the position is at the end of the text.
+// eslint-disable-next-line no-warning-comments
+// TODO(adonovan): move to Machine.
+function emptyOpContext(r1, r2) {
+    let op = 0;
+    if (r1 < 0) {
+        op |= EMPTY_BEGIN_TEXT | EMPTY_BEGIN_LINE;
+    }
+    if (r1 === 0x0a) {
+        op |= EMPTY_BEGIN_LINE;
+    }
+    if (r2 < 0) {
+        op |= EMPTY_END_TEXT | EMPTY_END_LINE;
+    }
+    if (r2 === 0x0a) {
+        op |= EMPTY_END_LINE;
+    }
+    if (isWordRune(r1) !== isWordRune(r2)) {
+        op |= EMPTY_WORD_BOUNDARY;
+    }
+    else {
+        op |= EMPTY_NO_WORD_BOUNDARY;
+    }
+    return op;
+}
+/**
+ * Returns a string that quotes all regular expression metacharacters inside the argument text;
+ * the returned string is a regular expression matching the literal text. For example,
+ * {@code quoteMeta("[foo]").equals("\\[foo\\]")}.
+ * @param {string} str
+ * @returns {string}
+ */
+function quoteMeta(str) {
+    return str
+        .split("") // A char loop is correct because all metacharacters fit in one UTF-16 code.
+        .map((s) => {
+        if (METACHARACTERS.indexOf(s) >= 0) {
+            return `\\${s}`;
+        }
+        return s;
+    })
+        .join("");
+}
+function charCount(codePoint) {
+    return codePoint > Unicode_js_1.MAX_BMP ? 2 : 1;
+}

package/dist/cjs/__fixtures__/find.d.ts

@@ -0,0 +1,9 @@
+declare class Test {
+    pat: string;
+    text: string;
+    matches: number[][];
+    constructor(pat: string, text: string, n: number, ...x: number[]);
+    toString(): string;
+}
+export declare const FIND_TESTS: Test[];
+export {};

package/dist/cjs/__fixtures__/find.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIND_TESTS = void 0;
+class Test {
+    pat;
+    text;
+    matches;
+    constructor(pat, text, n, ...x) {
+        this.pat = pat;
+        this.text = text;
+        this.matches = [];
+        if (n > 0) {
+            const runLength = Math.floor(x.length / n);
+            for (let i = 0, j = 0; i < n; i++) {
+                this.matches[i] = x.slice(j, j + runLength);
+                j += runLength;
+                if (j > x.length) {
+                    throw new Error("invalid build entry");
+                }
+            }
+        }
+    }
+    toString() {
+        return `pat=${this.pat} text=${this.text} len=${this.matches.length} matches=${JSON.stringify(this.matches)}`;
+    }
+}
+exports.FIND_TESTS = [
+    new Test("", "", 1, 0, 0),
+    new Test("^abcdefg", "abcdefg", 1, 0, 7),
+    new Test("a+", "baaab", 1, 1, 4),
+    new Test("abcd..", "abcdef", 1, 0, 6),
+    new Test("a", "a", 1, 0, 1),
+    new Test("x", "y", 0),
+    new Test("b", "abc", 1, 1, 2),
+    new Test(".", "a", 1, 0, 1),
+    new Test(".*", "abcdef", 1, 0, 6),
+    new Test("^", "abcde", 1, 0, 0),
+    new Test("$", "abcde", 1, 5, 5),
+    new Test("^abcd$", "abcd", 1, 0, 4),
+    new Test("^bcd'", "abcdef", 0),
+    new Test("^abcd$", "abcde", 0),
+    new Test("h.*od?", "hello\ngoodbye\n", 1, 0, 5),
+    new Test("a{1,5}", "baaac", 1, 1, 4),
+    new Test("ac{1,25}", "bbaaaccccdd", 1, 4, 9),
+    new Test("a+", "baaab", 1, 1, 4),
+    new Test("a*", "baaab", 3, 0, 0, 1, 4, 5, 5),
+    new Test("[a-z]+", "abcd", 1, 0, 4),
+    new Test("[^a-z]+", "ab1234cd", 1, 2, 6),
+    new Test("[a\\-\\]z]+", "az]-bcz", 2, 0, 4, 6, 7),
+    new Test("[^\\n]+", "abcd\n", 1, 0, 4),
+    new Test("[日本語]+", "日本語日本語", 1, 0, 18),
+    new Test("日本語+", "日本語", 1, 0, 9),
+    new Test("日本語+", "日本語語語語", 1, 0, 18),
+    new Test("()", "", 1, 0, 0, 0, 0),
+    new Test("(a)", "a", 1, 0, 1, 0, 1),
+    new Test("(.)(.)", "日a", 1, 0, 4, 0, 3, 3, 4),
+    new Test("(.*)", "", 1, 0, 0, 0, 0),
+    new Test("(.*)", "abcd", 1, 0, 4, 0, 4),
+    new Test("(..)(..)", "abcd", 1, 0, 4, 0, 2, 2, 4),
+    new Test("(([^xyz]*)(d))", "abcd", 1, 0, 4, 0, 4, 0, 3, 3, 4),
+    new Test("((a|b|c)*(d))", "abcd", 1, 0, 4, 0, 4, 2, 3, 3, 4),
+    new Test("(((a|b|c)*)(d))", "abcd", 1, 0, 4, 0, 4, 0, 3, 2, 3, 3, 4),
+    new Test("\\a\\f\\n\\r\\t\\v", "\x07\f\n\r\t\v", 1, 0, 6),
+    new Test("[\\a\\f\\n\\r\\t\\v]+", "\x07\f\n\r\t\v", 1, 0, 6),
+    new Test("a*(|(b))c*", "aacc", 1, 0, 4, 2, 2, -1, -1),
+    new Test("(.*).*", "ab", 1, 0, 2, 0, 2),
+    new Test("[.]", ".", 1, 0, 1),
+    new Test("/$", "/abc/", 1, 4, 5),
+    new Test("/$", "/abc", 0),
+    // multiple matches
+    new Test(".", "abc", 3, 0, 1, 1, 2, 2, 3),
+    new Test("(.)", "abc", 3, 0, 1, 0, 1, 1, 2, 1, 2, 2, 3, 2, 3),
+    new Test(".(.)", "abcd", 2, 0, 2, 1, 2, 2, 4, 3, 4),
+    new Test("ab*", "abbaab", 3, 0, 3, 3, 4, 4, 6),
+    new Test("a(b*)", "abbaab", 3, 0, 3, 1, 3, 3, 4, 4, 4, 4, 6, 5, 6),
+    // fixed bugs
+    new Test("ab$", "cab", 1, 1, 3),
+    new Test("axxb$", "axxcb", 0),
+    new Test("data", "daXY data", 1, 5, 9),
+    new Test("da(.)a$", "daXY data", 1, 5, 9, 7, 8),
+    new Test("zx+", "zzx", 1, 1, 3),
+    new Test("ab$", "abcab", 1, 3, 5),
+    new Test("(aa)*$", "a", 1, 1, 1, -1, -1),
+    new Test("(?:.|(?:.a))", "", 0),
+    new Test("(?:A(?:A|a))", "Aa", 1, 0, 2),
+    new Test("(?:A|(?:A|a))", "a", 1, 0, 1),
+    new Test("(a){0}", "", 1, 0, 0, -1, -1),
+    new Test("(?-s)(?:(?:^).)", "\n", 0),
+    new Test("(?s)(?:(?:^).)", "\n", 1, 0, 1),
+    new Test("(?:(?:^).)", "\n", 0),
+    new Test("\\b", "x", 2, 0, 0, 1, 1),
+    new Test("\\b", "xx", 2, 0, 0, 2, 2),
+    new Test("\\b", "x y", 4, 0, 0, 1, 1, 2, 2, 3, 3),
+    new Test("\\b", "xx yy", 4, 0, 0, 2, 2, 3, 3, 5, 5),
+    new Test("\\B", "x", 0),
+    new Test("\\B", "xx", 1, 1, 1),
+    new Test("\\B", "x y", 0),
+    new Test("\\B", "xx yy", 2, 1, 1, 4, 4),
+    // RE2 tests
+    new Test("[^\\S\\s]", "abcd", 0),
+    new Test("[^\\S[:space:]]", "abcd", 0),
+    new Test("[^\\D\\d]", "abcd", 0),
+    new Test("[^\\D[:digit:]]", "abcd", 0),
+    new Test("(?i)\\W", "x", 0),
+    new Test("(?i)\\W", "k", 0),
+    new Test("(?i)\\W", "s", 0),
+    // can backslash-escape any punctuation
+    new Test("\\!\\\"\\#\\$\\%\\&\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\{\\|\\}\\~", "!\"#$%&'()*+,-./:;<=>?@[\\]^_{|}~", 1, 0, 31),
+    new Test("[\\!\\\"\\#\\$\\%\\&\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\{\\|\\}\\~]+", "!\"#$%&'()*+,-./:;<=>?@[\\]^_{|}~", 1, 0, 31),
+    new Test("\\`", "`", 1, 0, 1),
+    new Test("[\\`]+", "`", 1, 0, 1),
+    // long set of matches
+    new Test(".", "qwertyuiopasdfghjklzxcvbnm1234567890", 36, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36),
+    new Test("(|a)*", "aa", 3, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2),
+];

package/dist/cjs/chars.d.ts

@@ -0,0 +1,2 @@
+export declare const codePoint: (v: string) => number;
+export declare const codePointAtOrThrow: (s: string, i: number) => number;

package/dist/cjs/chars.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codePointAtOrThrow = exports.codePoint = void 0;
+const codePoint = (v) => {
+    const cp = v.codePointAt(0);
+    if (cp === undefined) {
+        throw new Error("codePoint: empty string");
+    }
+    return cp;
+};
+exports.codePoint = codePoint;
+const codePointAtOrThrow = (s, i) => {
+    const cp = s.codePointAt(i);
+    if (cp === undefined) {
+        throw new Error(`codePointAt(${i}) returned undefined for ${JSON.stringify(s)}`);
+    }
+    return cp;
+};
+exports.codePointAtOrThrow = codePointAtOrThrow;

package/dist/cjs/exceptions.d.ts

@@ -0,0 +1,55 @@
+declare class RE2JSException extends Error {
+    /** @param {string} message */
+    constructor(message: string);
+}
+/**
+ * An exception thrown by the parser if the pattern was invalid.
+ */
+declare class RE2JSSyntaxException extends RE2JSException {
+    error: string;
+    input: string | null;
+    /**
+     * @param {string} error
+     * @param {string|null} [input=null]
+     */
+    constructor(error: string, 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
+ */
+declare class RE2JSCompileException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message: string);
+}
+/**
+ * An exception thrown by using groups
+ */
+declare class RE2JSGroupException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message: string);
+}
+/**
+ * An exception thrown by flags
+ */
+declare class RE2JSFlagsException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message: string);
+}
+/**
+ * An exception thrown for internal engine errors, such as corrupted bytecodes.
+ */
+declare class RE2JSInternalException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message: string);
+}
+export { RE2JSException, RE2JSSyntaxException, RE2JSCompileException, RE2JSGroupException, RE2JSFlagsException, RE2JSInternalException, };

package/dist/cjs/exceptions.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RE2JSInternalException = exports.RE2JSFlagsException = exports.RE2JSGroupException = exports.RE2JSCompileException = exports.RE2JSSyntaxException = exports.RE2JSException = void 0;
+class RE2JSException extends Error {
+    /** @param {string} message */
+    constructor(message) {
+        super(message);
+        this.name = "RE2JSException";
+    }
+}
+exports.RE2JSException = RE2JSException;
+/**
+ * An exception thrown by the parser if the pattern was invalid.
+ */
+class RE2JSSyntaxException extends RE2JSException {
+    error;
+    input;
+    /**
+     * @param {string} error
+     * @param {string|null} [input=null]
+     */
+    constructor(error, input = null) {
+        let message = `error parsing regexp: ${error}`;
+        if (input) {
+            message += `: \`${input}\``;
+        }
+        super(message);
+        this.name = "RE2JSSyntaxException";
+        this.message = message;
+        /** @type {string} */
+        this.error = error;
+        /** @type {string|null} */
+        this.input = input;
+    }
+    /**
+     * Retrieves the description of the error.
+     * @returns {string}
+     */
+    getDescription() {
+        return this.error;
+    }
+    /**
+     * Retrieves the erroneous regular-expression pattern.
+     * @returns {string|null}
+     */
+    getPattern() {
+        return this.input;
+    }
+}
+exports.RE2JSSyntaxException = RE2JSSyntaxException;
+/**
+ * An exception thrown by the compiler
+ */
+class RE2JSCompileException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message) {
+        super(message);
+        this.name = "RE2JSCompileException";
+    }
+}
+exports.RE2JSCompileException = RE2JSCompileException;
+/**
+ * An exception thrown by using groups
+ */
+class RE2JSGroupException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message) {
+        super(message);
+        this.name = "RE2JSGroupException";
+    }
+}
+exports.RE2JSGroupException = RE2JSGroupException;
+/**
+ * An exception thrown by flags
+ */
+class RE2JSFlagsException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message) {
+        super(message);
+        this.name = "RE2JSFlagsException";
+    }
+}
+exports.RE2JSFlagsException = RE2JSFlagsException;
+/**
+ * An exception thrown for internal engine errors, such as corrupted bytecodes.
+ */
+class RE2JSInternalException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message) {
+        super(message);
+        this.name = "RE2JSInternalException";
+    }
+}
+exports.RE2JSInternalException = RE2JSInternalException;

package/dist/cjs/index.d.ts

@@ -0,0 +1,102 @@
+import { RE2 } from "./RE2.js";
+export { RE2JSCompileException, RE2JSException, RE2JSFlagsException, RE2JSGroupException, RE2JSInternalException, RE2JSSyntaxException, } from "./exceptions.js";
+/**
+ * A compiled representation of an RE2 regular expression
+ */
+export declare class RE2JS {
+    patternInput: string;
+    flagsInput: number;
+    re2Input: RE2;
+    /**
+     * 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;
+    /**
+     * Returns a literal pattern string for the specified string.
+     *
+     * @param {string} str The string to be literalized
+     * @returns {string} A literal string replacement
+     */
+    static quote(str: string): string;
+    /**
+     * Helper: create new RE2JS with given regex and flags.
+     * @param {string} regex
+     * @param {number} [flags=0]
+     * @returns {RE2JS}
+     */
+    static compile(regex: string, flags?: number): RE2JS;
+    static validateFlags(flags: number): void;
+    static buildRegexWithFlags(regex: string, flags?: number): string;
+    /**
+     * Matches a string against a regular expression.
+     *
+     * @param {string} regex the regular expression
+     * @param {string} 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): boolean;
+    /**
+     * @param {string} pattern
+     * @param {number} flags
+     */
+    constructor(pattern: string, flags?: number);
+    /**
+     * Releases memory used by internal caches associated with this pattern.
+     */
+    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} input the input
+     * @returns {boolean} true if the regular expression matches the entire input
+     */
+    matches(input: string): boolean;
+    /**
+     * Tests whether the regular expression matches any part of the input string.
+     *
+     * @param {string} input - The input string to test against.
+     * @returns {boolean} `true` if the pattern is found anywhere in the input, `false` otherwise.
+     */
+    test(input: string): boolean;
+    /**
+     * Tests whether the regular expression matches the ENTIRE input string.
+     *
+     * @param {string} input - The input string to test against.
+     * @returns {boolean} `true` if the exact input string fully matches the pattern, `false` otherwise.
+     */
+    testExact(input: string): boolean;
+    toString(): string;
+    /**
+     * Returns the number of capturing groups in this matcher's pattern.
+     */
+    groupCount(): number;
+    /**
+     * Return a map of the capturing groups in this matcher's pattern.
+     */
+    namedGroups(): Map<string, number>;
+}

package/dist/cjs/index.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RE2JS = exports.RE2JSSyntaxException = exports.RE2JSInternalException = exports.RE2JSGroupException = exports.RE2JSFlagsException = exports.RE2JSException = exports.RE2JSCompileException = void 0;
+const RE2Flags_js_1 = require("./RE2Flags.js");
+const MachineInput_js_1 = require("./MachineInput.js");
+const RE2_js_1 = require("./RE2.js");
+const Utils_js_1 = require("./Utils.js");
+const exceptions_js_1 = require("./exceptions.js");
+var exceptions_js_2 = require("./exceptions.js");
+Object.defineProperty(exports, "RE2JSCompileException", { enumerable: true, get: function () { return exceptions_js_2.RE2JSCompileException; } });
+Object.defineProperty(exports, "RE2JSException", { enumerable: true, get: function () { return exceptions_js_2.RE2JSException; } });
+Object.defineProperty(exports, "RE2JSFlagsException", { enumerable: true, get: function () { return exceptions_js_2.RE2JSFlagsException; } });
+Object.defineProperty(exports, "RE2JSGroupException", { enumerable: true, get: function () { return exceptions_js_2.RE2JSGroupException; } });
+Object.defineProperty(exports, "RE2JSInternalException", { enumerable: true, get: function () { return exceptions_js_2.RE2JSInternalException; } });
+Object.defineProperty(exports, "RE2JSSyntaxException", { enumerable: true, get: function () { return exceptions_js_2.RE2JSSyntaxException; } });
+/**
+ * A compiled representation of an RE2 regular expression
+ */
+class RE2JS {
+    patternInput;
+    flagsInput;
+    re2Input;
+    /**
+     * Flag: case insensitive matching.
+     */
+    static CASE_INSENSITIVE = 1;
+    /**
+     * Flag: dot ({@code .}) matches all characters, including newline.
+     */
+    static DOTALL = 2;
+    /**
+     * Flag: multiline matching: {@code ^} and {@code $} match at beginning and end of line, not just
+     * beginning and end of input.
+     */
+    static MULTILINE = 4;
+    /**
+     * Flag: Unicode groups (e.g. {@code \p{Greek}} ) will be syntax errors.
+     */
+    static DISABLE_UNICODE_GROUPS = 8;
+    /**
+     * Returns a literal pattern string for the specified string.
+     *
+     * @param {string} str The string to be literalized
+     * @returns {string} A literal string replacement
+     */
+    static quote(str) {
+        return (0, Utils_js_1.quoteMeta)(str);
+    }
+    /**
+     * Helper: create new RE2JS with given regex and flags.
+     * @param {string} regex
+     * @param {number} [flags=0]
+     * @returns {RE2JS}
+     */
+    static compile(regex, flags = 0) {
+        return new RE2JS(regex, flags);
+    }
+    static validateFlags(flags) {
+        if ((flags &
+            ~(RE2JS.MULTILINE |
+                RE2JS.DOTALL |
+                RE2JS.CASE_INSENSITIVE |
+                RE2JS.DISABLE_UNICODE_GROUPS)) !==
+            0) {
+            throw new exceptions_js_1.RE2JSFlagsException("Flags should only be a combination of MULTILINE, DOTALL, CASE_INSENSITIVE, DISABLE_UNICODE_GROUPS");
+        }
+    }
+    static buildRegexWithFlags(regex, flags = 0) {
+        let fregex = regex;
+        if ((flags & RE2JS.CASE_INSENSITIVE) !== 0) {
+            fregex = `(?i)${fregex}`;
+        }
+        if ((flags & RE2JS.DOTALL) !== 0) {
+            fregex = `(?s)${fregex}`;
+        }
+        if ((flags & RE2JS.MULTILINE) !== 0) {
+            fregex = `(?m)${fregex}`;
+        }
+        return fregex;
+    }
+    /**
+     * Matches a string against a regular expression.
+     *
+     * @param {string} regex the regular expression
+     * @param {string} 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, input) {
+        return RE2JS.compile(regex).testExact(input);
+    }
+    /**
+     * @param {string} pattern
+     * @param {number} flags
+     */
+    constructor(pattern, flags = 0) {
+        let re2Flags = RE2Flags_js_1.PERL;
+        if ((flags & RE2JS.DISABLE_UNICODE_GROUPS) !== 0) {
+            re2Flags &= ~RE2Flags_js_1.UNICODE_GROUPS;
+        }
+        RE2JS.validateFlags(flags);
+        const fregex = RE2JS.buildRegexWithFlags(pattern, flags);
+        this.patternInput = pattern;
+        this.flagsInput = flags;
+        this.re2Input = RE2_js_1.RE2.compileImpl(fregex, re2Flags);
+    }
+    /**
+     * Releases memory used by internal caches associated with this pattern.
+     */
+    reset() {
+        this.re2Input.reset();
+    }
+    /**
+     * Returns the flags used in the constructor.
+     * @returns {number}
+     */
+    flags() {
+        return this.flagsInput;
+    }
+    /**
+     * Returns the pattern used in the constructor.
+     * @returns {string}
+     */
+    pattern() {
+        return this.patternInput;
+    }
+    re2() {
+        return this.re2Input;
+    }
+    /**
+     * Matches a string against a regular expression.
+     *
+     * @param {string} input the input
+     * @returns {boolean} true if the regular expression matches the entire input
+     */
+    matches(input) {
+        return this.testExact(input);
+    }
+    /**
+     * Tests whether the regular expression matches any part of the input string.
+     *
+     * @param {string} input - The input string to test against.
+     * @returns {boolean} `true` if the pattern is found anywhere in the input, `false` otherwise.
+     */
+    test(input) {
+        return this.re2Input.match(input);
+    }
+    /**
+     * Tests whether the regular expression matches the ENTIRE input string.
+     *
+     * @param {string} input - The input string to test against.
+     * @returns {boolean} `true` if the exact input string fully matches the pattern, `false` otherwise.
+     */
+    testExact(input) {
+        return (this.re2Input.executeEngine((0, MachineInput_js_1.fromUTF16)(input), 0, RE2Flags_js_1.ANCHOR_BOTH, 0) !== null);
+    }
+    toString() {
+        return this.patternInput;
+    }
+    /**
+     * Returns the number of capturing groups in this matcher's pattern.
+     */
+    groupCount() {
+        return this.re2Input.numberOfCapturingGroups();
+    }
+    /**
+     * Return a map of the capturing groups in this matcher's pattern.
+     */
+    namedGroups() {
+        return this.re2Input.namedGroups;
+    }
+}
+exports.RE2JS = RE2JS;