@bufbuild/re2 0.0.1-alpha.1

package/dist/esm/Inst.js

@@ -0,0 +1,83 @@
+import { FOLD_CASE } from "./RE2Flags.js";
+import { equalsIgnoreCase } from "./Unicode.js";
+/**
+ * A single instruction in the regular expression virtual machine.
+ *
+ * @see http://swtch.com/~rsc/regexp/regexp2.html
+ */
+class Inst {
+    static ALT = 1;
+    static ALT_MATCH = 2;
+    static CAPTURE = 3;
+    static EMPTY_WIDTH = 4;
+    static FAIL = 5;
+    static MATCH = 6;
+    static NOP = 7;
+    static RUNE = 8;
+    static RUNE1 = 9;
+    static RUNE_ANY = 10;
+    static RUNE_ANY_NOT_NL = 11;
+    op;
+    out;
+    arg;
+    runes;
+    static isRuneOp(op) {
+        return Inst.RUNE <= op && op <= Inst.RUNE_ANY_NOT_NL;
+    }
+    constructor(op) {
+        this.op = op;
+        this.out = 0; // all but MATCH, FAIL
+        this.arg = 0; // ALT, ALT_MATCH, CAPTURE, EMPTY_WIDTH
+        // length==1 => exact match
+        // otherwise a list of [lo,hi] pairs.  hi is *inclusive*.
+        this.runes = [];
+    }
+    // MatchRune returns true if the instruction matches (and consumes) r.
+    // It should only be called when op is a rune op.
+    matchRune(r) {
+        // Special case: single-rune slice is from literal string, not char
+        // class.
+        if (this.runes.length === 1) {
+            const r0 = this.runes[0];
+            // If this pattern is case-insensitive, apply Unicode case folding to compare the two runes.
+            // Note that this may result in a case-folding loop when executed,
+            // so attempt to reduce the chance of that occurring
+            // by performing case folding on |r0| from the pattern rather than |r| from the input.
+            if ((this.arg & FOLD_CASE) !== 0) {
+                return equalsIgnoreCase(r0, r);
+            }
+            return r === r0;
+        }
+        const len = this.runes.length;
+        // If the array is exactly 2, 4, 6, or 8 items, DO NOT fall through to binary search
+        if (len === 2 || len === 4 || len === 6 || len === 8) {
+            for (let j = 0; j < len; j += 2) {
+                if (r < this.runes[j]) {
+                    return false;
+                }
+                if (r <= this.runes[j + 1]) {
+                    return true;
+                }
+            }
+            return false; // Stop here
+        }
+        // Otherwise binary search.
+        let lo = 0;
+        let hi = (this.runes.length / 2) | 0;
+        while (lo < hi) {
+            const m = (lo + hi) >> 1; // native cpu instruction for "lo + (((hi - lo) / 2) | 0)"
+            const c = this.runes[2 * m];
+            if (c <= r) {
+                if (r <= this.runes[2 * m + 1]) {
+                    return true;
+                }
+                lo = m + 1;
+            }
+            else {
+                hi = m;
+            }
+        }
+        return false;
+    }
+}
+export { Inst };

package/dist/esm/MachineInput.d.ts

@@ -0,0 +1,17 @@
+import type { Prefilter } from "./Prefilter.js";
+import type { RE2 } from "./RE2.js";
+declare class MachineUTF16Input {
+    charSequence: string;
+    start: number;
+    end: number;
+    constructor(charSequence: string, start?: number, end?: number);
+    static EOF(): number;
+    endPos(): number;
+    hasString(prefilter: Prefilter, pos: number): boolean;
+    step(pos: number): number;
+    index(re2: RE2, pos: number): number;
+    context(pos: number): number;
+    prefixLength(re2: RE2): number;
+}
+declare function fromUTF16(charSequence: string, start?: number, end?: number): MachineUTF16Input;
+export { fromUTF16, MachineUTF16Input };

package/dist/esm/MachineInput.js

