@bufbuild/re2 0.0.1-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alexey Vasiliev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @bufbuild/re2
+
+This package provides an [RE2-compatible](https://cel.dev) regular expression engine, designed for use with CEL-es and Protovalidate-es.
+
+## Usage
+
+```ts
+import { RE2JS } from '@bufbuild/re2';
+
+const re = new RE2JS('^foo');
+console.log(re.test('foo')); // true
+console.log(re.testExact('fooxyz')); // false
+
+console.log(RE2JS.matches('^foo','foo')); // true
+```
+
+## Limitations
+Only boolean matchers are supported: `test` and `testExact`.
+
+The instance method `matches` is an alias for `testExact`. The static method `RE2JS.matches` compiles 
+a regular expression and calls `testExact`.
+
+As a size optimization, Unicode category and script information is generated on first use. This causes a 
+slight slowdown the first time a pattern is compiled with a category or script (only the referenced category 
+or script is generated). The categories and scripts in Unicode version 16.0 are supported. This package includes
+data to support Unicode version 16.0 on Unicode 15.0 or later.
+
+## Credits
+This code is a fork of the [RE2JS](https://re2js.leopard.in.ua) project. It has been converted to TypeScript and has a feature set tailored for
+CEL and Protovalidate-es.

package/dist/cjs/CharClass.d.ts

@@ -0,0 +1,30 @@
+import type { UnicodeRangeTable } from "./UnicodeRangeTable.js";
+import type { CharGroup } from "./CharGroup.js";
+/**
+ * A "builder"-style helper class for manipulating character classes represented as an array of
+ * pairs of runes [lo, hi], each denoting an inclusive interval.
+ *
+ * All methods mutate the internal state and return {@code this}, allowing operations to be chained.
+ */
+declare class CharClass {
+    static cmp(array: number[], i: number, pivotFrom: number, pivotTo: number): number;
+    static qsortIntPair(array: number[], left: number, right: number): void;
+    r: number[];
+    len: number;
+    constructor(r?: number[]);
+    toArray(): number[];
+    cleanClass(): this;
+    appendLiteral(x: number, flags: number): this;
+    appendRange(lo: number, hi: number): this;
+    appendFoldedRange(lo: number, hi: number): this;
+    appendClass(x: number[]): this;
+    appendFoldedClass(x: number[]): this;
+    appendNegatedClass(x: number[]): this;
+    appendTable(table: UnicodeRangeTable): this;
+    appendNegatedTable(table: UnicodeRangeTable): this;
+    appendTableWithSign(table: UnicodeRangeTable, sign: number): this;
+    negateClass(): this;
+    appendClassWithSign(x: number[], sign: number): this;
+    appendGroup(g: CharGroup, foldCase: boolean): this;
+}
+export { CharClass };

package/dist/cjs/CharClass.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CharClass = void 0;
+const RE2Flags_js_1 = require("./RE2Flags.js");
+const Unicode_js_1 = require("./Unicode.js");
+const Utils_js_1 = require("./Utils.js");
+/**
+ * A "builder"-style helper class for manipulating character classes represented as an array of
+ * pairs of runes [lo, hi], each denoting an inclusive interval.
+ *
+ * All methods mutate the internal state and return {@code this}, allowing operations to be chained.
+ */
+class CharClass {
+    // cmp() returns the ordering of the pair (a[i], a[i+1]) relative to
+    // (pivotFrom, pivotTo), where the first component of the pair (lo) is
+    // ordered naturally and the second component (hi) is in reverse order.
+    static cmp(array, i, pivotFrom, pivotTo) {
+        const cmp = array[i] - pivotFrom;
+        return cmp !== 0 ? cmp : pivotTo - array[i + 1];
+    }
+    // qsortIntPair() quicksorts pairs of ints in |array| according to lt().
+    // Precondition: |left|, |right|, |this.len| must all be even; |this.len > 1|.
+    static qsortIntPair(array, left, right) {
+        const pivotIndex = (((left + right) / 2) | 0) & ~1;
+        const pivotFrom = array[pivotIndex];
+        const pivotTo = array[pivotIndex + 1];
+        let i = left;
+        let j = right;
+        while (i <= j) {
+            while (i < right && CharClass.cmp(array, i, pivotFrom, pivotTo) < 0) {
+                i += 2;
+            }
+            while (j > left && CharClass.cmp(array, j, pivotFrom, pivotTo) > 0) {
+                j -= 2;
+            }
+            if (i <= j) {
+                if (i !== j) {
+                    let temp = array[i];
+                    array[i] = array[j];
+                    array[j] = temp;
+                    temp = array[i + 1];
+                    array[i + 1] = array[j + 1];
+                    array[j + 1] = temp;
+                }
+                i += 2;
+                j -= 2;
+            }
+        }
+        if (left < j) {
+            CharClass.qsortIntPair(array, left, j);
+        }
+        if (i < right) {
+            CharClass.qsortIntPair(array, i, right);
+        }
+    }
+    r;
+    len;
+    constructor(r = (0, Utils_js_1.emptyInts)()) {
+        this.r = r; // inclusive ranges, pairs of [lo,hi].  r.length is even.
+        this.len = r.length; // prefix of |r| that is defined.  Even.
+    }
+    // Returns the character class as an int array.  Subsequent CharClass
+    // operations may mutate this array, so typically this is the last operation
+    // performed on a given CharClass instance.
+    toArray() {
+        if (this.len === this.r.length) {
+            return this.r;
+        }
+        return this.r.slice(0, this.len);
+    }
+    // cleanClass() sorts the ranges (pairs of elements) of this CharClass,
+    // merges them, and eliminates duplicates.
+    cleanClass() {
+        if (this.len < 4) {
+            return this;
+        }
+        // Sort by lo increasing, hi decreasing to break ties.
+        CharClass.qsortIntPair(this.r, 0, this.len - 2);
+        // Merge abutting, overlapping.
+        let w = 2; // write index
+        for (let i = 2; i < this.len; i += 2) {
+            {
+                const lo = this.r[i];
+                const hi = this.r[i + 1];
+                if (lo <= this.r[w - 1] + 1) {
+                    // merge with previous range
+                    if (hi > this.r[w - 1]) {
+                        this.r[w - 1] = hi;
+                    }
+                    continue;
+                }
+                // new disjoint range
+                this.r[w] = lo;
+                this.r[w + 1] = hi;
+                w += 2;
+            }
+        }
+        this.len = w;
+        return this;
+    }
+    // appendLiteral() appends the literal |x| to this CharClass.
+    appendLiteral(x, flags) {
+        return (flags & RE2Flags_js_1.FOLD_CASE) !== 0
+            ? this.appendFoldedRange(x, x)
+            : this.appendRange(x, x);
+    }
+    // appendRange() appends the range [lo-hi] (inclusive) to this CharClass.
+    appendRange(lo, hi) {
+        // Expand last range or next to last range if it overlaps or abuts.
+        // Checking two ranges helps when appending case-folded
+        // alphabets, so that one range can be expanding A-Z and the
+        // other expanding a-z.
+        if (this.len > 0) {
+            for (let i = 2; i <= 4; i += 2) {
+                // twice, using i=2, i=4
+                if (this.len >= i) {
+                    const rlo = this.r[this.len - i];
+                    const rhi = this.r[this.len - i + 1];
+                    if (lo <= rhi + 1 && rlo <= hi + 1) {
+                        if (lo < rlo) {
+                            this.r[this.len - i] = lo;
+                        }
+                        if (hi > rhi) {
+                            this.r[this.len - i + 1] = hi;
+                        }
+                        return this;
+                    }
+                }
+            }
+        }
+        this.r[this.len++] = lo;
+        this.r[this.len++] = hi;
+        return this;
+    }
+    // appendFoldedRange() appends the range [lo-hi] and its case
+    // folding-equivalent runes to this CharClass.
+    appendFoldedRange(lo, hi) {
+        // Optimizations.
+        if (lo <= Unicode_js_1.MIN_FOLD && hi >= Unicode_js_1.MAX_FOLD) {
+            // Range is full: folding can't add more.
+            return this.appendRange(lo, hi);
+        }
+        if (hi < Unicode_js_1.MIN_FOLD || lo > Unicode_js_1.MAX_FOLD) {
+            // Range is outside folding possibilities.
+            return this.appendRange(lo, hi);
+        }
+        if (lo < Unicode_js_1.MIN_FOLD) {
+            // [lo, minFold-1] needs no folding.
+            this.appendRange(lo, Unicode_js_1.MIN_FOLD - 1);
+            lo = Unicode_js_1.MIN_FOLD;
+        }
+        if (hi > Unicode_js_1.MAX_FOLD) {
+            // [maxFold+1, hi] needs no folding.
+            this.appendRange(Unicode_js_1.MAX_FOLD + 1, hi);
+            hi = Unicode_js_1.MAX_FOLD;
+        }
+        // Brute force.  Depend on appendRange to coalesce ranges on the fly.
+        for (let c = lo; c <= hi; c++) {
+            this.appendRange(c, c);
+            for (let f = (0, Unicode_js_1.simpleFold)(c); f !== c; f = (0, Unicode_js_1.simpleFold)(f)) {
+                this.appendRange(f, f);
+            }
+        }
+        return this;
+    }
+    // appendClass() appends the class |x| to this CharClass.
+    // It assumes |x| is clean.  Does not mutate |x|.
+    appendClass(x) {
+        for (let i = 0; i < x.length; i += 2) {
+            this.appendRange(x[i], x[i + 1]);
+        }
+        return this;
+    }
+    // appendFoldedClass() appends the case folding of the class |x| to this
+    // CharClass.  Does not mutate |x|.
+    appendFoldedClass(x) {
+        for (let i = 0; i < x.length; i += 2) {
+            this.appendFoldedRange(x[i], x[i + 1]);
+        }
+        return this;
+    }
+    // appendNegatedClass() append the negation of the class |x| to this
+    // CharClass.  It assumes |x| is clean.  Does not mutate |x|.
+    appendNegatedClass(x) {
+        let nextLo = 0;
+        for (let i = 0; i < x.length; i += 2) {
+            const lo = x[i];
+            const hi = x[i + 1];
+            if (nextLo <= lo - 1) {
+                this.appendRange(nextLo, lo - 1);
+            }
+            nextLo = hi + 1;
+        }
+        if (nextLo <= Unicode_js_1.MAX_RUNE) {
+            this.appendRange(nextLo, Unicode_js_1.MAX_RUNE);
+        }
+        return this;
+    }
+    // appendTable() appends the Unicode range table |table| to this CharClass.
+    // Does not mutate |table|.
+    appendTable(table) {
+        for (let i = 0; i < table.length; ++i) {
+            const lo = table.getLo(i);
+            const hi = table.getHi(i);
+            const stride = table.getStride(i);
+            if (stride === 1) {
+                this.appendRange(lo, hi);
+                continue;
+            }
+            for (let c = lo; c <= hi; c += stride) {
+                this.appendRange(c, c);
+            }
+        }
+        return this;
+    }
+    // appendNegatedTable() returns the result of appending the negation of range
+    // table |table| to this CharClass.  Does not mutate |table|.
+    appendNegatedTable(table) {
+        let nextLo = 0;
+        for (let i = 0; i < table.length; ++i) {
+            const lo = table.getLo(i);
+            const hi = table.getHi(i);
+            const stride = table.getStride(i);
+            if (stride === 1) {
+                if (nextLo <= lo - 1) {
+                    this.appendRange(nextLo, lo - 1);
+                }
+                nextLo = hi + 1;
+                continue;
+            }
+            for (let c = lo; c <= hi; c += stride) {
+                if (nextLo <= c - 1) {
+                    this.appendRange(nextLo, c - 1);
+                }
+                nextLo = c + 1;
+            }
+        }
+        if (nextLo <= Unicode_js_1.MAX_RUNE) {
+            this.appendRange(nextLo, Unicode_js_1.MAX_RUNE);
+        }
+        return this;
+    }
+    // appendTableWithSign() calls append{,Negated}Table depending on sign.
+    // Does not mutate |table|.
+    appendTableWithSign(table, sign) {
+        return sign < 0 ? this.appendNegatedTable(table) : this.appendTable(table);
+    }
+    // negateClass() negates this CharClass, which must already be clean.
+    negateClass() {
+        let nextLo = 0; // lo end of next class to add
+        let w = 0; // write index
+        for (let i = 0; i < this.len; i += 2) {
+            const lo = this.r[i];
+            const hi = this.r[i + 1];
+            if (nextLo <= lo - 1) {
+                this.r[w] = nextLo;
+                this.r[w + 1] = lo - 1;
+                w += 2;
+            }
+            nextLo = hi + 1;
+        }
+        this.len = w;
+        if (nextLo <= Unicode_js_1.MAX_RUNE) {
+            this.r[this.len++] = nextLo;
+            this.r[this.len++] = Unicode_js_1.MAX_RUNE;
+        }
+        return this;
+    }
+    // appendClassWithSign() calls appendClass() if sign is +1 or
+    // appendNegatedClass if sign is -1.  Does not mutate |x|.
+    appendClassWithSign(x, sign) {
+        return sign < 0 ? this.appendNegatedClass(x) : this.appendClass(x);
+    }
+    // appendGroup() appends CharGroup |g| to this CharClass, folding iff
+    // |foldCase|.  Does not mutate |g|.
+    appendGroup(g, foldCase) {
+        let cls = g.cls;
+        if (foldCase) {
+            cls = new CharClass().appendFoldedClass(cls).cleanClass().toArray();
+        }
+        return this.appendClassWithSign(cls, g.sign);
+    }
+}
+exports.CharClass = CharClass;

package/dist/cjs/CharGroup.d.ts

@@ -0,0 +1,8 @@
+declare class CharGroup {
+    sign: number;
+    cls: number[];
+    constructor(sign: number, cls: number[]);
+}
+declare const getPerlGroups: () => Map<string, CharGroup>;
+declare const getPosixGroups: () => Map<string, CharGroup>;
+export { CharGroup, getPerlGroups, getPosixGroups };

package/dist/cjs/CharGroup.js

@@ -0,0 +1,83 @@
+"use strict";
+// GENERATED BY tools/scripts/make_perl_groups.pl; DO NOT EDIT.
+// ./tools/scripts/make_perl_groups.pl  > src/CharGroup.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPosixGroups = exports.getPerlGroups = exports.CharGroup = void 0;
+class CharGroup {
+    sign;
+    cls;
+    constructor(sign, cls) {
+        this.sign = sign;
+        this.cls = cls;
+    }
+}
+exports.CharGroup = CharGroup;
+const code1 = [0x30, 0x39];
+const code2 = [0x9, 0xa, 0xc, 0xd, 0x20, 0x20];
+const code3 = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a];
+let _PERL_GROUPS = null;
+const getPerlGroups = () => {
+    if (!_PERL_GROUPS) {
+        _PERL_GROUPS = new Map([
+            ["\\d", new CharGroup(+1, code1)],
+            ["\\D", new CharGroup(-1, code1)],
+            ["\\s", new CharGroup(+1, code2)],
+            ["\\S", new CharGroup(-1, code2)],
+            ["\\w", new CharGroup(+1, code3)],
+            ["\\W", new CharGroup(-1, code3)],
+        ]);
+    }
+    return _PERL_GROUPS;
+};
+exports.getPerlGroups = getPerlGroups;
+const code4 = [0x30, 0x39, 0x41, 0x5a, 0x61, 0x7a];
+const code5 = [0x41, 0x5a, 0x61, 0x7a];
+const code6 = [0x0, 0x7f];
+const code7 = [0x9, 0x9, 0x20, 0x20];
+const code8 = [0x0, 0x1f, 0x7f, 0x7f];
+const code9 = [0x30, 0x39];
+const code10 = [0x21, 0x7e];
+const code11 = [0x61, 0x7a];
+const code12 = [0x20, 0x7e];
+const code13 = [0x21, 0x2f, 0x3a, 0x40, 0x5b, 0x60, 0x7b, 0x7e];
+const code14 = [0x9, 0xd, 0x20, 0x20];
+const code15 = [0x41, 0x5a];
+const code16 = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a];
+const code17 = [0x30, 0x39, 0x41, 0x46, 0x61, 0x66];
+let _POSIX_GROUPS = null;
+const getPosixGroups = () => {
+    if (!_POSIX_GROUPS) {
+        _POSIX_GROUPS = new Map([
+            ["[:alnum:]", new CharGroup(+1, code4)],
+            ["[:^alnum:]", new CharGroup(-1, code4)],
+            ["[:alpha:]", new CharGroup(+1, code5)],
+            ["[:^alpha:]", new CharGroup(-1, code5)],
+            ["[:ascii:]", new CharGroup(+1, code6)],
+            ["[:^ascii:]", new CharGroup(-1, code6)],
+            ["[:blank:]", new CharGroup(+1, code7)],
+            ["[:^blank:]", new CharGroup(-1, code7)],
+            ["[:cntrl:]", new CharGroup(+1, code8)],
+            ["[:^cntrl:]", new CharGroup(-1, code8)],
+            ["[:digit:]", new CharGroup(+1, code9)],
+            ["[:^digit:]", new CharGroup(-1, code9)],
+            ["[:graph:]", new CharGroup(+1, code10)],
+            ["[:^graph:]", new CharGroup(-1, code10)],
+            ["[:lower:]", new CharGroup(+1, code11)],
+            ["[:^lower:]", new CharGroup(-1, code11)],
+            ["[:print:]", new CharGroup(+1, code12)],
+            ["[:^print:]", new CharGroup(-1, code12)],
+            ["[:punct:]", new CharGroup(+1, code13)],
+            ["[:^punct:]", new CharGroup(-1, code13)],
+            ["[:space:]", new CharGroup(+1, code14)],
+            ["[:^space:]", new CharGroup(-1, code14)],
+            ["[:upper:]", new CharGroup(+1, code15)],
+            ["[:^upper:]", new CharGroup(-1, code15)],
+            ["[:word:]", new CharGroup(+1, code16)],
+            ["[:^word:]", new CharGroup(-1, code16)],
+            ["[:xdigit:]", new CharGroup(+1, code17)],
+            ["[:^xdigit:]", new CharGroup(-1, code17)],
+        ]);
+    }
+    return _POSIX_GROUPS;
+};
+exports.getPosixGroups = getPosixGroups;

