re2js 2.2.3 → 2.3.1

package/build/index.esm.d.ts

@@ -33,9 +33,13 @@ export class Matcher {
     /**
      *
      * @param {RE2JS} pattern
-     * @param {Utf8MatcherInput|Utf16MatcherInput|number[]|string} input
+     * @param {string|number[]|Uint8Array} input
+     */
+    constructor(pattern: RE2JS, input: string | number[] | Uint8Array);
+    /**
+     * The pattern being matched.
+     * @type {RE2JS}
      */
-    constructor(pattern: RE2JS, input: Utf8MatcherInput | Utf16MatcherInput | number[] | string);
     patternInput: RE2JS;
     /** @type {number} */
     patternGroupCount: number;
@@ -65,11 +69,11 @@ export class Matcher {
     anchorFlag: number | undefined;
     /**
      * Resets the {@code Matcher} and changes the input.
-     * @param {Utf8MatcherInput|Utf16MatcherInput} input
+     * @param {MatcherInputBase} input
      * @returns {Matcher} the {@code Matcher} itself, for chained method calls
      */
-    resetMatcherInput(input: Utf8MatcherInput | Utf16MatcherInput): Matcher;
-    matcherInput: Utf8MatcherInput | Utf16MatcherInput | undefined;
+    resetMatcherInput(input: MatcherInputBase): Matcher;
+    matcherInput: MatcherInputBase | undefined;
     /**
      * Returns the start of the named group of the most recent match, or -1 if the group was not
      * matched.
@@ -98,7 +102,7 @@ export class Matcher {
     /**
      * 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}
+     * @returns {string|null}
      */
     group(group?: string | number): string | null;
     /**
@@ -137,11 +141,11 @@ export class Matcher {
      * 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} [start=null] the input position where the search begins
+     * @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): boolean;
+    find(start?: number | null): boolean;
     /**
      * Helper: does match starting at start, with RE2 anchor flag.
      * @param {number} startByte
@@ -299,10 +303,10 @@ export class RE2JS {
      * RE2JS-compatible syntax, and handling Unicode sequences properly. It ensures that the
      * resulting regex is safe and properly formatted before compilation.
      *
-     * @param {string} expr - The regular expression string to be translated.
+     * @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): string;
+    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
@@ -314,11 +318,11 @@ export class RE2JS {
      * Matches a string against a regular expression.
      *
      * @param {string} regex the regular expression
-     * @param {string|number[]} input the input
+     * @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[]): boolean;
+    static matches(regex: string, input: string | number[] | Uint8Array): boolean;
     /**
      * This is visible for testing.
      * @private
@@ -351,37 +355,37 @@ export class RE2JS {
     /**
      * Matches a string against a regular expression.
      *
-     * @param {string|number[]} input the input
+     * @param {string|number[]|Uint8Array} input the input
      * @returns {boolean} true if the regular expression matches the entire input
      */
-    matches(input: string | number[]): boolean;
+    matches(input: string | number[] | Uint8Array): boolean;
     /**
      * Creates a new {@code Matcher} matching the pattern against the input.
      *
-     * @param {string|number[]} input the input string
+     * @param {string|number[]|Uint8Array} input the input string
      * @returns {Matcher}
      */
-    matcher(input: string | number[]): Matcher;
+    matcher(input: string | number[] | Uint8Array): 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[]} input - The input string or UTF-8 byte array to test against.
+     * @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[]): boolean;
+    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[]} input - The input string or UTF-8 byte array to test against.
+     * @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[]): boolean;
+    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.
@@ -481,9 +485,17 @@ export class RE2JSSyntaxException extends RE2JSException {
     getPattern(): string | null;
 }
 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;
@@ -498,49 +510,43 @@ export class RE2Set {
         prefixRune: number;
         longest: boolean;
     } | null;
-    add(pattern: any): number;
-    compile(): void;
-    match(input: any): any[];
-}
-declare class Utf8MatcherInput extends MatcherInputBase {
-    constructor(bytes?: null);
-    bytes: any;
-    getEncoding(): any;
     /**
-     *
-     * @returns {string}
+     * 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.
      */
-    asCharSequence(): string;
+    add(pattern: string): number;
     /**
-     *
-     * @returns {number[]}
+     * Compiles the added patterns into a single state machine.
+     * This is automatically called on the first match if not called explicitly.
+     * @returns {void}
      */
-    asBytes(): number[];
+    compile(): void;
     /**
-     *
-     * @returns {number}
+     * 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.
      */
-    length(): number;
+    match(input: string | number[] | Uint8Array): number[];
 }