@@ -0,0 +1,68 @@
+import { emptyOpContext } from "./Utils.js";
+import { MAX_HIGH_SURROGATE, MAX_LOW_SURROGATE, MIN_HIGH_SURROGATE, MIN_LOW_SURROGATE, MIN_SUPPLEMENTARY_CODE_POINT, } from "./Unicode.js";
+class MachineUTF16Input {
+    charSequence;
+    start;
+    end;
+    constructor(charSequence, start = 0, end = charSequence.length) {
+        this.charSequence = charSequence;
+        this.start = start;
+        this.end = end;
+    }
+    static EOF() {
+        return -1 << 3;
+    }
+    endPos() {
+        return this.end;
+    }
+    hasString(prefilter, pos) {
+        const idx = this.charSequence.indexOf(prefilter.str, this.start + pos);
+        return idx !== -1 && idx <= this.end - prefilter.str.length;
+    }
+    step(pos) {
+        pos += this.start;
+        if (pos >= this.end) {
+            return MachineUTF16Input.EOF();
+        }
+        const c1 = this.charSequence.charCodeAt(pos);
+        // Fast path: standard BMP character (not a high surrogate)
+        if (c1 < MIN_HIGH_SURROGATE ||
+            c1 > MAX_HIGH_SURROGATE ||
+            pos + 1 >= this.end) {
+            return (c1 << 3) | 1;
+        }
+        // Slow path: Calculate surrogate pair manually
+        const c2 = this.charSequence.charCodeAt(pos + 1);
+        if (c2 >= MIN_LOW_SURROGATE && c2 <= MAX_LOW_SURROGATE) {
+            const rune = (c1 - MIN_HIGH_SURROGATE) * 0x400 +
+                (c2 - MIN_LOW_SURROGATE) +
+                MIN_SUPPLEMENTARY_CODE_POINT;
+            return (rune << 3) | 2;
+        }
+        // Invalid surrogate pair fallback
+        return (c1 << 3) | 1;
+    }
+    index(re2, pos) {
+        pos += this.start;
+        const i = this.charSequence.indexOf(re2.prefix, pos);
+        return i < 0 ? i : i - pos;
+    }
+    context(pos) {
+        pos += this.start;
+        const r1 = pos > 0 && pos <= this.charSequence.length
+            ? this.charSequence.codePointAt(pos - 1)
+            : -1;
+        const r2 = pos < this.charSequence.length ? this.charSequence.codePointAt(pos) : -1;
+        if (r1 === undefined || r2 === undefined) {
+            throw new Error("invalid state");
+        }
+        return emptyOpContext(r1, r2);
+    }
+    prefixLength(re2) {
+        return re2.prefix.length;
+    }
+}
+function fromUTF16(charSequence, start = 0, end = charSequence.length) {
+    return new MachineUTF16Input(charSequence, start, end);
+}
+export { fromUTF16, MachineUTF16Input };

package/dist/esm/Parser.d.ts

