@bufbuild/re2 0.0.1-alpha.1

package/dist/esm/Regexp.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Regular expression abstract syntax tree. Produced by parser, used by compiler.
+ */
+export declare class Regexp {
+    static Op: {
+        readonly NO_MATCH: 0;
+        readonly EMPTY_MATCH: 1;
+        readonly LITERAL: 2;
+        readonly CHAR_CLASS: 3;
+        readonly ANY_CHAR_NOT_NL: 4;
+        readonly ANY_CHAR: 5;
+        readonly BEGIN_LINE: 6;
+        readonly END_LINE: 7;
+        readonly BEGIN_TEXT: 8;
+        readonly END_TEXT: 9;
+        readonly WORD_BOUNDARY: 10;
+        readonly NO_WORD_BOUNDARY: 11;
+        readonly CAPTURE: 12;
+        readonly STAR: 13;
+        readonly PLUS: 14;
+        readonly QUEST: 15;
+        readonly REPEAT: 16;
+        readonly CONCAT: 17;
+        readonly ALTERNATE: 18;
+        readonly LEFT_PAREN: 19;
+        readonly VERTICAL_BAR: 20;
+    };
+    static isPseudoOp(op: number): boolean;
+    static emptySubs(): Regexp[];
+    static fromRegexp(re: Regexp): Regexp;
+    op: number;
+    flags: number;
+    subs: Regexp[];
+    runes: number[];
+    min: number;
+    max: number;
+    cap: number;
+    name: string | null;
+    namedGroups: Map<string, number>;
+    constructor(op: number);
+    reinit(): void;
+    maxCap(): number;
+}

package/dist/esm/Regexp.js

@@ -0,0 +1,94 @@
+/**
+ * Regular expression abstract syntax tree. Produced by parser, used by compiler.
+ */
+export class Regexp {
+    static Op = {
+        NO_MATCH: 0,
+        EMPTY_MATCH: 1,
+        LITERAL: 2,
+        CHAR_CLASS: 3,
+        ANY_CHAR_NOT_NL: 4,
+        ANY_CHAR: 5,
+        BEGIN_LINE: 6,
+        END_LINE: 7,
+        BEGIN_TEXT: 8,
+        END_TEXT: 9,
+        WORD_BOUNDARY: 10,
+        NO_WORD_BOUNDARY: 11,
+        CAPTURE: 12,
+        STAR: 13,
+        PLUS: 14,
+        QUEST: 15,
+        REPEAT: 16,
+        CONCAT: 17,
+        ALTERNATE: 18,
+        LEFT_PAREN: 19,
+        VERTICAL_BAR: 20,
+    };
+    static isPseudoOp(op) {
+        return op >= Regexp.Op.LEFT_PAREN;
+    }
+    static emptySubs() {
+        return [];
+    }
+    static fromRegexp(re) {
+        const regex = new Regexp(re.op);
+        regex.flags = re.flags;
+        regex.subs = re.subs;
+        regex.runes = re.runes;
+        regex.cap = re.cap;
+        regex.min = re.min;
+        regex.max = re.max;
+        regex.name = re.name;
+        regex.namedGroups = re.namedGroups;
+        return regex;
+    }
+    op;
+    flags;
+    subs;
+    runes;
+    min;
+    max;
+    cap;
+    name;
+    namedGroups;
+    constructor(op) {
+        this.op = op; // operator
+        this.flags = 0; // bitmap of parse flags
+        // subexpressions, if any.  Never null.
+        // subs[0] is used as the freelist.
+        this.subs = Regexp.emptySubs();
+        this.runes = []; // matched runes, for LITERAL, CHAR_CLASS
+        this.min = 0; // min for REPEAT
+        this.max = 0; // max for REPEAT
+        this.cap = 0; // capturing index, for CAPTURE
+        this.name = null; // capturing name, for CAPTURE
+        this.namedGroups = new Map();
+    }
+    reinit() {
+        this.flags = 0;
+        this.subs = Regexp.emptySubs();
+        this.runes = [];
+        this.cap = 0;
+        this.min = 0;
+        this.max = 0;
+        this.name = null;
+        this.namedGroups = new Map();
+    }
+    // maxCap() walks the regexp to find the maximum capture index.
+    maxCap() {
+        let m = 0;
+        if (this.op === Regexp.Op.CAPTURE) {
+            m = this.cap;
+        }
+        if (this.subs !== null) {
+            for (let sub of this.subs) {
+                const n = sub.maxCap();
+                if (m < n) {
+                    m = n;
+                }
+            }
+        }
+        return m;
+    }
+}

