@bufbuild/re2 0.0.1-alpha.1

package/dist/cjs/Compiler.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compiler = void 0;
+const RE2Flags_js_1 = require("./RE2Flags.js");
+const Unicode_js_1 = require("./Unicode.js");
+const Utils_js_1 = require("./Utils.js");
+const Regexp_js_1 = require("./Regexp.js");
+const Inst_js_1 = require("./Inst.js");
+const Prog_js_1 = require("./Prog.js");
+const exceptions_js_1 = require("./exceptions.js");
+/**
+ * A fragment of a compiled regular expression program.
+ *
+ * @see http://swtch.com/~rsc/regexp/regexp1.html
+ * @class
+ */
+class Frag {
+    i;
+    out;
+    nullable;
+    constructor(i = 0, out = new Prog_js_1.PatchList(), nullable = false) {
+        this.i = i; // an instruction address (pc).
+        this.out = out; // a patch list; see explanation in Prog.js
+        this.nullable = nullable; // whether the fragment can match the empty string
+    }
+}
+/**
+ * Compiler from {@code Regexp} (RE2 abstract syntax) to {@code RE2} (compiled regular expression).
+ *
+ * The only entry point is {@link #compileRegexp}.
+ */
+class Compiler {
+    prog;
+    static ANY_RUNE_NOT_NL() {
+        return [0, 0x0a - 1, 0x0a + 1, Unicode_js_1.MAX_RUNE];
+    }
+    static ANY_RUNE() {
+        return [0, Unicode_js_1.MAX_RUNE];
+    }
+    static compileRegexp(re) {
+        const c = new Compiler();
+        const f = c.compile(re);
+        c.prog.patch(f.out, c.newInst(Inst_js_1.Inst.MATCH).i);
+        c.prog.start = f.i;
+        return c.prog;
+    }
+    constructor() {
+        this.prog = new Prog_js_1.Prog();
+        this.newInst(Inst_js_1.Inst.FAIL);
+    }
+    newInst(op) {
+        this.prog.addInst(op);
+        return new Frag(this.prog.numInst() - 1, new Prog_js_1.PatchList(), true);
+    }
+    // Returns a no-op fragment.  Sometimes unavoidable.
+    nop() {
+        const f = this.newInst(Inst_js_1.Inst.NOP);
+        f.out = new Prog_js_1.PatchList(f.i << 1, f.i << 1);
+        return f;
+    }
+    fail() {
+        return new Frag();
+    }
+    // Given fragment a, returns (a) capturing as \n.
+    // Given a fragment a, returns a fragment with capturing parens around a.
+    cap(arg) {
+        const f = this.newInst(Inst_js_1.Inst.CAPTURE);
+        f.out = new Prog_js_1.PatchList(f.i << 1, f.i << 1);
+        this.prog.getInst(f.i).arg = arg;
+        if (this.prog.numCap < arg + 1) {
+            this.prog.numCap = arg + 1;
+        }
+        return f;
+    }
+    // Given fragments a and b, returns ab; a|b
+    cat(f1, f2) {
+        // concat of failure is failure
+        if (f1.i === 0 || f2.i === 0) {
+            return this.fail();
+        }
+        // eslint-disable-next-line no-warning-comments
+        // TODO(rsc): elide nop
+        this.prog.patch(f1.out, f2.i);
+        return new Frag(f1.i, f2.out, f1.nullable && f2.nullable);
+    }
+    // Given fragments for a and b, returns fragment for a|b.
+    alt(f1, f2) {
+        // alt of failure is other
+        if (f1.i === 0) {
+            return f2;
+        }
+        if (f2.i === 0) {
+            return f1;
+        }
+        const f = this.newInst(Inst_js_1.Inst.ALT);
+        const i = this.prog.getInst(f.i);
+        i.out = f1.i;
+        i.arg = f2.i;
+        f.out = this.prog.append(f1.out, f2.out);
+        f.nullable = f1.nullable || f2.nullable;
+        return f;
+    }
+    // loop returns the fragment for the main loop of a plus or star.
+    // For plus, it can be used directly. with f1.i as the entry.
+    // For star, it can be used directly when f1 can't match an empty string.
+    // (When f1 can match an empty string, f1* must be implemented as (f1+)?
+    // to get the priority match order correct.)
+    loop(f1, nongreedy) {
+        const f = this.newInst(Inst_js_1.Inst.ALT);
+        const i = this.prog.getInst(f.i);
+        if (nongreedy) {
+            i.arg = f1.i;
+            f.out = new Prog_js_1.PatchList(f.i << 1, f.i << 1);
+        }
+        else {
+            i.out = f1.i;
+            f.out = new Prog_js_1.PatchList((f.i << 1) | 1, (f.i << 1) | 1);
+        }
+        this.prog.patch(f1.out, f.i);
+        return f;
+    }
+    // Given a fragment for a, returns a fragment for a? or a?? (if nongreedy)
+    quest(f1, nongreedy) {
+        const f = this.newInst(Inst_js_1.Inst.ALT);
+        const i = this.prog.getInst(f.i);
+        if (nongreedy) {
+            i.arg = f1.i;
+            f.out = new Prog_js_1.PatchList(f.i << 1, f.i << 1);
+        }
+        else {
+            i.out = f1.i;
+            f.out = new Prog_js_1.PatchList((f.i << 1) | 1, (f.i << 1) | 1);
+        }
+        f.out = this.prog.append(f.out, f1.out);
+        return f;
+    }
+    // Given a fragment a, returns a fragment for a* or a*? (if nongreedy)
+    star(f1, nongreedy) {
+        if (f1.nullable) {
+            return this.quest(this.plus(f1, nongreedy), nongreedy);
+        }
+        return this.loop(f1, nongreedy);
+    }
+    // Given a fragment for a, returns a fragment for a+ or a+? (if nongreedy)
+    plus(f1, nongreedy) {
+        return new Frag(f1.i, this.loop(f1, nongreedy).out, f1.nullable);
+    }
+    // op is a bitmask of EMPTY_* flags.
+    empty(op) {
+        const f = this.newInst(Inst_js_1.Inst.EMPTY_WIDTH);
+        this.prog.getInst(f.i).arg = op;
+        f.out = new Prog_js_1.PatchList(f.i << 1, f.i << 1);
+        return f;
+    }
+    // flags : parser flags
+    rune(runes, flags) {
+        const f = this.newInst(Inst_js_1.Inst.RUNE);
+        f.nullable = false;
+        const i = this.prog.getInst(f.i);
+        i.runes = runes;
+        flags &= RE2Flags_js_1.FOLD_CASE;
+        if (runes.length !== 1 || (0, Unicode_js_1.simpleFold)(runes[0]) === runes[0]) {
+            flags &= ~RE2Flags_js_1.FOLD_CASE;
+        }
+        i.arg = flags;
+        f.out = new Prog_js_1.PatchList(f.i << 1, f.i << 1);
+        if (((flags & RE2Flags_js_1.FOLD_CASE) === 0 && runes.length === 1) ||
+            (runes.length === 2 && runes[0] === runes[1])) {
+            i.op = Inst_js_1.Inst.RUNE1;
+        }
+        else if (runes.length === 2 && runes[0] === 0 && runes[1] === Unicode_js_1.MAX_RUNE) {
+            i.op = Inst_js_1.Inst.RUNE_ANY;
+        }
+        else if (runes.length === 4 &&
+            runes[0] === 0 &&
+            runes[1] === 0x0a - 1 &&
+            runes[2] === 0x0a + 1 &&
+            runes[3] === Unicode_js_1.MAX_RUNE) {
+            i.op = Inst_js_1.Inst.RUNE_ANY_NOT_NL;
+        }
+        return f;
+    }
+    compile(re) {
+        switch (re.op) {
+            case Regexp_js_1.Regexp.Op.NO_MATCH:
+                return this.fail();
+            case Regexp_js_1.Regexp.Op.EMPTY_MATCH:
+                return this.nop();
+            case Regexp_js_1.Regexp.Op.LITERAL:
+                if (re.runes.length === 0) {
+                    return this.nop();
+                }
+                let f = null;
+                for (let r of re.runes) {
+                    const f1 = this.rune([r], re.flags);
+                    f = f === null ? f1 : this.cat(f, f1);
+                }
+                return f;
+            case Regexp_js_1.Regexp.Op.CHAR_CLASS:
+                return this.rune(re.runes, re.flags);
+            case Regexp_js_1.Regexp.Op.ANY_CHAR_NOT_NL:
+                return this.rune(Compiler.ANY_RUNE_NOT_NL(), 0);
+            case Regexp_js_1.Regexp.Op.ANY_CHAR:
+                return this.rune(Compiler.ANY_RUNE(), 0);
+            case Regexp_js_1.Regexp.Op.BEGIN_LINE:
+                return this.empty(Utils_js_1.EMPTY_BEGIN_LINE);
+            case Regexp_js_1.Regexp.Op.END_LINE:
+                return this.empty(Utils_js_1.EMPTY_END_LINE);
+            case Regexp_js_1.Regexp.Op.BEGIN_TEXT:
+                return this.empty(Utils_js_1.EMPTY_BEGIN_TEXT);
+            case Regexp_js_1.Regexp.Op.END_TEXT:
+                return this.empty(Utils_js_1.EMPTY_END_TEXT);
+            case Regexp_js_1.Regexp.Op.WORD_BOUNDARY:
+                return this.empty(Utils_js_1.EMPTY_WORD_BOUNDARY);
+            case Regexp_js_1.Regexp.Op.NO_WORD_BOUNDARY:
+                return this.empty(Utils_js_1.EMPTY_NO_WORD_BOUNDARY);
+            case Regexp_js_1.Regexp.Op.CAPTURE: {
+                const bra = this.cap(re.cap << 1);
+                const sub = this.compile(re.subs[0]);
+                const ket = this.cap((re.cap << 1) | 1);
+                return this.cat(this.cat(bra, sub), ket);
+            }
+            case Regexp_js_1.Regexp.Op.STAR:
+                return this.star(this.compile(re.subs[0]), (re.flags & RE2Flags_js_1.NON_GREEDY) !== 0);
+            case Regexp_js_1.Regexp.Op.PLUS:
+                return this.plus(this.compile(re.subs[0]), (re.flags & RE2Flags_js_1.NON_GREEDY) !== 0);
+            case Regexp_js_1.Regexp.Op.QUEST:
+                return this.quest(this.compile(re.subs[0]), (re.flags & RE2Flags_js_1.NON_GREEDY) !== 0);
+            case Regexp_js_1.Regexp.Op.CONCAT: {
+                if (re.subs.length === 0) {
+                    return this.nop();
+                }
+                let f = null;
+                for (let sub of re.subs) {
+                    const f1 = this.compile(sub);
+                    f = f === null ? f1 : this.cat(f, f1);
+                }
+                if (f === null) {
+                    throw new Error("invalid frag");
+                }
+                return f;
+            }
+            case Regexp_js_1.Regexp.Op.ALTERNATE: {
+                if (re.subs.length === 0) {
+                    return this.nop();
+                }
+                let f = null;
+                for (let sub of re.subs) {
+                    const f1 = this.compile(sub);
+                    f = f === null ? f1 : this.alt(f, f1);
+                }
+                if (f === null) {
+                    throw new Error("invalid frag");
+                }
+                return f;
+            }
+            default:
+                throw new exceptions_js_1.RE2JSCompileException("regexp: unhandled case in compile");
+        }
+    }
+}
+exports.Compiler = Compiler;

