re2js 1.2.2 → 1.2.3

package/build/index.esm.d.ts

@@ -1,202 +1,3 @@
-/**
- * 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;
-    /**
-     * 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;
-    /**
-     * 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} expr - The regular expression string to be translated.
-     * @returns {string} - The transformed regular expression string, ready for compilation.
-     */
-    static translateRegExp(expr: string): 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[]} 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;
-    /**
-     * This is visible for testing.
-     * @private
-     */
-    private static initTest;
-    /**
-     *
-     * @param {string} pattern
-     * @param {number} flags
-     */
-    constructor(pattern: string, flags: number);
-    patternInput: string;
-    flagsInput: number;
-    /**
-     * 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(): any;
-    /**
-     * Matches a string against a regular expression.
-     *
-     * @param {string|number[]} input the input
-     * @returns {boolean} true if the regular expression matches the entire input
-     */
-    matches(input: string | number[]): boolean;
-    /**
-     * Creates a new {@code Matcher} matching the pattern against the input.
-     *
-     * @param {string|number[]} input the input string
-     * @returns {Matcher}
-     */
-    matcher(input: string | number[]): Matcher;
-    /**
-     * 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 {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 {*}
-     */
-    namedGroups(): any;
-    /**
-     *
-     * @param {*} other
-     * @returns {boolean}
-     */
-    equals(other: any): boolean;
-}
-/**
- * An exception thrown by the compiler
- */
-export class RE2JSCompileException extends RE2JSException {
-}
-export class RE2JSException extends Error {
-    constructor(message: any);
-}
-/**
- * An exception thrown by flags
- */
-export class RE2JSFlagsException extends RE2JSException {
-}
-/**
- * An exception thrown by using groups
- */
-export class RE2JSGroupException extends RE2JSException {
-}
-/**
- * An exception thrown by the parser if the pattern was invalid.
- */
-export class RE2JSSyntaxException extends RE2JSException {
-    constructor(error: any, input?: any);
-    error: any;
-    input: any;
-    /**
-     * Retrieves the description of the error.
-     */
-    getDescription(): any;
-    /**
-     * Retrieves the erroneous regular-expression pattern.
-     */
-    getPattern(): any;
-}
 /**
  * A stateful iterator that interprets a regex {@code RE2JS} on a specific input.
  *
@@ -219,7 +20,7 @@ export class RE2JSSyntaxException extends RE2JSException {
  *
  * @author rsc@google.com (Russ Cox)
  */
