@bufbuild/re2 0.0.1-alpha.1

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/testParser.d.ts

@@ -0,0 +1,3 @@
+import { Regexp } from "./Regexp.js";
+export declare const dumpRegexp: (re: Regexp) => string;
+export declare const mkCharClass: (f: (r: number) => boolean) => string;

package/dist/cjs/testParser.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mkCharClass = exports.dumpRegexp = void 0;
+const RE2Flags_js_1 = require("./RE2Flags.js");
+const Regexp_js_1 = require("./Regexp.js");
+const Unicode_js_1 = require("./Unicode.js");
+const OP_NAMES = new Map([
+    [Regexp_js_1.Regexp.Op.NO_MATCH, "no"],
+    [Regexp_js_1.Regexp.Op.EMPTY_MATCH, "emp"],
+    [Regexp_js_1.Regexp.Op.LITERAL, "lit"],
+    [Regexp_js_1.Regexp.Op.CHAR_CLASS, "cc"],
+    [Regexp_js_1.Regexp.Op.ANY_CHAR_NOT_NL, "dnl"],
+    [Regexp_js_1.Regexp.Op.ANY_CHAR, "dot"],
+    [Regexp_js_1.Regexp.Op.BEGIN_LINE, "bol"],
+    [Regexp_js_1.Regexp.Op.END_LINE, "eol"],
+    [Regexp_js_1.Regexp.Op.BEGIN_TEXT, "bot"],
+    [Regexp_js_1.Regexp.Op.END_TEXT, "eot"],
+    [Regexp_js_1.Regexp.Op.WORD_BOUNDARY, "wb"],
+    [Regexp_js_1.Regexp.Op.NO_WORD_BOUNDARY, "nwb"],
+    [Regexp_js_1.Regexp.Op.CAPTURE, "cap"],
+    [Regexp_js_1.Regexp.Op.STAR, "star"],
+    [Regexp_js_1.Regexp.Op.PLUS, "plus"],
+    [Regexp_js_1.Regexp.Op.QUEST, "que"],
+    [Regexp_js_1.Regexp.Op.REPEAT, "rep"],
+    [Regexp_js_1.Regexp.Op.CONCAT, "cat"],
+    [Regexp_js_1.Regexp.Op.ALTERNATE, "alt"],
+]);
+const dumpRegexp = (re) => {
+    let b = "";
+    if (!OP_NAMES.has(re.op)) {
+        b += `op${re.op}`;
+    }
+    else {
+        const name = OP_NAMES.get(re.op);
+        switch (re.op) {
+            case Regexp_js_1.Regexp.Op.STAR:
+            case Regexp_js_1.Regexp.Op.PLUS:
+            case Regexp_js_1.Regexp.Op.QUEST:
+            case Regexp_js_1.Regexp.Op.REPEAT:
+                if ((re.flags & RE2Flags_js_1.NON_GREEDY) !== 0) {
+                    b += "n";
+                }
+                b += name;
+                break;
+            case Regexp_js_1.Regexp.Op.LITERAL:
+                if (re.runes.length > 1) {
+                    b += "str";
+                }
+                else {
+                    b += "lit";
+                }
+                if ((re.flags & RE2Flags_js_1.FOLD_CASE) !== 0) {
+                    for (let r of re.runes) {
+                        if ((0, Unicode_js_1.simpleFold)(r) !== r) {
+                            b += "fold";
+                            break;
+                        }
+                    }
+                }
+                break;
+            default:
+                b += name;
+                break;
+        }
+    }
+    b += "{";
+    switch (re.op) {
+        case Regexp_js_1.Regexp.Op.END_TEXT:
+            if ((re.flags & RE2Flags_js_1.WAS_DOLLAR) === 0) {
+                b += "\\z";
+            }
+            break;
+        case Regexp_js_1.Regexp.Op.LITERAL:
+            for (let r of re.runes) {
+                b += String.fromCodePoint(r);
+            }
+            break;
+        case Regexp_js_1.Regexp.Op.CONCAT:
+        case Regexp_js_1.Regexp.Op.ALTERNATE:
+            for (let sub of re.subs) {
+                b += (0, exports.dumpRegexp)(sub);
+            }
+            break;
+        case Regexp_js_1.Regexp.Op.STAR:
+        case Regexp_js_1.Regexp.Op.PLUS:
+        case Regexp_js_1.Regexp.Op.QUEST:
+            b += (0, exports.dumpRegexp)(re.subs[0]);
+            break;
+        case Regexp_js_1.Regexp.Op.REPEAT:
+            b += `${re.min},${re.max}`;
+            b += " ";
+            b += (0, exports.dumpRegexp)(re.subs[0]);
+            break;
+        case Regexp_js_1.Regexp.Op.CAPTURE:
+            if (re.name !== null && re.name.length > 0) {
+                b += re.name;
+                b += ":";
+            }
+            b += (0, exports.dumpRegexp)(re.subs[0]);
+            break;
+        case Regexp_js_1.Regexp.Op.CHAR_CLASS: {
+            let sep = "";
+            for (let i = 0; i < re.runes.length; i += 2) {
+                b += sep;
+                sep = " ";
+                let lo = re.runes[i];
+                let hi = re.runes[i + 1];
+                if (lo === hi) {
+                    b += `0x${lo.toString(16)}`;
+                }
+                else {
+                    b += `0x${lo.toString(16)}-0x${hi.toString(16)}`;
+                }
+            }
+            break;
+        }
+    }
+    b += "}";
+    return b;
+};
+exports.dumpRegexp = dumpRegexp;
+const mkCharClass = (f) => {
+    const re = new Regexp_js_1.Regexp(Regexp_js_1.Regexp.Op.CHAR_CLASS);
+    let runes = [];
+    let lo = -1;
+    for (let i = 0; i <= Unicode_js_1.MAX_RUNE; i++) {
+        if (f(i)) {
+            if (lo < 0) {
+                lo = i;
+            }
+        }
+        else if (lo >= 0) {
+            runes = [...runes, lo, i - 1];
+            lo = -1;
+        }
+    }
+    if (lo >= 0) {
+        runes = [...runes, lo, Unicode_js_1.MAX_RUNE];
+    }
+    re.runes = runes;
+    return (0, exports.dumpRegexp)(re);
+};
+exports.mkCharClass = mkCharClass;

