regexus/dist/Builder.d.ts

Human Readable Regular Expressions

declare class RegExpBuilder {
    private _flags;
    private _literal;
    private _groupsUsed;
    private _min;
    private _max;
    private _of;
    private _ofAny;
    private _ofGroup;
    private _from;
    private _notFrom;
    private _like;
    private _either;
    private _reluctant;
    private _capture;
    private _captureName;
    constructor();
    private clear;
    private flushState;
    private getQuantityLiteral;
    private getCharacterLiteral;
    /**
     * Returns the literal representation of the RegExp
     * @returns {string}
     */
    getLiteral(): string;
    private combineGroupNumberingAndGetLiteralral;
    private incrementGroupNumbering;
    /**
     * Returns the usable RegExp
     * @returns {RegExp}
     */
    getRegExp(): RegExp;
    private addFlag;
    ignoreCase(): RegExpBuilder;
    /**
     * Makes the RegExp match across multiple lines
     * @returns {RegExpBuilder}
     */
    multiLine(): RegExpBuilder;
    /**
     * Enables global matching of the RegExp
     * @returns {RegExpBuilder}
     */
    globalMatch(): RegExpBuilder;
    /**
     * Starts the RegExp matching at the beginning of the input
     * @returns {RegExpBuilder}
     */
    startOfInput(): RegExpBuilder;
    /**
     * Starts the RegExp matching at the beginning of the line
     * @returns {RegExpBuilder}
     */
    startOfLine(): RegExpBuilder;
    /**
     * Ends the RegExp matching at the end of the input
     * @returns {RegExpBuilder}
     */
    endOfInput(): RegExpBuilder;
    /**
     * Ends the RegExp matching at the end of the line
     * @returns {RegExpBuilder}
     */
    endOfLine(): RegExpBuilder;
    /**
     * Matches the input string against the RegExp
     * @param {string} input
     * @returns {boolean}
     */
    eitherFind(r: string | RegExpBuilder): RegExpBuilder;
    private setEither;
    orFind(r: string | RegExpBuilder): RegExpBuilder;
    anyOf(r: (string | RegExpBuilder)[]): RegExpBuilder;
    private setOr;
    neither(r: string | RegExpBuilder): RegExpBuilder;
    nor(r: string | RegExpBuilder): RegExpBuilder;
    exactly(n: number): RegExpBuilder;
    min(n: number): RegExpBuilder;
    max(n: number): RegExpBuilder;
    of(s: string): RegExpBuilder;
    ofAny(): RegExpBuilder;
    ofGroup(n: number): RegExpBuilder;
    from(s: string[]): RegExpBuilder;
    notFrom(s: string[]): RegExpBuilder;
    like(r: RegExpBuilder): RegExpBuilder;
    reluctantly(): RegExpBuilder;
    ahead(r: RegExpBuilder): RegExpBuilder;
    notAhead(r: RegExpBuilder): RegExpBuilder;
    asGroup(name?: string | null): RegExpBuilder;
    then(s: string): RegExpBuilder;
    find(s: string): RegExpBuilder;
    some(s: string[]): RegExpBuilder;
    maybeSome(s: string[]): RegExpBuilder;
    maybe(s: string): RegExpBuilder;
    anything(): RegExpBuilder;
    anythingBut(s: string): RegExpBuilder;
    something(): RegExpBuilder;
    any(): RegExpBuilder;
    lineBreak(): RegExpBuilder;
    lineBreaks(): RegExpBuilder;
    whitespace(): RegExpBuilder;
    notWhitespace(): RegExpBuilder;
    tab(): RegExpBuilder;
    tabs(): RegExpBuilder;
    digit(): RegExpBuilder;
    notDigit(): RegExpBuilder;
    digits(): RegExpBuilder;
    notDigits(): RegExpBuilder;
    letter(): RegExpBuilder;
    notLetter(): RegExpBuilder;
    letters(): RegExpBuilder;
    notLetters(): RegExpBuilder;
    lowerCaseLetter(): RegExpBuilder;
    lowerCaseLetters(): RegExpBuilder;
    upperCaseLetter(): RegExpBuilder;
    upperCaseLetters(): RegExpBuilder;
    append(r: RegExpBuilder): RegExpBuilder;
    optional(r: RegExpBuilder): RegExpBuilder;
    private sanitize;
    getNew(): RegExpBuilder;
}
export default RegExpBuilder;