package/dist/esm/Simplify.d.ts

@@ -0,0 +1,3 @@
+import { Regexp } from "./Regexp.js";
+declare function simplify(re: Regexp): Regexp;
+export { simplify };

package/dist/esm/Simplify.js

@@ -0,0 +1,228 @@
+import { NON_GREEDY } from "./RE2Flags.js";
+import { Regexp } from "./Regexp.js";
+import { MAX_RUNE } from "./Unicode.js";
+// simplify returns a regexp equivalent to re but without counted
+// repetitions and with various other simplifications, such as
+// rewriting /(?:a+)+/ to /a+/.  The resulting regexp will execute
+// correctly but its string representation will not produce the same
+// parse tree, because capturing parentheses may have been duplicated
+// or removed.  For example, the simplified form for /(x){1,2}/ is
+// /(x)(x)?/ but both parentheses capture as $1.  The returned regexp
+// may share structure with or be the original.
+function simplify(re) {
+    switch (re.op) {
+        case Regexp.Op.CAPTURE: {
+            const sub = simplify(re.subs[0]);
+            if (sub !== re.subs[0]) {
+                const nre = Regexp.fromRegexp(re);
+                nre.runes = [];
+                nre.subs = [sub];
+                return nre;
+            }
+            return re;
+        }
+        case Regexp.Op.CONCAT:
+        case Regexp.Op.ALTERNATE: {
+            const newSubs = [];
+            let changed = false;
+            for (let i = 0; i < re.subs.length; i++) {
+                const sub = re.subs[i];
+                const nsub = simplify(sub);
+                if (nsub !== sub) {
+                    changed = true;
+                }
+                if (re.op === Regexp.Op.CONCAT) {
+                    // If any part of a CONCAT is mathematically impossible,
+                    // the entire CONCAT sequence becomes impossible.
+                    if (nsub.op === Regexp.Op.NO_MATCH) {
+                        return new Regexp(Regexp.Op.NO_MATCH);
+                    }
+                    // Drop empty 0-width match nodes entirely from sequences
+                    if (nsub.op === Regexp.Op.EMPTY_MATCH) {
+                        changed = true;
+                        continue;
+                    }
+                    // Flatten nested concatenations
+                    if (nsub.op === Regexp.Op.CONCAT) {
+                        changed = true;
+                        newSubs.push(...nsub.subs);
+                        continue;
+                    }
+                }
+                else if (re.op === Regexp.Op.ALTERNATE) {
+                    // Drop impossible branches from alternations
+                    if (nsub.op === Regexp.Op.NO_MATCH) {
+                        changed = true;
+                        continue;
+                    }
+                    // Flatten nested alternations
+                    if (nsub.op === Regexp.Op.ALTERNATE) {
+                        changed = true;
+                        newSubs.push(...nsub.subs);
+                        continue;
+                    }
+                }
+                newSubs.push(nsub);
+            }
+            if (changed) {
+                // If we filtered out all nodes, return the mathematically correct fallback
+                if (newSubs.length === 0) {
+                    return new Regexp(re.op === Regexp.Op.CONCAT
+                        ? Regexp.Op.EMPTY_MATCH
+                        : Regexp.Op.NO_MATCH);
+                }
+                // If only 1 node remains, we don't need a CONCAT/ALT container at all
+                if (newSubs.length === 1) {
+                    return newSubs[0];
+                }
+                const nre = Regexp.fromRegexp(re);
+                nre.runes = [];
+                nre.subs = newSubs;
+                return nre;
+            }
+            return re;
+        }
+        case Regexp.Op.CHAR_CLASS: {
+            if (re.runes === null)
+                return re;
+            // Empty character classes match nothing.
+            if (re.runes.length === 0) {
+                return new Regexp(Regexp.Op.NO_MATCH);
+            }
+            // Full character classes match everything.
+            if (re.runes.length === 2 &&
+                re.runes[0] === 0 &&
+                re.runes[1] === MAX_RUNE) {
+                return new Regexp(Regexp.Op.ANY_CHAR);
+            }
+            // Standard catch-all except newline
+            if (re.runes.length === 4 &&
+                re.runes[0] === 0 &&
+                re.runes[1] === 0x0a - 1 &&
+                re.runes[2] === 0x0a + 1 &&
+                re.runes[3] === MAX_RUNE) {
+                return new Regexp(Regexp.Op.ANY_CHAR_NOT_NL);
+            }
+            return re;
+        }
+        case Regexp.Op.STAR:
+        case Regexp.Op.PLUS:
+        case Regexp.Op.QUEST: {
+            const sub = simplify(re.subs[0]);
+            return simplify1(re.op, re.flags, sub, re);
+        }
+        case Regexp.Op.REPEAT: {
+            // Special special case: x{0} matches the empty string
+            // and doesn't even need to consider x.
+            if (re.min === 0 && re.max === 0) {
+                return new Regexp(Regexp.Op.EMPTY_MATCH);
+            }
+            // The fun begins.
+            const sub = simplify(re.subs[0]);
+            // x{n,} means at least n matches of x.
+            if (re.max === -1) {
+                // Special case: x{0,} is x*.
+                if (re.min === 0) {
+                    return simplify1(Regexp.Op.STAR, re.flags, sub, null);
+                }
+                // Special case: x{1,} is x+.
+                if (re.min === 1) {
+                    return simplify1(Regexp.Op.PLUS, re.flags, sub, null);
+                }
+                // General case: x{4,} is xxxx+.
+                const nre = new Regexp(Regexp.Op.CONCAT);
+                const subs = [];
+                for (let i = 0; i < re.min - 1; i++) {
+                    subs.push(sub);
+                }
+                subs.push(simplify1(Regexp.Op.PLUS, re.flags, sub, null));
+                nre.subs = subs.slice(0);
+                // Ensure newly created CONCAT is properly flattened
+                return simplify(nre);
+            }
+            // Special case x{0} handled above.
+            // Special case: x{1} is just x.
+            if (re.min === 1 && re.max === 1) {
+                return sub;
+            }
+            // General case: x{n,m} means n copies of x and m copies of x?
+            // The machine will do less work if we nest the final m copies,
+            // so that x{2,5} = xx(x(x(x)?)?)?
+            // Build leading prefix: xx.
+            let prefixSubs = null;
+            if (re.min > 0) {
+                prefixSubs = [];
+                for (let i = 0; i < re.min; i++) {
+                    prefixSubs.push(sub);
+                }
+            }
+            // Build and attach suffix: (x(x(x)?)?)?
+            if (re.max > re.min) {
+                let suffix = simplify1(Regexp.Op.QUEST, re.flags, sub, null);
+                for (let i = re.min + 1; i < re.max; i++) {
+                    const nre2 = new Regexp(Regexp.Op.CONCAT);
+                    nre2.subs = [sub, suffix];
+                    suffix = simplify1(Regexp.Op.QUEST, re.flags, nre2, null);
+                }
+                if (prefixSubs === null) {
+                    return suffix;
+                }
+                prefixSubs.push(suffix);
+            }
+            if (prefixSubs !== null) {
+                const prefix = new Regexp(Regexp.Op.CONCAT);
+                prefix.subs = prefixSubs.slice(0);
+                // Ensure newly created CONCAT is properly flattened
+                return simplify(prefix);
+            }
+            // Some degenerate case like min > max or min < max < 0.
+            // Handle as impossible match.
+            return new Regexp(Regexp.Op.NO_MATCH);
+        }
+    }
+    return re;
+}
+// simplify1 implements Simplify for the unary OpStar,
+// OpPlus, and OpQuest operators.  It returns the simple regexp
+// equivalent to
+//
+//      Regexp{Op: op, Flags: flags, Sub: {sub}}
+//
+// under the assumption that sub is already simple, and
+// without first allocating that structure.  If the regexp
+// to be returned turns out to be equivalent to re, simplify1
+// returns re instead.
+//
+// simplify1 is factored out of Simplify because the implementation
+// for other operators generates these unary expressions.
+// Letting them call simplify1 makes sure the expressions they
+// generate are simple.
+function simplify1(op, flags, sub, re) {
+    // Special case: repeat the empty string as much as
+    // you want, but it's still the empty string.
+    if (sub.op === Regexp.Op.EMPTY_MATCH) {
+        return sub;
+    }
+    // Handle impossible targets gracefully.
+    // e.g. Trying to match "NO_MATCH" 0 or 1 times (QUEST/STAR) evaluates to EMPTY_MATCH.
+    if (sub.op === Regexp.Op.NO_MATCH) {
+        if (op === Regexp.Op.PLUS)
+            return sub; // 1+ times is impossible
+        return new Regexp(Regexp.Op.EMPTY_MATCH);
+    }
+    // The operators are idempotent if the flags match.
+    if (op === sub.op && (flags & NON_GREEDY) === (sub.flags & NON_GREEDY)) {
+        return sub;
+    }
+    if (re !== null &&
+        re.op === op &&
+        (re.flags & NON_GREEDY) === (flags & NON_GREEDY) &&
+        sub === re.subs[0]) {
+        return re;
+    }
+    const nre = new Regexp(op);
+    nre.flags = flags;
+    nre.subs = [sub];
+    return nre;
+}
+export { simplify };

