@bufbuild/re2 0.0.1-alpha.1

package/dist/esm/UnicodeTables.js

@@ -0,0 +1,568 @@
+// GENERATED BY tools/scripts/genUnicodeTable.js; DO NOT EDIT.
+// yarn node ./tools/scripts/genUnicodeTable.js > src/UnicodeTables.ts
+import { UnicodeRangeTable } from "./UnicodeRangeTable.js";
+let _B64_MAP = null;
+const getB64Map = () => {
+    if (!_B64_MAP) {
+        _B64_MAP = new Uint8Array(256);
+        const b = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-";
+        for (let i = 0; i < 64; i++) {
+            _B64_MAP[b.charCodeAt(i)] = i;
+        }
+    }
+    return _B64_MAP;
+};
+const decodeVLQ = (str) => {
+    const b64 = getB64Map();
+    const res = [];
+    let value = 0, shift = 0;
+    for (let i = 0; i < str.length; i++) {
+        const digit = b64[str.charCodeAt(i)];
+        value |= (digit & 0x1f) << shift;
+        if ((digit & 0x20) === 0) {
+            res.push(value);
+            value = 0;
+            shift = 0;
+        }
+        else {
+            shift += 5;
+        }
+    }
+    return res;
+};
+const decodeRanges = (str, isStride1) => {
+    if (str.length === 0)
+        return new Uint32Array(0);
+    const res = decodeVLQ(str);
+    const numRanges = isStride1 ? res.length / 2 : res.length / 3;
+    const out = new Uint32Array(numRanges * 3);
+    let current = 0, resIdx = 0;
+    for (let i = 0; i < numRanges; i++) {
+        current += res[resIdx++];
+        out[i * 3] = current;
+        current += res[resIdx++];
+        out[i * 3 + 1] = current;
+        out[i * 3 + 2] = isStride1 ? 1 : res[resIdx++];
+    }
+    return out;
+};
+const decodeOrbit = (str) => {
+    const res = decodeVLQ(str);
+    const map = new Map();
+    let currentKey = 0;
+    for (let i = 0; i < res.length; i += 2) {
+        currentKey += res[i];
+        map.set(currentKey, res[i + 1]);
+    }
+    return map;
+};
+// Merges two stride-encoded UnicodeRangeTables. Expands any stride>1
+// ranges to individual codepoints, then coalesces contiguous runs.
+const mergeRanges = (a, b) => {
+    if (b.length === 0)
+        return a;
+    if (a.length === 0)
+        return b;
+    const points = [];
+    const push = (arr) => {
+        for (let i = 0; i < arr.length; i += 3) {
+            const lo = arr[i], hi = arr[i + 1], stride = arr[i + 2];
+            if (stride === 1) {
+                points.push([lo, hi]);
+            }
+            else {
+                for (let cp = lo; cp <= hi; cp += stride)
+                    points.push([cp, cp]);
+            }
+        }
+    };
+    push(a);
+    push(b);
+    points.sort((x, y) => x[0] - y[0]);
+    const merged = [];
+    for (const [lo, hi] of points) {
+        const last = merged[merged.length - 1];
+        if (last && last[1] + 1 >= lo) {
+            if (hi > last[1])
+                last[1] = hi;
+        }
+        else {
+            merged.push([lo, hi]);
+        }
+    }
+    const out = new Uint32Array(merged.length * 3);
+    for (let i = 0; i < merged.length; i++) {
+        out[i * 3] = merged[i][0];
+        out[i * 3 + 1] = merged[i][1];
+        out[i * 3 + 2] = 1;
+    }
+    return out;
+};
+// Sweeps the codepoint space using a platform property-escape regex and
+// returns stride-1 ranges. Surrogates are included — String.fromCodePoint
+// returns the lone surrogate char and platform regex matches \p{Cs} on it.
+const sweepPlatform = (pattern) => {
+    const re = new RegExp(pattern, "u");
+    const ranges = [];
+    let start = -1;
+    for (let cp = 0; cp <= 0x10ffff; cp++) {
+        if (re.test(String.fromCodePoint(cp))) {
+            if (start < 0)
+                start = cp;
+        }
+        else if (start >= 0) {
+            ranges.push(start, cp - 1, 1);
+            start = -1;
+        }
+    }
+    if (start >= 0)
+        ranges.push(start, 0x10ffff, 1);
+    return Uint32Array.from(ranges);
+};
+class LazyDecoder {
+    initializer;
+    cache;
+    constructor(initializer) {
+        this.initializer = initializer;
+        this.cache = new Map();
+    }
+    has(key) {
+        return key in this.initializer;
+    }
+    get(key) {
+        const cached = this.cache.get(key);
+        if (cached !== undefined || this.cache.has(key)) {
+            return cached ?? null;
+        }
+        const fn = this.initializer[key];
+        const val = fn ? fn() : null;
+        this.cache.set(key, val);
+        return val;
+    }
+}
+let _CASE_ORBIT = null;
+const getCASE_ORBIT = () => {
+    if (!_CASE_ORBIT) {
+        _CASE_ORBIT = decodeOrbit("rDqpII-LsD+0HGrpIsCxJzElODoODrOnByP-Mz+HTieNj-HCweD1fDxeB+9HBwfC1FE2eBxfBjeE1eDmpII0fjB4c+BgkHChkHKikHDjkHBkkHImkHZnkHhhGlkH9O70H-Io8HBp8HBq8HBr8HBs8HBt8HBu8HBv8HJ48HB58HB68HB78HB88HB98HB+8HB-8HJo9HBp9HBq9HBr9HBs9HBt9HBu9HBv9HM89HLlaFs+HQwcQwdQ8-HzJpdErCBlGgphBokHjMu+pBBv+pBDy+pBBz+pBB0+pBB1+pBw5Um4+BBl4+B68cg17CBh17CBi17CBj17CBk17CBl17CBm17CBn17CBo17CBp17CBq17CBr17CBs17CBt17CBu17CBv17CBw17CBx17CBy17CBz17CB017CB117CB217CB317CB417CD717CB817CB917CB+17CB-17CBg27CBh27CBi27CBj27CBk27CBl27CBm27CBn27CBo27CBp27CBq27CBr27CBs27CBt27CBu27CBv27CBw27CBx27CBy27CBz27C");
+    }
+    return _CASE_ORBIT;
+};
+// Additions from Unicode 15.0 → 16.0 per stable general-category name.
+// Merged unconditionally with platform sweep output; no-op on 16.0+ engines.
+const _DELTA_CATEGORIES = /*#__PURE__*/ new LazyDecoder({
+    L: () => decodeRanges("pkHBBh6iBCBNCBkvXzBB36BbBKWB9JCB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBjhDsBBz8HxmWxmWBcBDgwhCgwhCBsTB", false),
+    LC: () => decodeRanges("pkHBh6iBCNC0rZVLV", true),
+    Ll: () => decodeRanges("qkHj6iBj6iBO1sZ1sZBUB", false),
+    Lm: () => decodeRanges("uqjChBhBx+XCBpBBB", false),
+    Lo: () => decodeRanges("guhCzBB36BDBCzLzLBBB8lBJBCDDClBBCaaCt-Bt-BBfBgkG68DBmoHdBmhDnBB18HxmWxmWBcBDgwhCgwhCBsTB", false),
+    Lu: () => decodeRanges("pkHi6iBi6iBBOOC0rZ0rZBUB", false),
+    M: () => decodeRanges("3kCymhCymhCBDBvM8lB8lBBHBCDDCDBCEBCPPB47C47CkuQRB-lhBBB", false),
+    Mc: () => decodeRanges("49kCCBIDDCDBCBBCvavaswSCB", false),
+    Mn: () => decodeRanges("3kCymhCymhCBDBvM-lB-lBBEBOECPBB47CkuQkuQBKBECB-lhBBB", false),
+    N: () => decodeRanges("gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ", true),
+    Nd: () => decodeRanges("gqjCJnsCTtoBJ3pRJ3hDJ37XJ4nGJ", true),
+    P: () => decodeRanges("u6GBBwBvv8Bvv8BmzBBBCBBpgCssUssUBBBwkeAB", false),
+    Pd: () => decodeRanges("urjCA", true),
+    Po: () => decodeRanges("u6GBBwB1i+B1i+BBCCBpgCpgCssUCBwkeAB", false),
+    S: () => decodeRanges("nhJCBz+CDBlPBBK-82B-82BBxzvBxzvBBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", false),
+    Sm: () => decodeRanges("usjCB", true),
+    So: () => decodeRanges("nhJCBz+CDBlPBBKxwmDxwmDBuHBRzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", false),
+});
+// Additions from Unicode 15.0 → 16.0 per stable script name.
+const _DELTA_SCRIPTS = /*#__PURE__*/ new LazyDecoder({
+    Arabic: () => decodeRanges("3kCrxhCrxhCBBB4BAB", false),
+    Balinese: () => decodeRanges("u6GBwBA", true),
+    Common: () => decodeRanges("nhJCBz+CDBlPBBKxwmDxwmDB4HBHzNB-vKJBFBBoOGGvBIIWDDKiHiHBjBB", false),
+    Cyrillic: () => decodeRanges("pkHB", true),
+    Egyptian_Hieroglyphs: () => decodeRanges("gjtC68D", true),
+    Han: () => decodeRanges("w-6FtT", true),
+    Kawi: () => decodeRanges("66nCA", true),
+    Khitan_Small_Script: () => decodeRanges("-njDA", true),
+    Latin: () => decodeRanges("r+pBCNC", true),
+    Myanmar: () => decodeRanges("w2lCT", true),
+});
+// Full tables for scripts added in Unicode 16.0. Engines < 16.0 throw
+// SyntaxError on these names, so platform sweep is impossible.
+const _NEW_SCRIPTS = /*#__PURE__*/ new LazyDecoder({
+    Garay: () => new UnicodeRangeTable(decodeRanges("gqjClBEcJB", true)),
+    Gurung_Khema: () => new UnicodeRangeTable(decodeRanges("go4C5B", true)),
+    Kirat_Rai: () => new UnicodeRangeTable(decodeRanges("gq7C5B", true)),
+    Ol_Onal: () => new UnicodeRangeTable(decodeRanges("wu5DqBFA", true)),
+    Sunuwar: () => new UnicodeRangeTable(decodeRanges("g+mChBPJ", true)),
+    Todhri: () => new UnicodeRangeTable(decodeRanges("guhCzB", true)),
+    Tulu_Tigalari: () => new UnicodeRangeTable(decodeRanges("g8kCJBCDDClBBCJBCDDCDBCJBCBBJBB", false)),
+});
+const STABLE_CATEGORY_NAMES = new Set([
+    "C",
+    "Cc",
+    "Cf",
+    "Cn",
+    "Co",
+    "Cs",
+    "L",
+    "LC",
+    "Ll",
+    "Lm",
+    "Lo",
+    "Lt",
+    "Lu",
+    "M",
+    "Mc",
+    "Me",
+    "Mn",
+    "N",
+    "Nd",
+    "Nl",
+    "No",
+    "P",
+    "Pc",
+    "Pd",
+    "Pe",
+    "Pf",
+    "Pi",
+    "Po",
+    "Ps",
+    "S",
+    "Sc",
+    "Sk",
+    "Sm",
+    "So",
+    "Z",
+    "Zl",
+    "Zp",
+    "Zs",
+]);
+const STABLE_SCRIPT_NAMES = new Set([
+    "Adlam",
+    "Ahom",
+    "Anatolian_Hieroglyphs",
+    "Arabic",
+    "Armenian",
+    "Avestan",
+    "Balinese",
+    "Bamum",
+    "Bassa_Vah",
+    "Batak",
+    "Bengali",
+    "Bhaiksuki",
+    "Bopomofo",
+    "Brahmi",
+    "Braille",
+    "Buginese",
+    "Buhid",
+    "Canadian_Aboriginal",
+    "Carian",
+    "Caucasian_Albanian",
+    "Chakma",
+    "Cham",
+    "Cherokee",
+    "Chorasmian",
+    "Common",
+    "Coptic",
+    "Cuneiform",
+    "Cypriot",
+    "Cypro_Minoan",
+    "Cyrillic",
+    "Deseret",
+    "Devanagari",
+    "Dives_Akuru",
+    "Dogra",
+    "Duployan",
+    "Egyptian_Hieroglyphs",
+    "Elbasan",
+    "Elymaic",
+    "Ethiopic",
+    "Georgian",
+    "Glagolitic",
+    "Gothic",
+    "Grantha",
+    "Greek",
+    "Gujarati",
+    "Gunjala_Gondi",
+    "Gurmukhi",
+    "Han",
+    "Hangul",
+    "Hanifi_Rohingya",
+    "Hanunoo",
+    "Hatran",
+    "Hebrew",
+    "Hiragana",
+    "Imperial_Aramaic",
+    "Inherited",
+    "Inscriptional_Pahlavi",
+    "Inscriptional_Parthian",
+    "Javanese",
+    "Kaithi",
+    "Kannada",
+    "Katakana",
+    "Kawi",
+    "Kayah_Li",
+    "Kharoshthi",
+    "Khitan_Small_Script",
+    "Khmer",
+    "Khojki",
+    "Khudawadi",
+    "Lao",
+    "Latin",
+    "Lepcha",
+    "Limbu",
+    "Linear_A",
+    "Linear_B",
+    "Lisu",
+    "Lycian",
+    "Lydian",
+    "Mahajani",
+    "Makasar",
+    "Malayalam",
+    "Mandaic",
+    "Manichaean",
+    "Marchen",
+    "Masaram_Gondi",
+    "Medefaidrin",
+    "Meetei_Mayek",
+    "Mende_Kikakui",
+    "Meroitic_Cursive",
+    "Meroitic_Hieroglyphs",
+    "Miao",
+    "Modi",
+    "Mongolian",
+    "Mro",
+    "Multani",
+    "Myanmar",
+    "Nabataean",
+    "Nag_Mundari",
+    "Nandinagari",
+    "New_Tai_Lue",
+    "Newa",
+    "Nko",
+    "Nushu",
+    "Nyiakeng_Puachue_Hmong",
+    "Ogham",
+    "Ol_Chiki",
+    "Old_Hungarian",
+    "Old_Italic",
+    "Old_North_Arabian",
+    "Old_Permic",
+    "Old_Persian",
+    "Old_Sogdian",
+    "Old_South_Arabian",
+    "Old_Turkic",
+    "Old_Uyghur",
+    "Oriya",
+    "Osage",
+    "Osmanya",
+    "Pahawh_Hmong",
+    "Palmyrene",
+    "Pau_Cin_Hau",
+    "Phags_Pa",
+    "Phoenician",
+    "Psalter_Pahlavi",
+    "Rejang",
+    "Runic",
+    "Samaritan",
+    "Saurashtra",
+    "Sharada",
+    "Shavian",
+    "Siddham",
+    "SignWriting",
+    "Sinhala",
+    "Sogdian",
+    "Sora_Sompeng",
+    "Soyombo",
+    "Sundanese",
+    "Syloti_Nagri",
+    "Syriac",
+    "Tagalog",
+    "Tagbanwa",
+    "Tai_Le",
+    "Tai_Tham",
+    "Tai_Viet",
+    "Takri",
+    "Tamil",
+    "Tangsa",
+    "Tangut",
+    "Telugu",
+    "Thaana",
+    "Thai",
+    "Tibetan",
+    "Tifinagh",
+    "Tirhuta",
+    "Toto",
+    "Ugaritic",
+    "Unknown",
+    "Vai",
+    "Vithkuqi",
+    "Wancho",
+    "Warang_Citi",
+    "Yezidi",
+    "Yi",
+    "Zanabazar_Square",
+]);
+const NEW_SCRIPT_NAMES = new Set([
+    "Garay",
+    "Gurung_Khema",
+    "Kirat_Rai",
+    "Ol_Onal",
+    "Sunuwar",
+    "Todhri",
+    "Tulu_Tigalari",
+]);
+const _sweepCache = new Map();
+const _foldCache = new Map();
+// Returns the base range table for a property name, or null if unknown.
+// Stable names: platform sweep + bundled delta (15.0 → 16.0).
+// New-in-16.0 script names: bundled full table.
+const buildForProperty = (name) => {
+    if (NEW_SCRIPT_NAMES.has(name)) {
+        return _NEW_SCRIPTS.get(name);
+    }
+    let kind = null;
+    let pattern = null;
+    if (STABLE_CATEGORY_NAMES.has(name)) {
+        kind = "category";
+        pattern = `\\p{General_Category=${name}}`;
+    }
+    else if (STABLE_SCRIPT_NAMES.has(name)) {
+        kind = "script";
+        pattern = `\\p{Script=${name}}`;
+    }
+    else
+        return null;
+    const cacheKey = `${kind}:${name}`;
+    const cached = _sweepCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const base = sweepPlatform(pattern);
+    const delta = kind === "category"
+        ? _DELTA_CATEGORIES.get(name)
+        : _DELTA_SCRIPTS.get(name);
+    const merged = delta ? mergeRanges(base, delta) : base;
+    const table = new UnicodeRangeTable(merged);
+    _sweepCache.set(cacheKey, table);
+    return table;
+};
+// Computes the fold-overlay for a property name: additional runes that
+// fold to some rune already in the base class. Returns null if no overlay
+// is needed (base class is fold-stable).
+const buildFoldOverlay = (name) => {
+    const cached = _foldCache.get(name);
+    if (cached !== undefined)
+        return cached;
+    const base = buildForProperty(name);
+    if (!base) {
+        _foldCache.set(name, null);
+        return null;
+    }
+    const inBase = (r) => {
+        let lo = 0, hi = base.length;
+        while (lo < hi) {
+            const m = (lo + hi) >> 1;
+            const rlo = base.getLo(m), rhi = base.getHi(m);
+            if (r < rlo)
+                hi = m;
+            else if (r > rhi)
+                lo = m + 1;
+            else
+                return (r - rlo) % base.getStride(m) === 0;
+        }
+        return false;
+    };
+    // Inline simpleFold to avoid circular import with Unicode.ts.
+    const orbit = getCASE_ORBIT();
+    const simpleFold = (r) => {
+        const folded = orbit.get(r);
+        if (folded !== undefined)
+            return folded;
+        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;
+    };
+    const extras = new Set();
+    for (let i = 0; i < base.length; i++) {
+        const lo = base.getLo(i), hi = base.getHi(i), stride = base.getStride(i);
+        for (let cp = lo; cp <= hi; cp += stride) {
+            let r = simpleFold(cp);
+            while (r !== cp) {
+                if (!inBase(r))
+                    extras.add(r);
+                r = simpleFold(r);
+            }
+        }
+    }
+    if (extras.size === 0) {
+        _foldCache.set(name, null);
+        return null;
+    }
+    const sorted = Array.from(extras).sort((a, b) => a - b);
+    const merged = [];
+    for (const cp of sorted) {
+        const last = merged[merged.length - 1];
+        if (last && last[1] + 1 === cp)
+            last[1] = cp;
+        else
+            merged.push([cp, cp]);
+    }
+    const out = new Uint32Array(merged.length * 3);
+    for (let i = 0; i < merged.length; i++) {
+        out[i * 3] = merged[i][0];
+        out[i * 3 + 1] = merged[i][1];
+        out[i * 3 + 2] = 1;
+    }
+    const table = new UnicodeRangeTable(out);
+    _foldCache.set(name, table);
+    return table;
+};
+const getUpper = () => {
+    const table = buildForProperty("Lu");
+    if (table === null) {
+        throw new Error("Upper: missing Lu property");
+    }
+    return table;
+};
+// --- Legacy API surface used by Parser ---
+export const UnicodeTables = {
+    get CASE_ORBIT() {
+        return getCASE_ORBIT();
+    },
+    STABLE_CATEGORY_NAMES,
+    STABLE_SCRIPT_NAMES,
+    NEW_SCRIPT_NAMES,
+    buildForProperty,
+    buildFoldOverlay,
+    CATEGORIES: {
+        has: (name) => STABLE_CATEGORY_NAMES.has(name),
+        get: (name) => buildForProperty(name),
+    },
+    SCRIPTS: {
+        has: (name) => STABLE_SCRIPT_NAMES.has(name) || NEW_SCRIPT_NAMES.has(name),
+        get: (name) => buildForProperty(name),
+    },
+    FOLD_CATEGORIES: {
+        has: (name) => STABLE_CATEGORY_NAMES.has(name),
+        get: (name) => buildFoldOverlay(name),
+    },
+    FOLD_SCRIPT: {
+        has: (name) => STABLE_SCRIPT_NAMES.has(name) || NEW_SCRIPT_NAMES.has(name),
+        get: (name) => buildFoldOverlay(name),
+    },
+    get Upper() {
+        return getUpper();
+    },
+    // --- Test-only hooks: expose the raw bundled 15.0→16.0 delta and
+    // new-in-16.0 script data so tests can verify the generator output.
+    // These are not part of the public API.
+    _deltaCategoryRanges: (name) => _DELTA_CATEGORIES.get(name),
+    _deltaScriptRanges: (name) => _DELTA_SCRIPTS.get(name),
+    _newScriptTable: (name) => _NEW_SCRIPTS.get(name),
+};