-declare class Utf16MatcherInput extends MatcherInputBase {
-    constructor(charSequence?: null);
-    charSequence: any;
-    getEncoding(): any;
-    /**
-     *
-     * @returns {string}
-     */
-    asCharSequence(): string;
+/**
+ * Abstract the representations of input text supplied to Matcher.
+ */
+declare class MatcherInputBase {
+    static Encoding: any;
+    getEncoding(): void;
     /**
      *
-     * @returns {number[]}
+     * @returns {boolean}
      */
-    asBytes(): number[];
+    isUTF8Encoding(): boolean;
     /**
      *
-     * @returns {number}
+     * @returns {boolean}
      */
-    length(): number;
+    isUTF16Encoding(): boolean;
 }
 /**
  * A Prog is a compiled regular expression program.
@@ -587,22 +593,5 @@ declare class DFA {
     match(input: any, pos: any, anchor: any): boolean | null;
     matchSet(input: any, pos: any, anchor: any): any[] | null;
 }
-/**
- * Abstract the representations of input text supplied to Matcher.
- */
-declare class MatcherInputBase {
-    static Encoding: any;
-    getEncoding(): void;
-    /**
-     *
-     * @returns {boolean}
-     */
-    isUTF8Encoding(): boolean;
-    /**
-     *
-     * @returns {boolean}
-     */
-    isUTF16Encoding(): boolean;
-}
 export {};
 //# sourceMappingURL=index.esm.d.ts.map

package/build/index.esm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.esm.d.ts","sourceRoot":"","sources":["index.esm.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.esm.d.ts","sourceRoot":"","sources":["index.esm.js"],"names":[],"mappings":"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"}

package/build/index.esm.js

@@ -2,7 +2,7 @@
  * re2js
  * RE2JS is the JavaScript port of RE2, a regular expression engine that provides linear time matching
  *
- * @version v2.2.3
+ * @version v2.3.1
  * @author Oleksii Vasyliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -1329,6 +1329,7 @@ class RE2JSInternalException extends RE2JSException {
  *
  * @author rsc@google.com (Russ Cox)
  */
+
 class Matcher {
   /**
    * Quotes '\' and '$' in {@code s}, so that the returned string could be used in
@@ -1367,13 +1368,16 @@ class Matcher {
   /**
    *
    * @param {RE2JS} pattern
-   * @param {Utf8MatcherInput|Utf16MatcherInput|number[]|string} input
+   * @param {string|number[]|Uint8Array} input
    */
   constructor(pattern, input) {
     if (pattern === null) {
       throw new Error('pattern is null');
     }
-    // The pattern being matched.
+    /**
+     * The pattern being matched.
+     * @type {RE2JS}
+     */
     this.patternInput = pattern;
     const re2 = this.patternInput.re2();
     // The number of submatches (groups) in the pattern.
@@ -1427,7 +1431,7 @@ class Matcher {
 
   /**
    * Resets the {@code Matcher} and changes the input.
-   * @param {Utf8MatcherInput|Utf16MatcherInput} input
+   * @param {MatcherInputBase} input
    * @returns {Matcher} the {@code Matcher} itself, for chained method calls
    */
   resetMatcherInput(input) {
@@ -1492,7 +1496,7 @@ class Matcher {
   /**
    * 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}
+   * @returns {string|null}
    */
   group(group = 0) {
     if (typeof group === 'string') {
@@ -1584,7 +1588,7 @@ class Matcher {
    * 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} [start=null] the input position where the search begins
+   * @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
    */
@@ -7935,9 +7939,18 @@ class RE2 {
 }
 
 class RE2Set {
+  /** @type {number} */
   static UNANCHORED = RE2Flags.UNANCHORED;
+  /** @type {number} */
   static ANCHOR_START = RE2Flags.ANCHOR_START;
+  /** @type {number} */
   static ANCHOR_BOTH = RE2Flags.ANCHOR_BOTH;
+
+  /**
+   * 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 = RE2Set.UNANCHORED, flags = 0) {
     this.anchor = anchor;
     this.jsFlags = flags;
@@ -7954,6 +7967,14 @@ class RE2Set {
     this.dfa = null;
     this.dummyRe2 = null;
   }
+
+  /**
+   * 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) {
     if (this.prog) {
       throw new RE2JSCompileException('Cannot add patterns after compile');
@@ -7972,6 +7993,12 @@ class RE2Set {
     this.regexps.push(Simplify.simplify(re));
     return this.regexps.length - 1;
   }
+
+  /**
+   * Compiles the added patterns into a single state machine.
+   * This is automatically called on the first match if not called explicitly.
+   * @returns {void}
+   */
   compile() {
     if (this.prog) return;
     this.prog = Compiler.compileSet(this.regexps);
@@ -7984,6 +8011,12 @@ class RE2Set {
       longest: false
     };
   }
+
+  /**
+   * 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) {
     if (!this.prog) this.compile();
     const machineInput = Utils.isByteArray(input) ? MachineInput.fromUTF8(input) : MachineInput.fromUTF16(input);
@@ -8009,13 +8042,19 @@ class RE2Set {
  * Transform JS regex string to RE2 regex string
  */
 class TranslateRegExpString {
-  static isUpperCaseAlpha(ch) {
-    return 'A' <= ch && ch <= 'Z';
-  }
   static isHexadecimal(ch) {
     return '0' <= ch && ch <= '9' || 'A' <= ch && ch <= 'F' || 'a' <= ch && ch <= 'f';
   }
   static translate(data) {
+    let prefixFlags = '';
+    if (data instanceof RegExp) {
+      if (data.ignoreCase) prefixFlags += 'i';
+      if (data.multiline) prefixFlags += 'm';
+      if (data.dotAll) prefixFlags += 's';
+
+      // execution flags ('g', 'y') are safely ignored here.
+      data = data.source;
+    }
     if (typeof data !== 'string') {
       return data;
     }
@@ -8026,6 +8065,7 @@ class TranslateRegExpString {
       result = '(?:)';
       changed = true;
     }
+    let inCharClass = false;
     let i = 0;
     while (i < size) {
       let ch = data[i];
@@ -8064,10 +8104,28 @@ class TranslateRegExpString {
                 if (i + 2 < size) {
                   let nextCh = data[i + 2];
                   if (nextCh === '{') {
-                    result += '\\x';
-                    i += 2;
-                    changed = true;
-                    continue;
+                    // Must have a closing brace and at least one valid hex digit inside
+                    let j = i + 3;
+                    let hasHex = false;
+                    let closed = false;
+                    while (j < size) {
+                      const hexChar = data[j];
+                      if (hexChar === '}') {
+                        closed = true;
+                        break;
+                      }
+                      if (!TranslateRegExpString.isHexadecimal(hexChar)) {
+                        break;
+                      }
+                      hasHex = true;
+                      j++;
+                    }
+                    if (closed && hasHex) {
+                      result += '\\x';
+                      i += 2;
+                      changed = true;
+                      continue;
+                    }
                   } else if (i + 5 < size) {
                     let isHex4 = true;
                     for (let j = 0; j < 4; j++) {
@@ -8084,18 +8142,101 @@ class TranslateRegExpString {
                     }
                   }
                 }
+
+                // Graceful degradation for invalid/unclosed \u sequences
                 result += 'u';
                 i += 2;
                 changed = true;
                 continue;
               }
+            case 'x':
+              {
+                let isValidHex = false;
+                if (i + 2 < size && data[i + 2] === '{') {
+                  // Must have a closing brace and at least one valid hex digit inside
+                  let j = i + 3;
+                  let hasHex = false;
+                  let closed = false;
+                  while (j < size) {
+                    const hexChar = data[j];
+                    if (hexChar === '}') {
+                      closed = true;
+                      break;
+                    }
+                    if (!TranslateRegExpString.isHexadecimal(hexChar)) {
+                      break;
+                    }
+                    hasHex = true;
+                    j++;
+                  }
+                  if (closed && hasHex) {
+                    isValidHex = true;
+                  }
+                } else if (i + 3 < size && TranslateRegExpString.isHexadecimal(data[i + 2]) && TranslateRegExpString.isHexadecimal(data[i + 3])) {
+                  isValidHex = true;
+                }
+                if (isValidHex) {
+                  result += '\\x';
+                  i += 2;
+                } else {
+                  result += 'x';
+                  i += 2;
+                  changed = true;
+                }
+                continue;
+              }
+            // Whitelist of valid RE2/JS alphanumeric escapes
+            case 'n':
+            case 'r':
+            case 't':
+            case 'a':
+            case 'f':
+            case 'v':
+            case 'd':
+            case 'D':
+            case 's':
+            case 'S':
+            case 'w':
+            case 'W':
+            case 'b':
+            case 'B':
+            case 'p':
+            case 'P':
+            case 'A':
+            case 'z':
+            case 'Q':
+            case 'E':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+              {
+                result += '\\' + ch;
+                i += 2;
+                continue;
+              }
             default:
               {
-                result += '\\';
                 let cp = data.codePointAt(i + 1);
-                let symSize = Utils.charCount(cp);
-                result += data.substring(i + 1, i + 1 + symSize);
-                i += symSize + 1;
+                let isAlphaNum = cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122;
+                if (isAlphaNum) {
+                  // Invalid JS alphanumeric escape sequence (e.g. \8, \9, \e, \K)
+                  // Gracefully degrade to the literal character to prevent RE2 syntax crashes
+                  let symSize = Utils.charCount(cp);
+                  result += data.substring(i + 1, i + 1 + symSize);
+                  i += symSize + 1;
+                  changed = true;
+                } else {
+                  // Escaped symbol (e.g. \., \*, \])
+                  result += '\\';
+                  let symSize = Utils.charCount(cp);
+                  result += data.substring(i + 1, i + 1 + symSize);
+                  i += symSize + 1;
+                }
                 continue;
               }
           }
@@ -8105,7 +8246,13 @@ class TranslateRegExpString {
         i += 1;
         changed = true;
         continue;
-      } else if (ch === '(' && i + 2 < size && data[i + 1] === '?' && data[i + 2] === '<') {
+      } else if (ch === '[') {
+        // Track entry into a character class (protects syntax inside)
+        inCharClass = true;
+      } else if (ch === ']') {
+        // Track exit of a character class
+        inCharClass = false;
+      } else if (!inCharClass && ch === '(' && i + 2 < size && data[i + 1] === '?' && data[i + 2] === '<') {
         if (i + 3 < size && !'=!>)'.includes(data[i + 3])) {
           result += '(?P<';
           i += 3;
@@ -8118,7 +8265,13 @@ class TranslateRegExpString {
       result += data.substring(i, i + symSize);
       i += symSize;
     }
-    return changed ? result : data;
+    const finalResult = changed ? result : data;
+
+    // Append any extracted inline flags
+    if (prefixFlags.length > 0) {
+      return `(?${prefixFlags})${finalResult}`;
+    }
+    return finalResult;
   }
 }
 
@@ -8196,7 +8349,7 @@ class RE2JS {
    * RE2JS-compatible syntax, and handling Unicode sequences properly. It ensures that the
    * resulting regex is safe and properly formatted before compilation.
    *
-   * @param {string} expr - The regular expression string to be translated.
+   * @param {string|RegExp} expr - The regular expression string to be translated.
    * @returns {string} - The transformed regular expression string, ready for compilation.
    */
   static translateRegExp(expr) {
@@ -8240,7 +8393,7 @@ class RE2JS {
    * Matches a string against a regular expression.
    *
    * @param {string} regex the regular expression
-   * @param {string|number[]} input the input
+   * @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
    */
@@ -8307,7 +8460,7 @@ class RE2JS {
   /**
    * Matches a string against a regular expression.
    *
-   * @param {string|number[]} input the input
+   * @param {string|number[]|Uint8Array} input the input
    * @returns {boolean} true if the regular expression matches the entire input
    */
   matches(input) {
@@ -8317,7 +8470,7 @@ class RE2JS {
   /**
    * Creates a new {@code Matcher} matching the pattern against the input.
    *
-   * @param {string|number[]} input the input string
+   * @param {string|number[]|Uint8Array} input the input string
    * @returns {Matcher}
    */
   matcher(input) {
@@ -8333,7 +8486,7 @@ class RE2JS {
    * 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[]} input - The input string or UTF-8 byte array to test against.
+   * @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) {
@@ -8352,7 +8505,7 @@ class RE2JS {
    * 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[]} input - The input string or UTF-8 byte array to test against.
+   * @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) {