re2js 0.2.0 → 0.3.0

package/build/index.esm.d.ts

@@ -0,0 +1,360 @@
+/**
+ * A compiled representation of an RE2 regular expression
+ *
+ * <p>
+ * 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.
+     *
+     * <p>
+     * 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.
+     * </p>
+     * 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;
+    /**
+     * Helper: create new RE2JS with given regex and flags. Flregex is the regex with flags applied.
+     * @param {string} regex
+     * @param {number} flags
+     * @returns {RE2JS}
+     */
+    static compile(regex: string, ...args: any[]): RE2JS;
+    /**
+     * Matches a string against a regular expression.
+     *
+     * @param {string} regex the regular expression
+     * @param {*} 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: any): boolean;
+    static initTest(pattern: any, flags: any, re2: any): RE2JS;
+    constructor(pattern: any, flags: any);
+    patternInput: any;
+    flagsInput: any;
+    /**
+     * 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 {*} input the input
+     * @returns {boolean} true if the regular expression matches the entire input
+     */
+    matches(input: any): boolean;
+    /**
+     * Creates a new {@code Matcher} matching the pattern against the input.
+     *
+     * @param {*} input the input string
+     * @returns {Matcher}
+     */
+    matcher(input: any): 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.
+     *
+     * <p>
+     * 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 the limit
+     * @returns {java.lang.String[]} the split strings
+     */
+    split(input: string, ...args: any[]): java.lang.String[];
+    toString(): any;
+    /**
+     * 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;
+    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, ...args: 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.
+ *
+ * <p>
+ * 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)
+ */
+declare 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}.
+     *
+     * @param {string} s the string to be quoted
+     * @returns {string} the quoted string
+     */
+    static quoteReplacement(str: any): string;
+    constructor(pattern: any, input: any);
+    patternInput: any;
+    patternGroupCount: any;
+    groups: any[];
+    namedGroups: any;
+    /** Returns the {@code RE2JS} associated with this {@code Matcher}. */
+    pattern(): any;
+    /**
+     * Resets the {@code Matcher}, rewinding input and discarding any match information.
+     *
+     * @returns the {@code Matcher} itself, for chained method calls
+     */
+    reset(): this;
+    matcherInputLength: any;
+    appendPos: any;
+    hasMatch: boolean;
+    hasGroups: boolean;
+    anchorFlag: number;
+    /**
+     * Resets the {@code Matcher} and changes the input.
+     * @returns the {@code Matcher} itself, for chained method calls
+     */
+    resetMatcherInput(input: any): this;
+    matcherInput: any;
+    /**
+     * Returns the start of the named group of the most recent match, or -1 if the group was not
+     * matched.
+     *
+     */
+    start(...args: any[]): any;
+    /**
+     * Returns the end of the named group of the most recent match, or -1 if the group was not
+     * matched.
+     *
+     */
+    end(...args: any[]): any;
+    /**
+     * Returns the named group of the most recent match, or {@code null} if the group was not matched.
+     *
+     */
+    group(...args: any[]): string;
+    /**
+     * 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 start 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(...args: any[]): 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.
+     *
+     * <p>
+     * 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.
+     *
+     * <p>
+     * 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} [perlMode=false] activate perl/js mode (different behaviour for capture groups and special characters)
+     * @returns the {@code Matcher} itself, for chained method calls
+     * @throws IllegalStateException if there was no most recent match
+     * @throws IndexOutOfBoundsException if replacement refers to an invalid group
+     */
+    appendReplacement(replacement: string, ...args: any[]): string;
+    /**
+     * @param {string} replacement - the replacement string
+     * @returns {string}
+     */
+    appendReplacementInternal(replacement: string): string;
+    /**
+     * @param {string} replacement - the replacement string
+     * @returns {string}
+     */
+    appendReplacementInternalPerl(replacement: string): string;
+    /**
+     * 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} replacement - the replacement string
+     * @param {boolean} [perlMode=false] - activate perl/js 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 perlMode is false
+     */
+    replaceAll(replacement: string, ...args: any[]): string;
+    /**
+     * Returns the input with the first match replaced by {@code replacement}, interpreted as for
+     * {@code appendReplacement}.
+     *
+     * @param {string} replacement - the replacement string
+     * @param {boolean} [perlMode=false] - activate perl/js 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 perlMode is false
+     */
+    replaceFirst(replacement: string, ...args: any[]): string;
+    /**
+     * Helper: replaceAll/replaceFirst hybrid.
+     * @param {string} replacement - the replacement string
+     * @param {boolean} [all=true] - replace all matches
+     * @param {boolean} [perlMode=false] - activate perl/js mode (different behaviour for capture groups and special characters)
+     * @returns {string}
+     * @private
+     */
+    private replace;
+}
+export {};
+//# sourceMappingURL=index.esm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.d.ts","sourceRoot":"","sources":["index.esm.js"],"names":[],"mappings":"AAk4KA;;;;;;;;;;GAUG;AACH;IACE;;OAEG;IACH,gCAA4B;IAC5B;;OAEG;IACH,sBAAkB;IAClB;;;OAGG;IACH,yBAAqB;IACrB;;OAEG;IACH,sCAAkC;IAClC;;OAEG;IACH,6BAA0B;IAE1B;;;;;;;;;;;OAWG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,mBAEJ,KAAK,CAyBjB;IAED;;;;;;;OAOG;IACH,sBALW,MAAM,eAEJ,OAAO,CAKnB;IAGD,2DAWC;IACD,sCAKC;IAHC,kBAA2B;IAE3B,gBAAuB;IAGzB;;;OAGG;IACH,cAEC;IAED;;;OAGG;IACH,SAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,WAFa,MAAM,CAIlB;IACD,WAEC;IAED;;;;;OAKG;IACH,qBAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,qBAFa,OAAO,CAOnB;IAED;;;;;;;;;;;;;OAaG;IACH,aAJW,MAAM,mBAEJ,kBAAkB,CAiD9B;IACD,gBAEC;IAED;;;;;OAKG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,mBAEC;IACD,4BAQC;CACF;AAj2JD;;GAEG;AACH;CAKC;AA/CD;IACE,0BAGC;CACF;AAsDD;;GAEG;AACH;CAKC;AAlBD;;GAEG;AACH;CAKC;AAlDD;;GAEG;AACH;IACE,wCAWC;IAFC,WAAkB;IAClB,WAAkB;IAGpB;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,kBAEC;CACF;AAgCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACE;;;;;;OAMG;IACH,mCAFa,MAAM,CAalB;IACD,sCAmBC;IAdC,kBAA2B;IAG3B,uBAAsD;IAEtD,cAAgB;IAChB,iBAAkC;IAUpC,sEAAsE;IACtE,eAEC;IAED;;;;OAIG;IACH,cAaC;IAXC,wBAAoD;IAEpD,eAAkB;IAElB,kBAAqB;IAGrB,mBAAsB;IAEtB,mBAAmB;IAIrB;;;OAGG;IACH,oCAOC;IAHC,kBAAyB;IAK3B;;;;OAIG;IACH,2BAWC;IAED;;;;OAIG;IACH,yBAWC;IAED;;;OAGG;IACH,8BAeC;IACD;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,kBAqBC;IAED;;;;;OAKG;IACH,WAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,aAFa,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,sBAHa,OAAO,CAqBnB;IAED;;;;;;OAMG;IACH,iBAWC;IAED;;;;;OAKG;IACH,iBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAOlB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,+BANW,MAAM,0BAiBhB;IAED;;;OAGG;IACH,uCAHW,MAAM,GACJ,MAAM,CA6DlB;IAED;;;OAGG;IACH,2CAHW,MAAM,GACJ,MAAM,CAmFlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,wBALW,MAAM,mBAEJ,MAAM,CAMlB;IAED;;;;;;;;OAQG;IACH,0BALW,MAAM,mBAEJ,MAAM,CAMlB;IAED;;;;;;;OAOG;IACH,gBAaC;CACF"}