package/dist/esm/Unicode.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Utilities for dealing with Unicode better than JS does.
+ */
+declare const MAX_RUNE = 1114111;
+declare const MAX_ASCII = 127;
+declare const MAX_BMP = 65535;
+declare const MIN_FOLD = 65;
+declare const MAX_FOLD = 125251;
+declare const MIN_HIGH_SURROGATE = 55296;
+declare const MAX_HIGH_SURROGATE = 56319;
+declare const MIN_LOW_SURROGATE = 56320;
+declare const MAX_LOW_SURROGATE = 57343;
+declare const MIN_SUPPLEMENTARY_CODE_POINT = 65536;
+declare function isUpper(r: number): boolean;
+declare function simpleFold(r: number): number;
+declare function equalsIgnoreCase(r1: number, r2: number): boolean;
+export { MAX_RUNE, MIN_FOLD, MAX_FOLD, simpleFold, MAX_ASCII, equalsIgnoreCase, MIN_SUPPLEMENTARY_CODE_POINT, MIN_LOW_SURROGATE, MIN_HIGH_SURROGATE, MAX_LOW_SURROGATE, MAX_HIGH_SURROGATE, MAX_BMP, isUpper, };

package/dist/esm/Unicode.js

@@ -0,0 +1,150 @@
+import { UnicodeTables } from "./UnicodeTables.js";
+/**
+ * Utilities for dealing with Unicode better than JS does.
+ */
+// The highest legal rune value.
+const MAX_RUNE = 0x10ffff;
+// The highest legal ASCII value.
+const MAX_ASCII = 0x7f;
+// The highest legal Latin-1 value.
+const MAX_LATIN1 = 0xff;
+// The highest legal Basic Multilingual Plane (BMP) value.
+const MAX_BMP = 0xffff;
+// Minimum and maximum runes involved in folding.
+// Checked during test.
+const MIN_FOLD = 0x0041;
+const MAX_FOLD = 0x1e943;
+const MIN_HIGH_SURROGATE = 0xd800;
+const MAX_HIGH_SURROGATE = 0xdbff;
+const MIN_LOW_SURROGATE = 0xdc00;
+const MAX_LOW_SURROGATE = 0xdfff;
+const MIN_SUPPLEMENTARY_CODE_POINT = 0x10000;
+// is32 uses binary search to test whether rune is in the specified
+// slice of 32-bit ranges.
+function is32(ranges, r) {
+    // binary search over ranges
+    let lo = 0;
+    let hi = ranges.length;
+    while (lo < hi) {
+        const m = lo + Math.floor((hi - lo) / 2);
+        const rlo = ranges.getLo(m);
+        const rhi = ranges.getHi(m);
+        if (rlo <= r && r <= rhi) {
+            const stride = ranges.getStride(m);
+            return (r - rlo) % stride === 0;
+        }
+        if (r < rlo) {
+            hi = m;
+        }
+        else {
+            lo = m + 1;
+        }
+    }
+    return false;
+}
+// is tests whether rune is in the specified table of ranges.
+function is(ranges, r) {
+    // Fast path for Latin-1 characters using linear search.
+    if (r <= MAX_LATIN1) {
+        for (let i = 0; i < ranges.length; i++) {
+            const rhi = ranges.getHi(i);
+            if (r > rhi) {
+                continue;
+            }
+            const rlo = ranges.getLo(i);
+            if (r < rlo) {
+                return false;
+            }
+            const stride = ranges.getStride(i);
+            return (r - rlo) % stride === 0;
+        }
+        return false;
+    }
+    // Fallback to binary search for runes outside Latin-1
+    return ranges.length > 0 && r >= ranges.getLo(0) && is32(ranges, r);
+}
+// isUpper reports whether the rune is an upper case letter.
+function isUpper(r) {
+    if (r <= MAX_LATIN1) {
+        const s = String.fromCodePoint(r);
+        return s.toUpperCase() === s && s.toLowerCase() !== s;
+    }
+    return is(UnicodeTables.Upper, r);
+}
+// simpleFold iterates over Unicode code points equivalent under
+// the Unicode-defined simple case folding.  Among the code points
+// equivalent to rune (including rune itself), SimpleFold returns the
+// smallest r >= rune if one exists, or else the smallest r >= 0.
+//
+// For example:
+//      SimpleFold('A') = 'a'
+//      SimpleFold('a') = 'A'
+//
+//      SimpleFold('K') = 'k'
+//      SimpleFold('k') = '\u212A' (Kelvin symbol, K)
+//      SimpleFold('\u212A') = 'K'
+//
+//      SimpleFold('1') = '1'
+//
+// Derived from Go's unicode.SimpleFold.
+//
+function simpleFold(r) {
+    // Consult caseOrbit table for special cases (3+ element cycles, lossy
+    // mappings like ſ→S, and Turkic-specific self-loops).
+    const caseOrbit = UnicodeTables.CASE_ORBIT;
+    const folded = caseOrbit.get(r);
+    if (folded !== undefined) {
+        return folded;
+    }
+    // Fallback for 2-element orbits: use raw native case conversion.
+    // The length check rejects multi-char results (e.g., ß→SS) which
+    // would otherwise be truncated to a non-equivalent codepoint.
+    const s = String.fromCodePoint(r);
+    const lower = s.toLowerCase();
+    if (lower.length === s.length) {
+        const lowerCp = lower.codePointAt(0);
+        if (lowerCp !== undefined && lowerCp !== r)
+            return lowerCp;
+    }
+    const upper = s.toUpperCase();
+    if (upper.length === s.length) {
+        const upperCp = upper.codePointAt(0);
+        if (upperCp !== undefined && upperCp !== r)
+            return upperCp;
+    }
+    return r;
+}
+// equalsIgnoreCase performs case-insensitive equality comparison
+// on the given runes |r1| and |r2|, with special consideration
+// for the likely scenario where both runes are ASCII characters.
+// If non-ASCII, Unicode case folding will be performed on |r1|
+// to compare it to |r2|.
+// -1 is interpreted as the end-of-file mark and never matches.
+function equalsIgnoreCase(r1, r2) {
+    if (r1 < 0 || r2 < 0) {
+        return false;
+    }
+    if (r1 === r2) {
+        return true;
+    }
+    // Fast path for the common case where both runes are ASCII characters.
+    // Coerces both runes to lowercase if applicable.
+    if (r1 <= MAX_ASCII && r2 <= MAX_ASCII) {
+        if (0x41 <= r1 && r1 <= 0x5a) {
+            r1 |= 0x20;
+        }
+        if (0x41 <= r2 && r2 <= 0x5a) {
+            r2 |= 0x20;
+        }
+        return r1 === r2;
+    }
+    // Fall back to full Unicode case folding otherwise.
+    // Invariant: r1 must be non-negative
+    for (let r = simpleFold(r1); r !== r1; r = simpleFold(r)) {
+        if (r === r2) {
+            return true;
+        }
+    }
+    return false;
+}
+export { MAX_RUNE, MIN_FOLD, MAX_FOLD, simpleFold, MAX_ASCII, equalsIgnoreCase, MIN_SUPPLEMENTARY_CODE_POINT, MIN_LOW_SURROGATE, MIN_HIGH_SURROGATE, MAX_LOW_SURROGATE, MAX_HIGH_SURROGATE, MAX_BMP, isUpper, };