-declare class Matcher {
+export class Matcher {
     /**
      * Quotes '\' and '$' in {@code s}, so that the returned string could be used in
      * {@link #appendReplacement} as a literal replacement of {@code s}.
@@ -235,10 +36,14 @@ declare class Matcher {
      */
     constructor(pattern: RE2JS, input: Utf8MatcherInput | Utf16MatcherInput | number[] | string);
     patternInput: RE2JS;
-    patternGroupCount: any;
-    groups: any[];
-    namedGroups: any;
-    numberOfInstructions: any;
+    /** @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 {RE2JS}
@@ -250,17 +55,20 @@ declare class Matcher {
      * @returns {Matcher} the {@code Matcher} itself, for chained method calls
      */
     reset(): Matcher;
-    matcherInputLength: any;
+    /** @type {number} */
+    matcherInputLength: number;
+    /** @type {number} */
     appendPos: number;
     hasMatch: boolean;
     hasGroups: boolean;
     anchorFlag: number;
     /**
      * Resets the {@code Matcher} and changes the input.
+     * @param {Utf8MatcherInput|Utf16MatcherInput} input
      * @returns {Matcher} the {@code Matcher} itself, for chained method calls
      */
-    resetMatcherInput(input: any): Matcher;
-    matcherInput: any;
+    resetMatcherInput(input: Utf8MatcherInput | Utf16MatcherInput): Matcher;
+    matcherInput: Utf8MatcherInput | Utf16MatcherInput;
     /**
      * Returns the start of the named group of the most recent match, or -1 if the group was not
      * matched.
@@ -322,11 +130,11 @@ declare 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 {string|number} [start=null] the input position where the search begins
+     * @param {number} [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?: string | number): boolean;
+    find(start?: number): boolean;
     /**
      * Helper: does match starting at start, with RE2 anchor flag.
      * @param {number} startByte
@@ -417,6 +225,214 @@ declare class Matcher {
      */
     private replace;
 }
+/**
+ * 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;
+    /**
+     * 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;
+    /**
+     * 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} expr - The regular expression string to be translated.
+     * @returns {string} - The transformed regular expression string, ready for compilation.
+     */
+    static translateRegExp(expr: string): 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[]} 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;
+    /**
+     * This is visible for testing.
+     * @private
+     */
+    private static initTest;
+    /**
+     *
+     * @param {string} pattern
+     * @param {number} flags
+     */
+    constructor(pattern: string, flags: number);
+    patternInput: string;
+    flagsInput: number;
+    /**
+     * 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(): any;
+    /**
+     * Matches a string against a regular expression.
+     *
+     * @param {string|number[]} input the input
+     * @returns {boolean} true if the regular expression matches the entire input
+     */
+    matches(input: string | number[]): boolean;
+    /**
+     * Creates a new {@code Matcher} matching the pattern against the input.
+     *
+     * @param {string|number[]} input the input string
+     * @returns {Matcher}
+     */
+    matcher(input: string | number[]): Matcher;
+    /**
+     * 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 {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;
+}
+/**
+ * An exception thrown by the compiler
+ */
+export class RE2JSCompileException extends RE2JSException {
+}
+export class RE2JSException extends Error {
+    /** @param {string} message */
+    constructor(message: string);
+}
+/**
+ * An exception thrown by flags
+ */
+export class RE2JSFlagsException extends RE2JSException {
+}
+/**
+ * An exception thrown by using groups
+ */
+export class RE2JSGroupException extends RE2JSException {
+}
+/**
+ * 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;
+}
 declare class Utf8MatcherInput extends MatcherInputBase {
     constructor(bytes?: any);
     bytes: any;

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 v1.2.2
+ * @version v1.2.3
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -842,6 +842,7 @@ class MatcherInput {
 }
 
 class RE2JSException extends Error {
+  /** @param {string} message */
   constructor(message) {
     super(message);
     this.name = 'RE2JSException';
@@ -852,6 +853,10 @@ class RE2JSException extends Error {
  * An exception thrown by the parser if the pattern was invalid.
  */
 class RE2JSSyntaxException extends RE2JSException {
+  /**
+   * @param {string} error
+   * @param {string|null} [input=null]
+   */
   constructor(error, input = null) {
     let message = `error parsing regexp: ${error}`;
     if (input) {
@@ -860,12 +865,15 @@ class RE2JSSyntaxException extends RE2JSException {
     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;
@@ -873,6 +881,7 @@ class RE2JSSyntaxException extends RE2JSException {
 
   /**
    * Retrieves the erroneous regular-expression pattern.
+   * @returns {string|null}
    */
   getPattern() {
     return this.input;
@@ -883,6 +892,7 @@ class RE2JSSyntaxException extends RE2JSException {
  * An exception thrown by the compiler
  */
 class RE2JSCompileException extends RE2JSException {
+  /** @param {string} message */
   constructor(message) {
     super(message);
     this.name = 'RE2JSCompileException';
@@ -893,6 +903,7 @@ class RE2JSCompileException extends RE2JSException {
  * An exception thrown by using groups
  */
 class RE2JSGroupException extends RE2JSException {
+  /** @param {string} message */
   constructor(message) {
     super(message);
     this.name = 'RE2JSGroupException';
@@ -903,6 +914,7 @@ class RE2JSGroupException extends RE2JSException {
  * An exception thrown by flags
  */
 class RE2JSFlagsException extends RE2JSException {
+  /** @param {string} message */
   constructor(message) {
     super(message);
     this.name = 'RE2JSFlagsException';
@@ -964,10 +976,14 @@ class Matcher {
     this.patternInput = pattern;
     const re2 = this.patternInput.re2();
     // The number of submatches (groups) in the pattern.
+    /** @type {number} */
     this.patternGroupCount = re2.numberOfCapturingGroups();
     // The group indexes, in [start, end) pairs.  Zeroth pair is overall match.
+    /** @type {number[]} */
     this.groups = [];
+    /** @type {Record<string, number>} */
     this.namedGroups = re2.namedGroups;
+    /** @type {number} */
     this.numberOfInstructions = re2.numberOfInstructions();
     if (input instanceof MatcherInputBase) {
       this.resetMatcherInput(input);
@@ -993,8 +1009,10 @@ class Matcher {
    */
   reset() {
     // The input length in UTF16 codes.
+    /** @type {number} */
     this.matcherInputLength = this.matcherInput.length();
     // The append position: where the next append should start.
+    /** @type {number} */
     this.appendPos = 0;
     // Is there a current match?
     this.hasMatch = false;
@@ -1008,6 +1026,7 @@ class Matcher {
 
   /**
    * Resets the {@code Matcher} and changes the input.
+   * @param {Utf8MatcherInput|Utf16MatcherInput} input
    * @returns {Matcher} the {@code Matcher} itself, for chained method calls
    */
   resetMatcherInput(input) {
@@ -1150,7 +1169,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 {string|number} [start=null] the input position where the search begins
+   * @param {number} [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
    */
@@ -6198,7 +6217,7 @@ class RE2JS {
   /**
    * 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 {*}
+   * @returns {Record<string, number>}
    */
   namedGroups() {
     return this.re2Input.namedGroups;
@@ -6220,5 +6239,5 @@ class RE2JS {
   }
 }
 
-export { RE2JS, RE2JSCompileException, RE2JSException, RE2JSFlagsException, RE2JSGroupException, RE2JSSyntaxException };
+export { Matcher, RE2JS, RE2JSCompileException, RE2JSException, RE2JSFlagsException, RE2JSGroupException, RE2JSSyntaxException };
 //# sourceMappingURL=index.esm.js.map