package/dist/cjs/Codepoint.d.ts

@@ -0,0 +1,3 @@
+declare function toUpperCase(codepoint: number): number;
+declare function toLowerCase(codepoint: number): number;
+export { toUpperCase, toLowerCase };

package/dist/cjs/Codepoint.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toUpperCase = toUpperCase;
+exports.toLowerCase = toLowerCase;
+/**
+ * Various constants and helper for unicode codepoints.
+ */
+const ASCII_SIZE = 128;
+let _ASCII_TO_UPPER = null;
+let _ASCII_TO_LOWER = null;
+const getAsciiToUpper = () => {
+    if (!_ASCII_TO_UPPER) {
+        _ASCII_TO_UPPER = new Int32Array(ASCII_SIZE);
+        for (let i = 0; i < ASCII_SIZE; i++) {
+            _ASCII_TO_UPPER[i] = i >= 97 && i <= 122 ? i - 32 : i;
+        }
+    }
+    return _ASCII_TO_UPPER;
+};
+const getAsciiToLower = () => {
+    if (!_ASCII_TO_LOWER) {
+        _ASCII_TO_LOWER = new Int32Array(ASCII_SIZE);
+        for (let i = 0; i < ASCII_SIZE; i++) {
+            _ASCII_TO_LOWER[i] = i >= 65 && i <= 90 ? i + 32 : i;
+        }
+    }
+    return _ASCII_TO_LOWER;
+};
+function toUpperCase(codepoint) {
+    if (codepoint < ASCII_SIZE)
+        return getAsciiToUpper()[codepoint];
+    const s = String.fromCodePoint(codepoint).toUpperCase();
+    if (s.length > 1) {
+        return codepoint;
+    }
+    const cp = s.codePointAt(0);
+    if (cp === undefined) {
+        return codepoint;
+    }
+    const sOrigin = String.fromCodePoint(cp).toLowerCase();
+    if (sOrigin.length > 1 || sOrigin.codePointAt(0) !== codepoint) {
+        return codepoint;
+    }
+    return cp;
+}
+function toLowerCase(codepoint) {
+    if (codepoint < ASCII_SIZE)
+        return getAsciiToLower()[codepoint];
+    const s = String.fromCodePoint(codepoint).toLowerCase();
+    if (s.length > 1) {
+        return codepoint;
+    }
+    const cp = s.codePointAt(0);
+    if (cp === undefined) {
+        return codepoint;
+    }
+    const sOrigin = String.fromCodePoint(cp).toUpperCase();
+    if (sOrigin.length > 1 || sOrigin.codePointAt(0) !== codepoint) {
+        return codepoint;
+    }
+    return cp;
+}