package/dist/esm/Utils.d.ts

@@ -0,0 +1,22 @@
+declare const EMPTY_BEGIN_LINE = 1;
+declare const EMPTY_END_LINE = 2;
+declare const EMPTY_BEGIN_TEXT = 4;
+declare const EMPTY_END_TEXT = 8;
+declare const EMPTY_WORD_BOUNDARY = 16;
+declare const EMPTY_NO_WORD_BOUNDARY = 32;
+declare function emptyInts(): number[];
+declare function isalnum(c: number): boolean;
+declare function unhex(c: number): number;
+declare function stringToRunes(str: string): number[];
+declare function runeToString(r: number): string;
+declare function emptyOpContext(r1: number, r2: number): number;
+/**
+ * Returns a string that quotes all regular expression metacharacters inside the argument text;
+ * the returned string is a regular expression matching the literal text. For example,
+ * {@code quoteMeta("[foo]").equals("\\[foo\\]")}.
+ * @param {string} str
+ * @returns {string}
+ */
+declare function quoteMeta(str: string): string;
+declare function charCount(codePoint: number): number;
+export { emptyInts, runeToString, emptyOpContext, charCount, stringToRunes, isalnum, unhex, quoteMeta, EMPTY_BEGIN_LINE, EMPTY_END_LINE, EMPTY_WORD_BOUNDARY, EMPTY_BEGIN_TEXT, EMPTY_END_TEXT, EMPTY_NO_WORD_BOUNDARY, };