package/dist/esm/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/esm/CharClass.js

@@ -0,0 +1,281 @@
+import { FOLD_CASE } from "./RE2Flags.js";
+import { MAX_FOLD, MAX_RUNE, MIN_FOLD, simpleFold } from "./Unicode.js";
+import { emptyInts } from "./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 = 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 & 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 <= MIN_FOLD && hi >= MAX_FOLD) {
+            // Range is full: folding can't add more.
+            return this.appendRange(lo, hi);
+        }
+        if (hi < MIN_FOLD || lo > MAX_FOLD) {
+            // Range is outside folding possibilities.
+            return this.appendRange(lo, hi);
+        }
+        if (lo < MIN_FOLD) {
+            // [lo, minFold-1] needs no folding.
+            this.appendRange(lo, MIN_FOLD - 1);
+            lo = MIN_FOLD;
+        }
+        if (hi > MAX_FOLD) {
+            // [maxFold+1, hi] needs no folding.
+            this.appendRange(MAX_FOLD + 1, hi);
+            hi = 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 = simpleFold(c); f !== c; f = 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 <= MAX_RUNE) {
+            this.appendRange(nextLo, 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 <= MAX_RUNE) {
+            this.appendRange(nextLo, 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 <= MAX_RUNE) {
+            this.r[this.len++] = nextLo;
+            this.r[this.len++] = 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);
+    }
+}
+export { CharClass };

package/dist/esm/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/esm/CharGroup.js

@@ -0,0 +1,78 @@
+// GENERATED BY tools/scripts/make_perl_groups.pl; DO NOT EDIT.
+// ./tools/scripts/make_perl_groups.pl  > src/CharGroup.js
+class CharGroup {
+    sign;
+    cls;
+    constructor(sign, cls) {
+        this.sign = sign;
+        this.cls = cls;
+    }
+}
+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;
+};
+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;
+};
+export { CharGroup, getPerlGroups, getPosixGroups };

package/dist/esm/Codepoint.d.ts

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

package/dist/esm/Codepoint.js

@@ -0,0 +1,59 @@
+/**
+ * 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;
+}
+export { toUpperCase, toLowerCase };

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