package/dist/cjs/DFA.d.ts

@@ -0,0 +1,36 @@
+import type { Prog } from "./Prog.js";
+import type { MachineUTF16Input } from "./MachineInput.js";
+declare class DFAState {
+    nfaStates: Int32Array;
+    isMatch: boolean;
+    hasEmptyWidth: boolean;
+    matchIDs: number[];
+    nextAscii: (DFAState | null)[];
+    nextMap: Map<number, DFAState | null>;
+    constructor(nfaStates: Int32Array, isMatch: boolean, hasEmptyWidth: boolean, matchIDs?: number[]);
+}
+declare class DFA {
+    prog: Prog;
+    stateCache: Map<number, DFAState[]>;
+    stateCount: number;
+    startState: DFAState | null;
+    stateLimit: number;
+    cacheClears: number;
+    failed: boolean;
+    static MAX_CACHE_CLEARS: number;
+    constructor(prog: Prog);
+    computeClosure(pcs: number[]): {
+        pcs: Int32Array;
+        isMatch: boolean;
+        hasEmptyWidth: boolean;
+        matchIDs: number[];
+    };
+    resolveEmptyWidth(nfaStates: Int32Array, context: number): {
+        resolvedPCs: Set<number>;
+        isMatch: boolean;
+    };
+    getState(pcs: number[]): DFAState | null;
+    step(state: DFAState, charCode: number, anchor: number, context: number): DFAState | null;
+    match(input: MachineUTF16Input, pos: number, anchor: number): boolean | null;
+}
+export { DFA };

