@bufbuild/re2 0.0.1-alpha.1

package/dist/esm/Prefilter.d.ts

@@ -0,0 +1,19 @@
+import { Regexp } from "./Regexp.js";
+import type { MachineUTF16Input } from "./MachineInput.js";
+declare class Prefilter {
+    type: number;
+    subs: Prefilter[];
+    str: string;
+    static Type: {
+        NONE: number;
+        EXACT: number;
+        AND: number;
+        OR: number;
+    };
+    constructor(type: number);
+    eval(input: MachineUTF16Input, pos: number): boolean;
+}
+declare const PrefilterTree: {
+    build: (re: Regexp) => Prefilter;
+};
+export { Prefilter, PrefilterTree };

package/dist/esm/Prefilter.js

@@ -0,0 +1,159 @@
+import { Regexp } from "./Regexp.js";
+import { FOLD_CASE } from "./RE2Flags.js";
+class Prefilter {
+    type;
+    subs;
+    str;
+    static Type = { NONE: 0, EXACT: 1, AND: 2, OR: 3 };
+    constructor(type) {
+        this.type = type;
+        this.subs = [];
+        this.str = "";
+    }
+    eval(input, pos) {
+        switch (this.type) {
+            case Prefilter.Type.NONE:
+                return true;
+            case Prefilter.Type.EXACT:
+                return input.hasString(this, pos);
+            case Prefilter.Type.AND:
+                for (let i = 0; i < this.subs.length; i++) {
+                    if (!this.subs[i].eval(input, pos))
+                        return false;
+                }
+                return true;
+            case Prefilter.Type.OR:
+                for (let i = 0; i < this.subs.length; i++) {
+                    if (this.subs[i].eval(input, pos))
+                        return true;
+                }
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+const fromRegexp = (re) => {
+    if (!re)
+        return new Prefilter(Prefilter.Type.NONE);
+    switch (re.op) {
+        case Regexp.Op.NO_MATCH:
+        case Regexp.Op.EMPTY_MATCH:
+        case Regexp.Op.BEGIN_LINE:
+        case Regexp.Op.END_LINE:
+        case Regexp.Op.BEGIN_TEXT:
+        case Regexp.Op.END_TEXT:
+        case Regexp.Op.WORD_BOUNDARY:
+        case Regexp.Op.NO_WORD_BOUNDARY:
+        case Regexp.Op.CHAR_CLASS:
+        case Regexp.Op.ANY_CHAR_NOT_NL:
+        case Regexp.Op.ANY_CHAR: {
+            return new Prefilter(Prefilter.Type.NONE);
+        }
+        case Regexp.Op.LITERAL: {
+            if (re.runes.length === 0 || (re.flags & FOLD_CASE) !== 0) {
+                // Skip case-folded literals for simplicity
+                return new Prefilter(Prefilter.Type.NONE);
+            }
+            const pf = new Prefilter(Prefilter.Type.EXACT);
+            let str = "";
+            for (let i = 0; i < re.runes.length; i++) {
+                str += String.fromCodePoint(re.runes[i]);
+            }
+            pf.str = str;
+            return pf;
+        }
+        case Regexp.Op.CAPTURE:
+        case Regexp.Op.PLUS: {
+            return fromRegexp(re.subs[0]);
+        }
+        case Regexp.Op.REPEAT: {
+            if (re.min >= 1) {
+                return fromRegexp(re.subs[0]);
+            }
+            return new Prefilter(Prefilter.Type.NONE);
+        }
+        case Regexp.Op.CONCAT: {
+            const pf = new Prefilter(Prefilter.Type.AND);
+            for (const sub of re.subs) {
+                pf.subs.push(fromRegexp(sub));
+            }
+            return pf;
+        }
+        case Regexp.Op.ALTERNATE: {
+            const pf = new Prefilter(Prefilter.Type.OR);
+            for (const sub of re.subs) {
+                pf.subs.push(fromRegexp(sub));
+            }
+            return pf;
+        }
+        default:
+            return new Prefilter(Prefilter.Type.NONE);
+    }
+};
+const simplify = (pf) => {
+    if (pf.type === Prefilter.Type.EXACT || pf.type === Prefilter.Type.NONE) {
+        return pf;
+    }
+    if (pf.type === Prefilter.Type.AND) {
+        const newSubs = [];
+        for (const sub of pf.subs) {
+            const s = simplify(sub);
+            if (s.type !== Prefilter.Type.NONE) {
+                if (s.type === Prefilter.Type.AND) {
+                    newSubs.push(...s.subs);
+                }
+                else {
+                    newSubs.push(s);
+                }
+            }
+        }
+        if (newSubs.length === 0)
+            return new Prefilter(Prefilter.Type.NONE);
+        if (newSubs.length === 1)
+            return newSubs[0];
+        pf.subs = newSubs;
+        return pf;
+    }
+    if (pf.type === Prefilter.Type.OR) {
+        const newSubs = [];
+        for (const sub of pf.subs) {
+            const s = simplify(sub);
+            if (s.type === Prefilter.Type.NONE) {
+                // If any branch of an OR has no requirements, the whole OR has no requirements
+                return new Prefilter(Prefilter.Type.NONE);
+            }
+            if (s.type === Prefilter.Type.OR) {
+                newSubs.push(...s.subs);
+            }
+            else {
+                newSubs.push(s);
+            }
+        }
+        if (newSubs.length === 0)
+            return new Prefilter(Prefilter.Type.NONE);
+        if (newSubs.length === 1)
+            return newSubs[0];
+        // De-duplicate EXACT branches
+        const seen = new Set();
+        const uniqueSubs = [];
+        for (const sub of newSubs) {
+            if (sub.type === Prefilter.Type.EXACT) {
+                if (!seen.has(sub.str)) {
+                    seen.add(sub.str);
+                    uniqueSubs.push(sub);
+                }
+            }
+            else {
+                uniqueSubs.push(sub);
+            }
+        }
+        pf.subs = uniqueSubs;
+        return pf;
+    }
+    return pf;
+};
+const PrefilterTree = {
+    build: (re) => simplify(fromRegexp(re)),
+};
+export { Prefilter, PrefilterTree };

package/dist/esm/Prog.d.ts

@@ -0,0 +1,39 @@
+import { Inst } from "./Inst.js";
+/**
+ * A list of instruction pointers waiting to be patched.
+ * Tracks both `head` and `tail` to allow O(1) appending during compilation.
+ * * Values are encoded integers, not standard memory pointers:
+ * - Program instruction index: `l >> 1`
+ * - Patch `.out` field if: `(l & 1) === 0`
+ * - Patch `.arg` field if: `(l & 1) === 1`
+ * - `0` denotes an empty list.
+ * * @see https://swtch.com/~rsc/regexp/regexp1.html
+ */
+declare class PatchList {
+    head: number;
+    tail: number;
+    /**
+     * @param {number} head - Encoded pointer to the start of the patch list.
+     * @param {number} tail - Encoded pointer to the end of the patch list.
+     */
+    constructor(head?: number, tail?: number);
+}
+/**
+ * A Prog is a compiled regular expression program.
+ */
+declare class Prog {
+    inst: Inst[];
+    start: number;
+    numCap: number;
+    constructor();
+    getInst(pc: number): Inst;
+    numInst(): number;
+    addInst(op: number): void;
+    skipNop(pc: number): Inst;
+    prefix(): [boolean, string];
+    startCond(): number;
+    next(l: number): number;
+    patch(l: PatchList, val: number): void;
+    append(l1: PatchList, l2: PatchList): PatchList;
+}
+export { Prog, PatchList };

package/dist/esm/Prog.js

@@ -0,0 +1,150 @@
+import { FOLD_CASE } from "./RE2Flags.js";
+import { Inst } from "./Inst.js";
+/**
+ * A list of instruction pointers waiting to be patched.
+ * Tracks both `head` and `tail` to allow O(1) appending during compilation.
+ * * Values are encoded integers, not standard memory pointers:
+ * - Program instruction index: `l >> 1`
+ * - Patch `.out` field if: `(l & 1) === 0`
+ * - Patch `.arg` field if: `(l & 1) === 1`
+ * - `0` denotes an empty list.
+ * * @see https://swtch.com/~rsc/regexp/regexp1.html
+ */
+class PatchList {
+    head;
+    tail;
+    /**
+     * @param {number} head - Encoded pointer to the start of the patch list.
+     * @param {number} tail - Encoded pointer to the end of the patch list.
+     */
+    constructor(head = 0, tail = 0) {
+        this.head = head;
+        this.tail = tail;
+    }
+}
+/**
+ * A Prog is a compiled regular expression program.
+ */
+class Prog {
+    inst;
+    start;
+    numCap;
+    constructor() {
+        this.inst = [];
+        this.start = 0; // index of start instruction
+        // number of CAPTURE insts in re
+        // 2 => implicit ( and ) for whole match $0
+        this.numCap = 2;
+    }
+    // Returns the instruction at the specified pc.
+    // Precondition: pc > 0 && pc < numInst().
+    getInst(pc) {
+        return this.inst[pc];
+    }
+    // Returns the number of instructions in this program.
+    numInst() {
+        return this.inst.length;
+    }
+    // Adds a new instruction to this program, with operator |op| and |pc| equal
+    // to |numInst()|.
+    addInst(op) {
+        this.inst.push(new Inst(op));
+    }
+    // skipNop() follows any no-op or capturing instructions and returns the
+    // resulting instruction.
+    skipNop(pc) {
+        let i = this.inst[pc];
+        while (i.op === Inst.NOP || i.op === Inst.CAPTURE) {
+            i = this.inst[pc];
+            pc = i.out;
+        }
+        return i;
+    }
+    // prefix() returns a pair of a literal string that all matches for the
+    // regexp must start with, and a boolean which is true if the prefix is the
+    // entire match.  The string is returned by appending to |prefix|.
+    prefix() {
+        let prefix = "";
+        let i = this.skipNop(this.start);
+        if (!Inst.isRuneOp(i.op) || i.runes.length !== 1) {
+            return [i.op === Inst.MATCH, prefix];
+        }
+        while (Inst.isRuneOp(i.op) &&
+            i.runes.length === 1 &&
+            (i.arg & FOLD_CASE) === 0) {
+            prefix += String.fromCodePoint(i.runes[0]);
+            i = this.skipNop(i.out);
+        }
+        return [i.op === Inst.MATCH, prefix];
+    }
+    // startCond() returns the leading empty-width conditions that must be true
+    // in any match.  It returns -1 (all bits set) if no matches are possible.
+    startCond() {
+        let flag = 0;
+        let pc = this.start;
+        loop: for (;;) {
+            const i = this.inst[pc];
+            switch (i.op) {
+                case Inst.EMPTY_WIDTH:
+                    flag |= i.arg;
+                    break;
+                case Inst.FAIL:
+                    return -1;
+                case Inst.CAPTURE:
+                case Inst.NOP:
+                    break;
+                default:
+                    break loop;
+            }
+            pc = i.out;
+        }
+        return flag;
+    }
+    // --- Patch list ---
+    // A patchlist is a list of instruction pointers that need to be filled in
+    // (patched).  Because the pointers haven't been filled in yet, we can reuse
+    // their storage to hold the list.  It's kind of sleazy, but works well in
+    // practice.  See http://swtch.com/~rsc/regexp/regexp1.html for inspiration.
+    // These aren't really pointers: they're integers, so we can reinterpret them
+    // this way without using package unsafe.  A value l denotes p.inst[l>>1].out
+    // (l&1==0) or .arg (l&1==1).  l == 0 denotes the empty list, okay because we
+    // start every program with a fail instruction, so we'll never want to point
+    // at its output link.
+    next(l) {
+        const i = this.inst[l >> 1];
+        if ((l & 1) === 0) {
+            return i.out;
+        }
+        return i.arg;
+    }
+    patch(l, val) {
+        let head = l.head;
+        while (head !== 0) {
+            const i = this.inst[head >> 1];
+            if ((head & 1) === 0) {
+                head = i.out;
+                i.out = val;
+            }
+            else {
+                head = i.arg;
+                i.arg = val;
+            }
+        }
+    }
+    append(l1, l2) {
+        if (l1.head === 0)
+            return l2;
+        if (l2.head === 0)
+            return l1;
+        // We know exactly where the tail is
+        const i = this.inst[l1.tail >> 1];
+        if ((l1.tail & 1) === 0) {
+            i.out = l2.head;
+        }
+        else {
+            i.arg = l2.head;
+        }
+        return new PatchList(l1.head, l2.tail);
+    }
+}
+export { Prog, PatchList };

package/dist/esm/RE2.d.ts

@@ -0,0 +1,27 @@
+import { type MachineUTF16Input } from "./MachineInput.js";
+import { DFA } from "./DFA.js";
+import { Prefilter } from "./Prefilter.js";
+import type { Prog } from "./Prog.js";
+declare class RE2 {
+    expr: string;
+    prog: Prog;
+    numSubexp: number;
+    cond: number;
+    prefix: string;
+    prefixComplete: boolean;
+    prefixRune: number;
+    dfa: DFA;
+    prefilter: Prefilter | null;
+    namedGroups: Map<string, number>;
+    static compile(expr: string): RE2;
+    static compileImpl(expr: string, mode: number): RE2;
+    constructor(expr: string, mode: number);
+    matchPrefixComplete(input: MachineUTF16Input, pos: number, anchor: number, ncap: number): number[] | null;
+    executeEngine(input: MachineUTF16Input, pos: number, anchor: number, ncap: number): number[] | null;
+    _nfaFallback(input: MachineUTF16Input, pos: number, anchor: number): boolean;
+    numberOfCapturingGroups(): number;
+    reset(): void;
+    toString(): string;
+    match(s: string): boolean;
+}
+export { RE2 };

package/dist/esm/RE2.js

@@ -0,0 +1,218 @@
+import { ANCHOR_BOTH, ANCHOR_START, PERL, UNANCHORED } from "./RE2Flags.js";
+import { fromUTF16 } from "./MachineInput.js";
+import { DFA } from "./DFA.js";
+import { Inst } from "./Inst.js";
+import { Prefilter, PrefilterTree } from "./Prefilter.js";
+import { Compiler } from "./Compiler.js";
+import { simplify } from "./Simplify.js";
+import { Parser } from "./Parser.js";
+import { emptyOpContext } from "./Utils.js";
+class RE2 {
+    expr;
+    prog;
+    numSubexp;
+    cond;
+    prefix;
+    prefixComplete;
+    prefixRune;
+    dfa;
+    prefilter;
+    namedGroups;
+    static compile(expr) {
+        return RE2.compileImpl(expr, PERL);
+    }
+    static compileImpl(expr, mode) {
+        return new RE2(expr, mode);
+    }
+    constructor(expr, mode) {
+        let re = Parser.parse(expr, mode);
+        re = simplify(re);
+        const prefilter = PrefilterTree.build(re);
+        const prog = Compiler.compileRegexp(re);
+        this.prefilter = prefilter.type === Prefilter.Type.NONE ? null : prefilter;
+        const [prefixCompl, prefixStr] = prog.prefix();
+        this.prefixComplete = prefixCompl;
+        this.prefix = prefixStr;
+        this.prefixRune = 0;
+        if (this.prefix.length > 0) {
+            const cp = this.prefix.codePointAt(0);
+            if (cp === undefined) {
+                throw new Error("RE2: prefix has no code point");
+            }
+            this.prefixRune = cp;
+        }
+        this.namedGroups = re.namedGroups;
+        this.expr = expr;
+        this.prog = prog;
+        this.numSubexp = re.maxCap();
+        this.cond = prog.startCond();
+        this.dfa = new DFA(this.prog);
+    }
+    matchPrefixComplete(input, pos, anchor, ncap) {
+        if ((anchor === ANCHOR_START || anchor === ANCHOR_BOTH) && pos !== 0) {
+            return null;
+        }
+        let matchStart = -1;
+        let matchEnd = -1;
+        const pLen = input.prefixLength(this);
+        if (anchor === UNANCHORED) {
+            const idx = input.index(this, pos);
+            if (idx < 0)
+                return null;
+            matchStart = pos + idx;
+            matchEnd = matchStart + pLen;
+        }
+        else if (anchor === ANCHOR_BOTH) {
+            if (input.endPos() !== pLen)
+                return null;
+            const idx = input.index(this, 0);
+            if (idx !== 0)
+                return null;
+            matchStart = 0;
+            matchEnd = pLen;
+        }
+        else if (anchor === ANCHOR_START) {
+            const idx = input.index(this, 0);
+            if (idx !== 0)
+                return null;
+            matchStart = 0;
+            matchEnd = pLen;
+        }
+        if (matchStart < 0)
+            return null;
+        // If captures are requested (e.g. findSubmatch instead of test), populate bounds
+        if (ncap > 0) {
+            const matchcap = new Int32Array(ncap).fill(-1);
+            matchcap[0] = matchStart;
+            matchcap[1] = matchEnd;
+            return Array.from(matchcap);
+        }
+        return []; // Matched successfully, but no capture data requested
+    }
+    executeEngine(input, pos, anchor, ncap) {
+        if (this.prefixComplete && (ncap === 0 || this.numSubexp === 0)) {
+            return this.matchPrefixComplete(input, pos, anchor, ncap);
+        }
+        if (this.prefilter !== null && anchor === UNANCHORED) {
+            if (!this.prefilter.eval(input, pos)) {
+                return null;
+            }
+        }
+        const dfaResult = this.dfa.match(input, pos, anchor);
+        if (dfaResult !== null) {
+            return dfaResult ? [] : null;
+        }
+        // Minimal NFA fallback for DFA state explosion
+        return this._nfaFallback(input, pos, anchor) ? [] : null;
+    }
+    // Minimal boolean-only NFA for when the DFA bails due to state explosion.
+    // No captures, no thread pools — just two sets of NFA states swapped each step.
+    _nfaFallback(input, pos, anchor) {
+        const prog = this.prog;
+        const endPos = input.endPos();
+        const addState = (set, visited, pc, context) => {
+            if (pc < 0 || pc >= prog.numInst() || visited.has(pc))
+                return;
+            visited.add(pc);
+            const inst = prog.getInst(pc);
+            switch (inst.op) {
+                case Inst.ALT:
+                case Inst.ALT_MATCH:
+                    addState(set, visited, inst.out, context);
+                    addState(set, visited, inst.arg, context);
+                    break;
+                case Inst.NOP:
+                case Inst.CAPTURE:
+                    addState(set, visited, inst.out, context);
+                    break;
+                case Inst.EMPTY_WIDTH:
+                    if ((inst.arg & ~context) === 0) {
+                        addState(set, visited, inst.out, context);
+                    }
+                    break;
+                default:
+                    set.add(pc);
+                    break;
+            }
+        };
+        let current = new Set();
+        let next = new Set();
+        // prevRune: the rune immediately before `pos`. See DFA.match for rationale.
+        let prevRune = -1;
+        if (pos > 0) {
+            const r = input.step(pos - 1) >> 3;
+            if (r >= 0)
+                prevRune = r;
+        }
+        for (let i = pos; i <= endPos; i++) {
+            const rune = i < endPos ? input.step(i) >> 3 : -1;
+            const width = i < endPos ? input.step(i) & 7 : 0;
+            const context = emptyOpContext(prevRune, rune);
+            // Add start state at each position for unanchored search
+            if (anchor === UNANCHORED || i === pos) {
+                const visited = new Set();
+                addState(current, visited, prog.start, context);
+            }
+            // Check for matches before consuming.
+            // For UNANCHORED/ANCHOR_START, a MATCH at any position succeeds.
+            // For ANCHOR_BOTH, we must consume the entire input — intermediate
+            // matches are skipped; only the final post-loop check accepts MATCH.
+            if (anchor !== ANCHOR_BOTH) {
+                for (const pc of current) {
+                    const inst = prog.getInst(pc);
+                    if (inst.op === Inst.MATCH) {
+                        return true;
+                    }
+                }
+            }
+            if (i >= endPos || width === 0)
+                break;
+            // Step: consume current character
+            next.clear();
+            for (const pc of current) {
+                const inst = prog.getInst(pc);
+                if (Inst.isRuneOp(inst.op) && inst.matchRune(rune)) {
+                    const nextContext = emptyOpContext(rune, i + width < endPos ? input.step(i + width) >> 3 : -1);
+                    const visited = new Set();
+                    addState(next, visited, inst.out, nextContext);
+                }
+            }
+            // For unanchored, add start state at next position too
+            if (anchor === UNANCHORED) {
+                const nextRune = i + width < endPos ? input.step(i + width) >> 3 : -1;
+                const nextContext = emptyOpContext(rune, nextRune);
+                const visited = new Set();
+                addState(next, visited, prog.start, nextContext);
+            }
+            prevRune = rune;
+            [current, next] = [next, current];
+            i += width - 1; // loop increments by 1, but we advanced by width
+        }
+        // Final check for match after processing all input
+        const endContext = emptyOpContext(prevRune, -1);
+        const visited = new Set();
+        const finalSet = new Set();
+        for (const pc of current) {
+            addState(finalSet, visited, pc, endContext);
+        }
+        for (const pc of finalSet) {
+            const inst = prog.getInst(pc);
+            if (inst.op === Inst.MATCH)
+                return true;
+        }
+        return false;
+    }
+    numberOfCapturingGroups() {
+        return this.numSubexp;
+    }
+    reset() {
+        // No-op: machine pool removed
+    }
+    toString() {
+        return this.expr;
+    }
+    match(s) {
+        return this.executeEngine(fromUTF16(s), 0, UNANCHORED, 0) !== null;
+    }
+}
+export { RE2 };

package/dist/esm/RE2Flags.d.ts

@@ -0,0 +1,16 @@
+declare const FOLD_CASE = 1;
+declare const LITERAL = 2;
+declare const CLASS_NL = 4;
+declare const DOT_NL = 8;
+declare const ONE_LINE = 16;
+declare const NON_GREEDY = 32;
+declare const PERL_X = 64;
+declare const UNICODE_GROUPS = 128;
+declare const WAS_DOLLAR = 256;
+declare const MATCH_NL: number;
+declare const PERL: number;
+declare const POSIX = 0;
+declare const UNANCHORED = 0;
+declare const ANCHOR_START = 1;
+declare const ANCHOR_BOTH = 2;
+export { UNANCHORED, ANCHOR_BOTH, NON_GREEDY, FOLD_CASE, LITERAL, ONE_LINE, WAS_DOLLAR, DOT_NL, UNICODE_GROUPS, CLASS_NL, PERL, ANCHOR_START, POSIX, MATCH_NL, PERL_X, };

package/dist/esm/RE2Flags.js

@@ -0,0 +1,41 @@
+//// Parser flags.
+// Fold case during matching (case-insensitive).
+const FOLD_CASE = 0x01;
+// Treat pattern as a literal string instead of a regexp.
+const LITERAL = 0x02;
+// Allow character classes like [^a-z] and [[:space:]] to match newline.
+const CLASS_NL = 0x04;
+// Allow '.' to match newline.
+const DOT_NL = 0x08;
+// Treat ^ and $ as only matching at beginning and end of text, not
+// around embedded newlines.  (Perl's default).
+const ONE_LINE = 0x10;
+// Make repetition operators default to non-greedy.
+const NON_GREEDY = 0x20;
+// allow Perl extensions:
+//   non-capturing parens - (?: )
+//   non-greedy operators - *? +? ?? {}?
+//   flag edits - (?i) (?-i) (?i: )
+//     i - FoldCase
+//     m - !OneLine
+//     s - DotNL
+//     U - NonGreedy
+//   line ends: \A \z
+//   \Q and \E to disable/enable metacharacters
+//   (?P<name>expr) for named captures
+// \C (any byte) is not supported.
+const PERL_X = 0x40;
+// Allow \p{Han}, \P{Han} for Unicode group and negation.
+const UNICODE_GROUPS = 0x80;
+// Regexp END_TEXT was $, not \z.  Internal use only.
+const WAS_DOLLAR = 0x100;
+const MATCH_NL = CLASS_NL | DOT_NL;
+// As close to Perl as possible.
+const PERL = CLASS_NL | ONE_LINE | PERL_X | UNICODE_GROUPS;
+// POSIX syntax.
+const POSIX = 0;
+//// Anchors
+const UNANCHORED = 0;
+const ANCHOR_START = 1;
+const ANCHOR_BOTH = 2;
+export { UNANCHORED, ANCHOR_BOTH, NON_GREEDY, FOLD_CASE, LITERAL, ONE_LINE, WAS_DOLLAR, DOT_NL, UNICODE_GROUPS, CLASS_NL, PERL, ANCHOR_START, POSIX, MATCH_NL, PERL_X, };