package/dist/cjs/Compiler.d.ts

@@ -0,0 +1,40 @@
+import { Regexp } from "./Regexp.js";
+import { Prog, PatchList } from "./Prog.js";
+/**
+ * A fragment of a compiled regular expression program.
+ *
+ * @see http://swtch.com/~rsc/regexp/regexp1.html
+ * @class
+ */
+declare class Frag {
+    i: number;
+    out: PatchList;
+    nullable: boolean;
+    constructor(i?: number, out?: PatchList, nullable?: boolean);
+}
+/**
+ * Compiler from {@code Regexp} (RE2 abstract syntax) to {@code RE2} (compiled regular expression).
+ *
+ * The only entry point is {@link #compileRegexp}.
+ */
+declare class Compiler {
+    prog: Prog;
+    static ANY_RUNE_NOT_NL(): number[];
+    static ANY_RUNE(): number[];
+    static compileRegexp(re: Regexp): Prog;
+    constructor();
+    newInst(op: number): Frag;
+    nop(): Frag;
+    fail(): Frag;
+    cap(arg: number): Frag;
+    cat(f1: Frag, f2: Frag): Frag;
+    alt(f1: Frag, f2: Frag): Frag;
+    loop(f1: Frag, nongreedy: boolean): Frag;
+    quest(f1: Frag, nongreedy: boolean): Frag;
+    star(f1: Frag, nongreedy: boolean): Frag;
+    plus(f1: Frag, nongreedy: boolean): Frag;
+    empty(op: number): Frag;
+    rune(runes: number[], flags: number): Frag;
+    compile(re: Regexp): Frag;
+}
+export { Compiler };