package/dist/cjs/DFA.js

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DFA = void 0;
+const Inst_js_1 = require("./Inst.js");
+const RE2Flags_js_1 = require("./RE2Flags.js");
+const Unicode_js_1 = require("./Unicode.js");
+const Utils_js_1 = require("./Utils.js");
+// FNV-1a 32-bit hash for an array of integers.
+const hashPCs = (pcs) => {
+    let h = -2128831035;
+    for (let i = 0; i < pcs.length; i++) {
+        h ^= pcs[i];
+        h = Math.imul(h, 16777619);
+    }
+    return h;
+};
+const arraysEqual = (a, b) => {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+};
+class DFAState {
+    nfaStates;
+    isMatch;
+    hasEmptyWidth;
+    matchIDs;
+    nextAscii;
+    nextMap;
+    constructor(nfaStates, isMatch, hasEmptyWidth, matchIDs = []) {
+        this.nfaStates = nfaStates; // Int32Array of Instruction PCs
+        this.isMatch = isMatch;
+        this.hasEmptyWidth = hasEmptyWidth; // true if any PC is an EMPTY_WIDTH instruction
+        this.matchIDs = matchIDs;
+        this.nextAscii = new Array(Unicode_js_1.MAX_ASCII + 1).fill(null);
+        this.nextMap = new Map();
+    }
+}
+class DFA {
+    prog;
+    stateCache;
+    stateCount;
+    startState;
+    stateLimit;
+    cacheClears;
+    failed;
+    static MAX_CACHE_CLEARS = 5;
+    constructor(prog) {
+        this.prog = prog;
+        this.stateCache = new Map();
+        this.stateCount = 0;
+        this.startState = null;
+        this.stateLimit = 10000;
+        this.cacheClears = 0;
+        this.failed = false;
+    }
+    // Follows epsilon transitions to find all reachable states without consuming a char.
+    // Stops at EMPTY_WIDTH (includes the PC but does not follow through).
+    computeClosure(pcs) {
+        const closure = new Set();
+        const stack = [...pcs];
+        let isMatch = false;
+        let hasEmptyWidth = false;
+        const matchIDs = [];
+        while (stack.length > 0) {
+            const pc = stack.pop();
+            if (pc === undefined) {
+                throw new Error("invalid state");
+            }
+            if (closure.has(pc))
+                continue;
+            closure.add(pc);
+            const inst = this.prog.getInst(pc);
+            switch (inst.op) {
+                case Inst_js_1.Inst.MATCH:
+                    isMatch = true;
+                    if (!matchIDs.includes(inst.arg))
+                        matchIDs.push(inst.arg);
+                    break;
+                case Inst_js_1.Inst.ALT:
+                case Inst_js_1.Inst.ALT_MATCH:
+                    stack.push(inst.out);
+                    stack.push(inst.arg);
+                    break;
+                case Inst_js_1.Inst.NOP:
+                case Inst_js_1.Inst.CAPTURE:
+                    stack.push(inst.out);
+                    break;
+                case Inst_js_1.Inst.EMPTY_WIDTH:
+                    // Include in state but don't follow through — resolved at step time with context
+                    hasEmptyWidth = true;
+                    break;
+            }
+        }
+        const sortedPCs = Int32Array.from(closure).sort();
+        matchIDs.sort((a, b) => a - b);
+        return { pcs: sortedPCs, isMatch, hasEmptyWidth, matchIDs };
+    }
+    // Resolve EMPTY_WIDTH PCs using the given context.
+    // Returns { resolvedPCs: Set<number>, isMatch: boolean }
+    resolveEmptyWidth(nfaStates, context) {
+        const resolved = new Set();
+        const stack = [];
+        let isMatch = false;
+        // Start with all PCs in the state
+        for (let i = 0; i < nfaStates.length; i++) {
+            const pc = nfaStates[i];
+            const inst = this.prog.getInst(pc);
+            if (inst.op === Inst_js_1.Inst.EMPTY_WIDTH) {
+                // Check if context satisfies the empty-width condition
+                if ((inst.arg & ~context) === 0) {
+                    stack.push(inst.out);
+                }
+            }
+            else {
+                resolved.add(pc);
+                if (inst.op === Inst_js_1.Inst.MATCH) {
+                    isMatch = true;
+                }
+            }
+        }
+        // Follow through from resolved EMPTY_WIDTH transitions
+        while (stack.length > 0) {
+            const pc = stack.pop();
+            if (pc === undefined) {
+                throw new Error("invalid state");
+            }
+            if (resolved.has(pc))
+                continue;
+            resolved.add(pc);
+            const inst = this.prog.getInst(pc);
+            switch (inst.op) {
+                case Inst_js_1.Inst.MATCH:
+                    isMatch = true;
+                    break;
+                case Inst_js_1.Inst.ALT:
+                case Inst_js_1.Inst.ALT_MATCH:
+                    stack.push(inst.out);
+                    stack.push(inst.arg);
+                    break;
+                case Inst_js_1.Inst.NOP:
+                case Inst_js_1.Inst.CAPTURE:
+                    stack.push(inst.out);
+                    break;
+                case Inst_js_1.Inst.EMPTY_WIDTH:
+                    if ((inst.arg & ~context) === 0) {
+                        stack.push(inst.out);
+                    }
+                    break;
+            }
+        }
+        return { resolvedPCs: resolved, isMatch };
+    }
+    getState(pcs) {
+        const closureResult = this.computeClosure(pcs);
+        const sortedPCs = closureResult.pcs;
+        const hash = hashPCs(sortedPCs);
+        let bucket = this.stateCache.get(hash);
+        if (bucket) {
+            for (let i = 0; i < bucket.length; i++) {
+                const state = bucket[i];
+                if (arraysEqual(state.nfaStates, sortedPCs)) {
+                    return state;
+                }
+            }
+        }
+        else {
+            bucket = [];
+            this.stateCache.set(hash, bucket);
+        }
+        if (this.failed)
+            return null;
+        if (this.stateCount >= this.stateLimit) {
+            this.stateCache.clear();
+            this.stateCount = 0;
+            this.startState = null;
+            this.cacheClears++;
+            if (this.cacheClears >= DFA.MAX_CACHE_CLEARS) {
+                this.failed = true;
+            }
+            return null;
+        }
+        const state = new DFAState(sortedPCs, closureResult.isMatch, closureResult.hasEmptyWidth, closureResult.matchIDs);
+        bucket.push(state);
+        this.stateCount++;
+        return state;
+    }
+    // Compute the next DFA state given a current state, a character, and context.
+    // Context is needed only when the state has EMPTY_WIDTH PCs.
+    step(state, charCode, anchor, context) {
+        // Cache lookup
+        let cacheKey = 0;
+        if (state.hasEmptyWidth) {
+            // Context-dependent: include context in key
+            cacheKey =
+                charCode * 128 + (context & 0x3f) * 2 + (anchor === RE2Flags_js_1.UNANCHORED ? 0 : 1);
+            const cached = state.nextMap.get(cacheKey);
+            if (cached !== undefined || state.nextMap.has(cacheKey)) {
+                return cached ?? null;
+            }
+        }
+        else {
+            // Context-independent: use original caching
+            if (anchor === RE2Flags_js_1.UNANCHORED && charCode <= Unicode_js_1.MAX_ASCII) {
+                const next = state.nextAscii[charCode];
+                if (next !== null) {
+                    return next;
+                }
+            }
+            else {
+                cacheKey = charCode + (anchor === RE2Flags_js_1.UNANCHORED ? 0 : Unicode_js_1.MAX_RUNE + 1);
+                const cached = state.nextMap.get(cacheKey);
+                if (cached !== undefined || state.nextMap.has(cacheKey)) {
+                    return cached ?? null;
+                }
+            }
+        }
+        // Determine which PCs to check for RUNE matches
+        let activePCs;
+        if (state.hasEmptyWidth) {
+            const { resolvedPCs } = this.resolveEmptyWidth(state.nfaStates, context);
+            activePCs = resolvedPCs;
+        }
+        else {
+            activePCs = state.nfaStates;
+        }
+        // Collect next PCs from RUNE matches
+        const nextPCs = [];
+        const iterPCs = activePCs instanceof Set ? activePCs : state.nfaStates;
+        for (const pc of iterPCs) {
+            const inst = this.prog.getInst(pc);
+            if (Inst_js_1.Inst.isRuneOp(inst.op) && inst.matchRune(charCode)) {
+                nextPCs.push(inst.out);
+            }
+        }
+        if (anchor === RE2Flags_js_1.UNANCHORED) {
+            nextPCs.push(this.prog.start);
+        }
+        const nextState = this.getState(nextPCs);
+        // Cache the result
+        if (state.hasEmptyWidth) {
+            state.nextMap.set(cacheKey, nextState);
+        }
+        else if (anchor === RE2Flags_js_1.UNANCHORED && charCode <= Unicode_js_1.MAX_ASCII) {
+            state.nextAscii[charCode] = nextState;
+        }
+        else {
+            cacheKey = charCode + (anchor === RE2Flags_js_1.UNANCHORED ? 0 : Unicode_js_1.MAX_RUNE + 1);
+            state.nextMap.set(cacheKey, nextState);
+        }
+        return nextState;
+    }
+    // The hot loop: Execute the Lazy DFA
+    match(input, pos, anchor) {
+        if (!this.startState) {
+            this.startState = this.getState([this.prog.start]);
+            if (!this.startState)
+                return null;
+        }
+        const endPos = input.endPos();
+        let currentState = this.startState;
+        // prevRune: the rune immediately before position `pos`. For pos=0 this is
+        // -1 (beginning-of-text sentinel). For pos>0 we query the input so that
+        // ^, \A, and \b anchors use the correct context when matching begins
+        // from a mid-text offset.
+        let prevRune = -1;
+        if (pos > 0) {
+            const r = input.step(pos - 1) >> 3;
+            if (r >= 0)
+                prevRune = r;
+        }
+        // Check if start state matches directly (e.g., empty pattern)
+        if (currentState.isMatch) {
+            if (anchor === RE2Flags_js_1.ANCHOR_BOTH) {
+                if (pos === endPos)
+                    return true;
+            }
+            else {
+                return true;
+            }
+        }
+        let i = pos;
+        while (i < endPos) {
+            const r = input.step(i);
+            const rune = r >> 3;
+            const width = r & 7;
+            if (width === 0)
+                break;
+            // Compute context at position i (between prevRune and rune)
+            const context = (0, Utils_js_1.emptyOpContext)(prevRune, rune);
+            // Before consuming: check if EMPTY_WIDTH in current state resolves to MATCH
+            if (currentState.hasEmptyWidth) {
+                const { isMatch } = this.resolveEmptyWidth(currentState.nfaStates, context);
+                if (isMatch) {
+                    if (anchor === RE2Flags_js_1.ANCHOR_BOTH) {
+                        // Match at position i (before consuming rune) — only valid if i === endPos
+                        // which can't happen in this loop, so skip
+                    }
+                    else {
+                        return true;
+                    }
+                }
+            }
+            // Consume rune and transition to next state
+            if (!currentState.hasEmptyWidth &&
+                anchor === RE2Flags_js_1.UNANCHORED &&
+                rune <= Unicode_js_1.MAX_ASCII) {
+                currentState =
+                    currentState.nextAscii[rune] ||
+                        this.step(currentState, rune, anchor, context);
+            }
+            else {
+                currentState = this.step(currentState, rune, anchor, context);
+            }
+            if (currentState === null)
+                return null;
+            // After consuming: check if new state is a match
+            if (currentState.isMatch) {
+                if (anchor === RE2Flags_js_1.ANCHOR_BOTH) {
+                    if (i + width === endPos)
+                        return true;
+                }
+                else {
+                    return true;
+                }
+            }
+            if (currentState.nfaStates.length === 0) {
+                if (anchor !== RE2Flags_js_1.UNANCHORED)
+                    return false;
+            }
+            prevRune = rune;
+            i += width;
+        }
+        // After the loop: check EMPTY_WIDTH at end of text.
+        // For all anchor modes, a resolved MATCH here means the pattern succeeded:
+        // UNANCHORED/ANCHOR_START accept any match; ANCHOR_BOTH accepts it because
+        // we have consumed the entire input up to endPos.
+        if (currentState.hasEmptyWidth) {
+            const endContext = (0, Utils_js_1.emptyOpContext)(prevRune, -1);
+            const { isMatch } = this.resolveEmptyWidth(currentState.nfaStates, endContext);
+            if (isMatch)
+                return true;
+        }
+        return false;
+    }
+}
+exports.DFA = DFA;

package/dist/cjs/Inst.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A single instruction in the regular expression virtual machine.
+ *
+ * @see http://swtch.com/~rsc/regexp/regexp2.html
+ */
+declare class Inst {
+    static ALT: number;
+    static ALT_MATCH: number;
+    static CAPTURE: number;
+    static EMPTY_WIDTH: number;
+    static FAIL: number;
+    static MATCH: number;
+    static NOP: number;
+    static RUNE: number;
+    static RUNE1: number;
+    static RUNE_ANY: number;
+    static RUNE_ANY_NOT_NL: number;
+    op: number;
+    out: number;
+    arg: number;
+    runes: number[];
+    static isRuneOp(op: number): boolean;
+    constructor(op: number);
+    matchRune(r: number): boolean;
+}
+export { Inst };