package/dist/esm/Utils.js

@@ -0,0 +1,103 @@
+import { MAX_BMP } from "./Unicode.js";
+import { codePointAtOrThrow } from "./chars.js";
+/**
+ * Various constants and helper utilities.
+ */
+const METACHARACTERS = "\\.+*?()|[]{}^$";
+//// EMPTY_* flags
+const EMPTY_BEGIN_LINE = 0x01;
+const EMPTY_END_LINE = 0x02;
+const EMPTY_BEGIN_TEXT = 0x04;
+const EMPTY_END_TEXT = 0x08;
+const EMPTY_WORD_BOUNDARY = 0x10;
+const EMPTY_NO_WORD_BOUNDARY = 0x20;
+function emptyInts() {
+    return [];
+}
+// Returns true iff |c| is an ASCII letter or decimal digit.
+function isalnum(c) {
+    return ((0x30 <= c && c <= 0x39) ||
+        (0x61 <= c && c <= 0x7a) ||
+        (0x41 <= c && c <= 0x5a));
+}
+// If |c| is an ASCII hex digit, returns its value, otherwise -1.
+function unhex(c) {
+    if (0x30 <= c && c <= 0x39) {
+        return c - 0x30;
+    }
+    if (0x61 <= c && c <= 0x66) {
+        return c - 0x61 + 10;
+    }
+    if (0x41 <= c && c <= 0x46) {
+        return c - 0x41 + 10;
+    }
+    return -1;
+}
+// Returns the array of runes in the specified UTF-16 string.
+function stringToRunes(str) {
+    return Array.from(String(str)).map((s) => codePointAtOrThrow(s, 0));
+}
+// Returns the Java UTF-16 string containing the single rune |r|.
+function runeToString(r) {
+    return String.fromCodePoint(r);
+}
+// isWordRune reports whether r is consider a ``word character''
+// during the evaluation of the \b and \B zero-width assertions.
+// These assertions are ASCII-only: the word characters are [A-Za-z0-9_].
+function isWordRune(r) {
+    return ((0x61 <= r && r <= 0x7a) ||
+        (0x41 <= r && r <= 0x5a) ||
+        (0x30 <= r && r <= 0x39) ||
+        r === 0x5f);
+}
+// emptyOpContext returns the zero-width assertions satisfied at the position
+// between the runes r1 and r2, a bitmask of EMPTY_* flags.
+// Passing r1 == -1 indicates that the position is at the beginning of the
+// text.
+// Passing r2 == -1 indicates that the position is at the end of the text.
+// eslint-disable-next-line no-warning-comments
+// TODO(adonovan): move to Machine.
+function emptyOpContext(r1, r2) {
+    let op = 0;
+    if (r1 < 0) {
+        op |= EMPTY_BEGIN_TEXT | EMPTY_BEGIN_LINE;
+    }
+    if (r1 === 0x0a) {
+        op |= EMPTY_BEGIN_LINE;
+    }
+    if (r2 < 0) {
+        op |= EMPTY_END_TEXT | EMPTY_END_LINE;
+    }
+    if (r2 === 0x0a) {
+        op |= EMPTY_END_LINE;
+    }
+    if (isWordRune(r1) !== isWordRune(r2)) {
+        op |= EMPTY_WORD_BOUNDARY;
+    }
+    else {
+        op |= EMPTY_NO_WORD_BOUNDARY;
+    }
+    return op;
+}
+/**
+ * Returns a string that quotes all regular expression metacharacters inside the argument text;
+ * the returned string is a regular expression matching the literal text. For example,
+ * {@code quoteMeta("[foo]").equals("\\[foo\\]")}.
+ * @param {string} str
+ * @returns {string}
+ */
+function quoteMeta(str) {
+    return str
+        .split("") // A char loop is correct because all metacharacters fit in one UTF-16 code.
+        .map((s) => {
+        if (METACHARACTERS.indexOf(s) >= 0) {
+            return `\\${s}`;
+        }
+        return s;
+    })
+        .join("");
+}
+function charCount(codePoint) {
+    return codePoint > MAX_BMP ? 2 : 1;
+}
+export { emptyInts, runeToString, emptyOpContext, charCount, stringToRunes, isalnum, unhex, quoteMeta, EMPTY_BEGIN_LINE, EMPTY_END_LINE, EMPTY_WORD_BOUNDARY, EMPTY_BEGIN_TEXT, EMPTY_END_TEXT, EMPTY_NO_WORD_BOUNDARY, };

package/dist/esm/__fixtures__/find.d.ts

@@ -0,0 +1,9 @@
+declare class Test {
+    pat: string;
+    text: string;
+    matches: number[][];
+    constructor(pat: string, text: string, n: number, ...x: number[]);
+    toString(): string;
+}
+export declare const FIND_TESTS: Test[];
+export {};