@bufbuild/re2 0.0.1-alpha.1

package/dist/cjs/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/cjs/Prefilter.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrefilterTree = exports.Prefilter = void 0;
+const Regexp_js_1 = require("./Regexp.js");
+const RE2Flags_js_1 = require("./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;
+        }
+    }
+}
+exports.Prefilter = Prefilter;
+const fromRegexp = (re) => {
+    if (!re)
+        return new Prefilter(Prefilter.Type.NONE);
+    switch (re.op) {
+        case Regexp_js_1.Regexp.Op.NO_MATCH:
+        case Regexp_js_1.Regexp.Op.EMPTY_MATCH:
+        case Regexp_js_1.Regexp.Op.BEGIN_LINE:
+        case Regexp_js_1.Regexp.Op.END_LINE:
+        case Regexp_js_1.Regexp.Op.BEGIN_TEXT:
+        case Regexp_js_1.Regexp.Op.END_TEXT:
+        case Regexp_js_1.Regexp.Op.WORD_BOUNDARY:
+        case Regexp_js_1.Regexp.Op.NO_WORD_BOUNDARY:
+        case Regexp_js_1.Regexp.Op.CHAR_CLASS:
+        case Regexp_js_1.Regexp.Op.ANY_CHAR_NOT_NL:
+        case Regexp_js_1.Regexp.Op.ANY_CHAR: {
+            return new Prefilter(Prefilter.Type.NONE);
+        }
+        case Regexp_js_1.Regexp.Op.LITERAL: {
+            if (re.runes.length === 0 || (re.flags & RE2Flags_js_1.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_js_1.Regexp.Op.CAPTURE:
+        case Regexp_js_1.Regexp.Op.PLUS: {
+            return fromRegexp(re.subs[0]);
+        }
+        case Regexp_js_1.Regexp.Op.REPEAT: {
+            if (re.min >= 1) {
+                return fromRegexp(re.subs[0]);
+            }
+            return new Prefilter(Prefilter.Type.NONE);
+        }
+        case Regexp_js_1.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_js_1.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)),
+};
+exports.PrefilterTree = PrefilterTree;

package/dist/cjs/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/cjs/Prog.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatchList = exports.Prog = void 0;
+const RE2Flags_js_1 = require("./RE2Flags.js");
+const Inst_js_1 = require("./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;
+    }
+}
+exports.PatchList = PatchList;
+/**
+ * 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_js_1.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_js_1.Inst.NOP || i.op === Inst_js_1.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_js_1.Inst.isRuneOp(i.op) || i.runes.length !== 1) {
+            return [i.op === Inst_js_1.Inst.MATCH, prefix];
+        }
+        while (Inst_js_1.Inst.isRuneOp(i.op) &&
+            i.runes.length === 1 &&
+            (i.arg & RE2Flags_js_1.FOLD_CASE) === 0) {
+            prefix += String.fromCodePoint(i.runes[0]);
+            i = this.skipNop(i.out);
+        }
+        return [i.op === Inst_js_1.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_js_1.Inst.EMPTY_WIDTH:
+                    flag |= i.arg;
+                    break;
+                case Inst_js_1.Inst.FAIL:
+                    return -1;
+                case Inst_js_1.Inst.CAPTURE:
+                case Inst_js_1.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);
+    }
+}
+exports.Prog = Prog;

package/dist/cjs/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/cjs/RE2.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RE2 = void 0;
+const RE2Flags_js_1 = require("./RE2Flags.js");
+const MachineInput_js_1 = require("./MachineInput.js");
+const DFA_js_1 = require("./DFA.js");
+const Inst_js_1 = require("./Inst.js");
+const Prefilter_js_1 = require("./Prefilter.js");
+const Compiler_js_1 = require("./Compiler.js");
+const Simplify_js_1 = require("./Simplify.js");
+const Parser_js_1 = require("./Parser.js");
+const Utils_js_1 = require("./Utils.js");
+class RE2 {
+    expr;
+    prog;
+    numSubexp;
+    cond;
+    prefix;
+    prefixComplete;
+    prefixRune;
+    dfa;
+    prefilter;
+    namedGroups;
+    static compile(expr) {
+        return RE2.compileImpl(expr, RE2Flags_js_1.PERL);
+    }
+    static compileImpl(expr, mode) {
+        return new RE2(expr, mode);
+    }
+    constructor(expr, mode) {
+        let re = Parser_js_1.Parser.parse(expr, mode);
+        re = (0, Simplify_js_1.simplify)(re);
+        const prefilter = Prefilter_js_1.PrefilterTree.build(re);
+        const prog = Compiler_js_1.Compiler.compileRegexp(re);
+        this.prefilter = prefilter.type === Prefilter_js_1.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_js_1.DFA(this.prog);
+    }
+    matchPrefixComplete(input, pos, anchor, ncap) {
+        if ((anchor === RE2Flags_js_1.ANCHOR_START || anchor === RE2Flags_js_1.ANCHOR_BOTH) && pos !== 0) {
+            return null;
+        }
+        let matchStart = -1;
+        let matchEnd = -1;
+        const pLen = input.prefixLength(this);
+        if (anchor === RE2Flags_js_1.UNANCHORED) {
+            const idx = input.index(this, pos);
+            if (idx < 0)
+                return null;
+            matchStart = pos + idx;
+            matchEnd = matchStart + pLen;
+        }
+        else if (anchor === RE2Flags_js_1.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 === RE2Flags_js_1.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 === RE2Flags_js_1.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_js_1.Inst.ALT:
+                case Inst_js_1.Inst.ALT_MATCH:
+                    addState(set, visited, inst.out, context);
+                    addState(set, visited, inst.arg, context);
+                    break;
+                case Inst_js_1.Inst.NOP:
+                case Inst_js_1.Inst.CAPTURE:
+                    addState(set, visited, inst.out, context);
+                    break;
+                case Inst_js_1.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 = (0, Utils_js_1.emptyOpContext)(prevRune, rune);
+            // Add start state at each position for unanchored search
+            if (anchor === RE2Flags_js_1.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 !== RE2Flags_js_1.ANCHOR_BOTH) {
+                for (const pc of current) {
+                    const inst = prog.getInst(pc);
+                    if (inst.op === Inst_js_1.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_js_1.Inst.isRuneOp(inst.op) && inst.matchRune(rune)) {
+                    const nextContext = (0, Utils_js_1.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 === RE2Flags_js_1.UNANCHORED) {
+                const nextRune = i + width < endPos ? input.step(i + width) >> 3 : -1;
+                const nextContext = (0, Utils_js_1.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 = (0, Utils_js_1.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_js_1.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((0, MachineInput_js_1.fromUTF16)(s), 0, RE2Flags_js_1.UNANCHORED, 0) !== null;
+    }
+}
+exports.RE2 = RE2;

package/dist/cjs/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, };