@@ -0,0 +1,111 @@
+import { UnicodeRangeTable } from "./UnicodeRangeTable.js";
+import { CharClass } from "./CharClass.js";
+import { Regexp } from "./Regexp.js";
+declare class StringIterator {
+    str: string;
+    position: number;
+    constructor(str: string);
+    pos(): number;
+    rewindTo(pos: number): void;
+    more(): boolean;
+    peek(): number;
+    skip(n: number): void;
+    skipString(s: string): void;
+    pop(): number;
+    lookingAt(s: string): boolean;
+    rest(): string;
+    from(beforePos: number): string;
+    toString(): string;
+}
+/**
+ * A parser of regular expression patterns.
+ *
+ * The only public entry point is {@link #parse(String pattern, int flags)}.
+ */
+declare class Parser {
+    static ERR_INVALID_CHAR_RANGE: string;
+    static ERR_INVALID_ESCAPE: string;
+    static ERR_INVALID_NAMED_CAPTURE: string;
+    static ERR_INVALID_PERL_OP: string;
+    static ERR_INVALID_REPEAT_OP: string;
+    static ERR_INVALID_REPEAT_SIZE: string;
+    static ERR_MISSING_BRACKET: string;
+    static ERR_MISSING_PAREN: string;
+    static ERR_MISSING_REPEAT_ARGUMENT: string;
+    static ERR_TRAILING_BACKSLASH: string;
+    static ERR_DUPLICATE_NAMED_CAPTURE: string;
+    static ERR_UNEXPECTED_PAREN: string;
+    static ERR_NESTING_DEPTH: string;
+    static ERR_LARGE: string;
+    static ERR_BAD_EXPRESSION: string;
+    static MAX_HEIGHT: number;
+    static MAX_SIZE: number;
+    static MAX_RUNES: number;
+    static ANY_TABLE: UnicodeRangeTable;
+    static ASCII_TABLE: UnicodeRangeTable;
+    static ASCII_FOLD_TABLE: UnicodeRangeTable;
+    static unicodeTable(name: string): {
+        tab: UnicodeRangeTable | null;
+        fold: UnicodeRangeTable | null;
+        sign: number;
+    } | null;
+    static minFoldRune(r: number): number;
+    static literalRegexp(s: string, flags: number): Regexp;
+    /**
+     * Parse regular expression pattern {@code pattern} with mode flags {@code flags}.
+     * @param {string} pattern
+     * @param {number} flags
+     */
+    static parse(pattern: string, flags: number): Regexp;
+    static parseRepeat(t: StringIterator): number;
+    static isValidCaptureName(name: string): boolean;
+    static parseInt(t: StringIterator): number;
+    static isCharClass(re: Regexp): boolean;
+    static matchRune(re: Regexp, r: number): boolean;
+    static mergeCharClass(dst: Regexp, src: Regexp): void;
+    static parseEscape(t: StringIterator): number;
+    static parseClassChar(t: StringIterator, wholeClassPos: number): number;
+    static concatRunes(x: number[], y: number[]): number[];
+    wholeRegexp: string;
+    flags: number;
+    numCap: number;
+    namedGroups: Map<string, number>;
+    stack: Regexp[];
+    free: Regexp | null;
+    numRegexp: number;
+    numRunes: number;
+    repeats: number;
+    height: Map<Regexp, number> | null;
+    size: Map<Regexp, number> | null;
+    constructor(wholeRegexp: string, flags?: number);
+    newRegexp(op: number): Regexp;
+    reuse(re: Regexp): void;
+    checkLimits(re: Regexp): void;
+    checkSize(re: Regexp): void;
+    calcSize(re: Regexp, force?: boolean): number;
+    checkHeight(re: Regexp): void;
+    calcHeight(re: Regexp, force?: boolean): number;
+    pop(): Regexp | undefined;
+    popToPseudo(): Regexp[];
+    push(re: Regexp): Regexp | null;
+    maybeConcat(r: number, flags: number): boolean;
+    newLiteral(r: number, flags: number): Regexp;
+    literal(r: number): void;
+    op(op: number): Regexp | null;
+    repeat(op: number, min: number, max: number, beforePos: number, t: StringIterator, lastRepeatPos: number): void;
+    repeatIsValid(re: Regexp, n: number): boolean;
+    concat(): Regexp | null;
+    alternate(): Regexp | null;
+    cleanAlt(re: Regexp): void;
+    collapse(subs: Regexp[], op: number): Regexp;
+    parseInternal(): Regexp;
+    parsePerlFlags(t: StringIterator): void;
+    parseVerticalBar(): void;
+    swapVerticalBar(): boolean;
+    parseRightParen(): void;
+    parsePerlClassEscape(t: StringIterator, cc: CharClass): boolean;
+    parseNamedClass(t: StringIterator, cc: CharClass): boolean;
+    parseUnicodeClass(t: StringIterator, cc: CharClass): boolean;
+    parseClass(t: StringIterator): void;
+}
+export { Parser };