package/dist/esm/UnicodeRangeTable.d.ts

@@ -0,0 +1,12 @@
+declare class UnicodeRangeTable {
+    data: Uint32Array;
+    isStride1: boolean;
+    SIZE: number;
+    constructor(data: Uint32Array, isStride1?: boolean);
+    getLo(index: number): number;
+    getHi(index: number): number;
+    getStride(index: number): number;
+    get(index: number): number[];
+    get length(): number;
+}
+export { UnicodeRangeTable };

package/dist/esm/UnicodeRangeTable.js

@@ -0,0 +1,28 @@
+class UnicodeRangeTable {
+    data;
+    isStride1;
+    SIZE;
+    constructor(data, isStride1 = false) {
+        this.data = data; // A Uint32Array
+        this.isStride1 = isStride1;
+        this.SIZE = isStride1 ? 2 : 3;
+    }
+    // High-performance getters that do NOT allocate memory
+    getLo(index) {
+        return this.data[index * this.SIZE];
+    }
+    getHi(index) {
+        return this.data[index * this.SIZE + 1];
+    }
+    getStride(index) {
+        return this.isStride1 ? 1 : this.data[index * this.SIZE + 2];
+    }
+    get(index) {
+        const i = index * this.SIZE;
+        return [this.data[i], this.data[i + 1], this.getStride(index)];
+    }
+    get length() {
+        return this.data.length / this.SIZE;
+    }
+}
+export { UnicodeRangeTable };

package/dist/esm/UnicodeTables.d.ts

@@ -0,0 +1,29 @@
+import { UnicodeRangeTable } from "./UnicodeRangeTable.js";
+export declare const UnicodeTables: {
+    readonly CASE_ORBIT: Map<number, number>;
+    STABLE_CATEGORY_NAMES: ReadonlySet<string>;
+    STABLE_SCRIPT_NAMES: ReadonlySet<string>;
+    NEW_SCRIPT_NAMES: ReadonlySet<string>;
+    buildForProperty: (name: string) => UnicodeRangeTable | null;
+    buildFoldOverlay: (name: string) => UnicodeRangeTable | null;
+    CATEGORIES: {
+        has: (name: string) => boolean;
+        get: (name: string) => UnicodeRangeTable | null;
+    };
+    SCRIPTS: {
+        has: (name: string) => boolean;
+        get: (name: string) => UnicodeRangeTable | null;
+    };
+    FOLD_CATEGORIES: {
+        has: (name: string) => boolean;
+        get: (name: string) => UnicodeRangeTable | null;
+    };
+    FOLD_SCRIPT: {
+        has: (name: string) => boolean;
+        get: (name: string) => UnicodeRangeTable | null;
+    };
+    readonly Upper: UnicodeRangeTable;
+    _deltaCategoryRanges: (name: string) => Uint32Array | null;
+    _deltaScriptRanges: (name: string) => Uint32Array | null;
+    _newScriptTable: (name: string) => UnicodeRangeTable | null;
+};