@bufbuild/re2 0.0.1-alpha.1

package/dist/esm/__fixtures__/find.js

@@ -0,0 +1,112 @@
+class Test {
+    pat;
+    text;
+    matches;
+    constructor(pat, text, n, ...x) {
+        this.pat = pat;
+        this.text = text;
+        this.matches = [];
+        if (n > 0) {
+            const runLength = Math.floor(x.length / n);
+            for (let i = 0, j = 0; i < n; i++) {
+                this.matches[i] = x.slice(j, j + runLength);
+                j += runLength;
+                if (j > x.length) {
+                    throw new Error("invalid build entry");
+                }
+            }
+        }
+    }
+    toString() {
+        return `pat=${this.pat} text=${this.text} len=${this.matches.length} matches=${JSON.stringify(this.matches)}`;
+    }
+}
+export const FIND_TESTS = [
+    new Test("", "", 1, 0, 0),
+    new Test("^abcdefg", "abcdefg", 1, 0, 7),
+    new Test("a+", "baaab", 1, 1, 4),
+    new Test("abcd..", "abcdef", 1, 0, 6),
+    new Test("a", "a", 1, 0, 1),
+    new Test("x", "y", 0),
+    new Test("b", "abc", 1, 1, 2),
+    new Test(".", "a", 1, 0, 1),
+    new Test(".*", "abcdef", 1, 0, 6),
+    new Test("^", "abcde", 1, 0, 0),
+    new Test("$", "abcde", 1, 5, 5),
+    new Test("^abcd$", "abcd", 1, 0, 4),
+    new Test("^bcd'", "abcdef", 0),
+    new Test("^abcd$", "abcde", 0),
+    new Test("h.*od?", "hello\ngoodbye\n", 1, 0, 5),
+    new Test("a{1,5}", "baaac", 1, 1, 4),
+    new Test("ac{1,25}", "bbaaaccccdd", 1, 4, 9),
+    new Test("a+", "baaab", 1, 1, 4),
+    new Test("a*", "baaab", 3, 0, 0, 1, 4, 5, 5),
+    new Test("[a-z]+", "abcd", 1, 0, 4),
+    new Test("[^a-z]+", "ab1234cd", 1, 2, 6),
+    new Test("[a\\-\\]z]+", "az]-bcz", 2, 0, 4, 6, 7),
+    new Test("[^\\n]+", "abcd\n", 1, 0, 4),
+    new Test("[日本語]+", "日本語日本語", 1, 0, 18),
+    new Test("日本語+", "日本語", 1, 0, 9),
+    new Test("日本語+", "日本語語語語", 1, 0, 18),
+    new Test("()", "", 1, 0, 0, 0, 0),
+    new Test("(a)", "a", 1, 0, 1, 0, 1),
+    new Test("(.)(.)", "日a", 1, 0, 4, 0, 3, 3, 4),
+    new Test("(.*)", "", 1, 0, 0, 0, 0),
+    new Test("(.*)", "abcd", 1, 0, 4, 0, 4),
+    new Test("(..)(..)", "abcd", 1, 0, 4, 0, 2, 2, 4),
+    new Test("(([^xyz]*)(d))", "abcd", 1, 0, 4, 0, 4, 0, 3, 3, 4),
+    new Test("((a|b|c)*(d))", "abcd", 1, 0, 4, 0, 4, 2, 3, 3, 4),
+    new Test("(((a|b|c)*)(d))", "abcd", 1, 0, 4, 0, 4, 0, 3, 2, 3, 3, 4),
+    new Test("\\a\\f\\n\\r\\t\\v", "\x07\f\n\r\t\v", 1, 0, 6),
+    new Test("[\\a\\f\\n\\r\\t\\v]+", "\x07\f\n\r\t\v", 1, 0, 6),
+    new Test("a*(|(b))c*", "aacc", 1, 0, 4, 2, 2, -1, -1),
+    new Test("(.*).*", "ab", 1, 0, 2, 0, 2),
+    new Test("[.]", ".", 1, 0, 1),
+    new Test("/$", "/abc/", 1, 4, 5),
+    new Test("/$", "/abc", 0),
+    // multiple matches
+    new Test(".", "abc", 3, 0, 1, 1, 2, 2, 3),
+    new Test("(.)", "abc", 3, 0, 1, 0, 1, 1, 2, 1, 2, 2, 3, 2, 3),
+    new Test(".(.)", "abcd", 2, 0, 2, 1, 2, 2, 4, 3, 4),
+    new Test("ab*", "abbaab", 3, 0, 3, 3, 4, 4, 6),
+    new Test("a(b*)", "abbaab", 3, 0, 3, 1, 3, 3, 4, 4, 4, 4, 6, 5, 6),
+    // fixed bugs
+    new Test("ab$", "cab", 1, 1, 3),
+    new Test("axxb$", "axxcb", 0),
+    new Test("data", "daXY data", 1, 5, 9),
+    new Test("da(.)a$", "daXY data", 1, 5, 9, 7, 8),
+    new Test("zx+", "zzx", 1, 1, 3),
+    new Test("ab$", "abcab", 1, 3, 5),
+    new Test("(aa)*$", "a", 1, 1, 1, -1, -1),
+    new Test("(?:.|(?:.a))", "", 0),
+    new Test("(?:A(?:A|a))", "Aa", 1, 0, 2),
+    new Test("(?:A|(?:A|a))", "a", 1, 0, 1),
+    new Test("(a){0}", "", 1, 0, 0, -1, -1),
+    new Test("(?-s)(?:(?:^).)", "\n", 0),
+    new Test("(?s)(?:(?:^).)", "\n", 1, 0, 1),
+    new Test("(?:(?:^).)", "\n", 0),
+    new Test("\\b", "x", 2, 0, 0, 1, 1),
+    new Test("\\b", "xx", 2, 0, 0, 2, 2),
+    new Test("\\b", "x y", 4, 0, 0, 1, 1, 2, 2, 3, 3),
+    new Test("\\b", "xx yy", 4, 0, 0, 2, 2, 3, 3, 5, 5),
+    new Test("\\B", "x", 0),
+    new Test("\\B", "xx", 1, 1, 1),
+    new Test("\\B", "x y", 0),
+    new Test("\\B", "xx yy", 2, 1, 1, 4, 4),
+    // RE2 tests
+    new Test("[^\\S\\s]", "abcd", 0),
+    new Test("[^\\S[:space:]]", "abcd", 0),
+    new Test("[^\\D\\d]", "abcd", 0),
+    new Test("[^\\D[:digit:]]", "abcd", 0),
+    new Test("(?i)\\W", "x", 0),
+    new Test("(?i)\\W", "k", 0),
+    new Test("(?i)\\W", "s", 0),
+    // can backslash-escape any punctuation
+    new Test("\\!\\\"\\#\\$\\%\\&\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\{\\|\\}\\~", "!\"#$%&'()*+,-./:;<=>?@[\\]^_{|}~", 1, 0, 31),
+    new Test("[\\!\\\"\\#\\$\\%\\&\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\{\\|\\}\\~]+", "!\"#$%&'()*+,-./:;<=>?@[\\]^_{|}~", 1, 0, 31),
+    new Test("\\`", "`", 1, 0, 1),
+    new Test("[\\`]+", "`", 1, 0, 1),
+    // long set of matches
+    new Test(".", "qwertyuiopasdfghjklzxcvbnm1234567890", 36, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36),
+    new Test("(|a)*", "aa", 3, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2),
+];

package/dist/esm/chars.d.ts

@@ -0,0 +1,2 @@
+export declare const codePoint: (v: string) => number;
+export declare const codePointAtOrThrow: (s: string, i: number) => number;

package/dist/esm/chars.js

@@ -0,0 +1,14 @@
+export const codePoint = (v) => {
+    const cp = v.codePointAt(0);
+    if (cp === undefined) {
+        throw new Error("codePoint: empty string");
+    }
+    return cp;
+};
+export const codePointAtOrThrow = (s, i) => {
+    const cp = s.codePointAt(i);
+    if (cp === undefined) {
+        throw new Error(`codePointAt(${i}) returned undefined for ${JSON.stringify(s)}`);
+    }
+    return cp;
+};

package/dist/esm/exceptions.d.ts

@@ -0,0 +1,55 @@
+declare class RE2JSException extends Error {
+    /** @param {string} message */
+    constructor(message: string);
+}
+/**
+ * An exception thrown by the parser if the pattern was invalid.
+ */
+declare class RE2JSSyntaxException extends RE2JSException {
+    error: string;
+    input: string | null;
+    /**
+     * @param {string} error
+     * @param {string|null} [input=null]
+     */
+    constructor(error: string, input?: string | null);
+    /**
+     * Retrieves the description of the error.
+     * @returns {string}
+     */
+    getDescription(): string;
+    /**
+     * Retrieves the erroneous regular-expression pattern.
+     * @returns {string|null}
+     */
+    getPattern(): string | null;
+}
+/**
+ * An exception thrown by the compiler
+ */
+declare class RE2JSCompileException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message: string);
+}
+/**
+ * An exception thrown by using groups
+ */
+declare class RE2JSGroupException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message: string);
+}
+/**
+ * An exception thrown by flags
+ */
+declare class RE2JSFlagsException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message: string);
+}
+/**
+ * An exception thrown for internal engine errors, such as corrupted bytecodes.
+ */
+declare class RE2JSInternalException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message: string);
+}
+export { RE2JSException, RE2JSSyntaxException, RE2JSCompileException, RE2JSGroupException, RE2JSFlagsException, RE2JSInternalException, };

package/dist/esm/exceptions.js

@@ -0,0 +1,86 @@
+class RE2JSException extends Error {
+    /** @param {string} message */
+    constructor(message) {
+        super(message);
+        this.name = "RE2JSException";
+    }
+}
+/**
+ * An exception thrown by the parser if the pattern was invalid.
+ */
+class RE2JSSyntaxException extends RE2JSException {
+    error;
+    input;
+    /**
+     * @param {string} error
+     * @param {string|null} [input=null]
+     */
+    constructor(error, input = null) {
+        let message = `error parsing regexp: ${error}`;
+        if (input) {
+            message += `: \`${input}\``;
+        }
+        super(message);
+        this.name = "RE2JSSyntaxException";
+        this.message = message;
+        /** @type {string} */
+        this.error = error;
+        /** @type {string|null} */
+        this.input = input;
+    }
+    /**
+     * Retrieves the description of the error.
+     * @returns {string}
+     */
+    getDescription() {
+        return this.error;
+    }
+    /**
+     * Retrieves the erroneous regular-expression pattern.
+     * @returns {string|null}
+     */
+    getPattern() {
+        return this.input;
+    }
+}
+/**
+ * An exception thrown by the compiler
+ */
+class RE2JSCompileException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message) {
+        super(message);
+        this.name = "RE2JSCompileException";
+    }
+}
+/**
+ * An exception thrown by using groups
+ */
+class RE2JSGroupException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message) {
+        super(message);
+        this.name = "RE2JSGroupException";
+    }
+}
+/**
+ * An exception thrown by flags
+ */
+class RE2JSFlagsException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message) {
+        super(message);
+        this.name = "RE2JSFlagsException";
+    }
+}
+/**
+ * An exception thrown for internal engine errors, such as corrupted bytecodes.
+ */
+class RE2JSInternalException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message) {
+        super(message);
+        this.name = "RE2JSInternalException";
+    }
+}
+export { RE2JSException, RE2JSSyntaxException, RE2JSCompileException, RE2JSGroupException, RE2JSFlagsException, RE2JSInternalException, };

package/dist/esm/index.d.ts

@@ -0,0 +1,102 @@
+import { RE2 } from "./RE2.js";
+export { RE2JSCompileException, RE2JSException, RE2JSFlagsException, RE2JSGroupException, RE2JSInternalException, RE2JSSyntaxException, } from "./exceptions.js";
+/**
+ * A compiled representation of an RE2 regular expression
+ */
+export declare class RE2JS {
+    patternInput: string;
+    flagsInput: number;
+    re2Input: RE2;
+    /**
+     * Flag: case insensitive matching.
+     */
+    static CASE_INSENSITIVE: number;
+    /**
+     * Flag: dot ({@code .}) matches all characters, including newline.
+     */
+    static DOTALL: number;
+    /**
+     * Flag: multiline matching: {@code ^} and {@code $} match at beginning and end of line, not just
+     * beginning and end of input.
+     */
+    static MULTILINE: number;
+    /**
+     * Flag: Unicode groups (e.g. {@code \p{Greek}} ) will be syntax errors.
+     */
+    static DISABLE_UNICODE_GROUPS: number;
+    /**
+     * Returns a literal pattern string for the specified string.
+     *
+     * @param {string} str The string to be literalized
+     * @returns {string} A literal string replacement
+     */
+    static quote(str: string): string;
+    /**
+     * Helper: create new RE2JS with given regex and flags.
+     * @param {string} regex
+     * @param {number} [flags=0]
+     * @returns {RE2JS}
+     */
+    static compile(regex: string, flags?: number): RE2JS;
+    static validateFlags(flags: number): void;
+    static buildRegexWithFlags(regex: string, flags?: number): string;
+    /**
+     * Matches a string against a regular expression.
+     *
+     * @param {string} regex the regular expression
+     * @param {string} input the input
+     * @returns {boolean} true if the regular expression matches the entire input
+     * @throws RE2JSSyntaxException if the regular expression is malformed
+     */
+    static matches(regex: string, input: string): boolean;
+    /**
+     * @param {string} pattern
+     * @param {number} flags
+     */
+    constructor(pattern: string, flags?: number);
+    /**
+     * Releases memory used by internal caches associated with this pattern.
+     */
+    reset(): void;
+    /**
+     * Returns the flags used in the constructor.
+     * @returns {number}
+     */
+    flags(): number;
+    /**
+     * Returns the pattern used in the constructor.
+     * @returns {string}
+     */
+    pattern(): string;
+    re2(): RE2;
+    /**
+     * Matches a string against a regular expression.
+     *
+     * @param {string} input the input
+     * @returns {boolean} true if the regular expression matches the entire input
+     */
+    matches(input: string): boolean;
+    /**
+     * Tests whether the regular expression matches any part of the input string.
+     *
+     * @param {string} input - The input string to test against.
+     * @returns {boolean} `true` if the pattern is found anywhere in the input, `false` otherwise.
+     */
+    test(input: string): boolean;
+    /**
+     * Tests whether the regular expression matches the ENTIRE input string.
+     *
+     * @param {string} input - The input string to test against.
+     * @returns {boolean} `true` if the exact input string fully matches the pattern, `false` otherwise.
+     */
+    testExact(input: string): boolean;
+    toString(): string;
+    /**
+     * Returns the number of capturing groups in this matcher's pattern.
+     */
+    groupCount(): number;
+    /**
+     * Return a map of the capturing groups in this matcher's pattern.
+     */
+    namedGroups(): Map<string, number>;
+}

package/dist/esm/index.js

@@ -0,0 +1,163 @@
+import { ANCHOR_BOTH, PERL, UNICODE_GROUPS } from "./RE2Flags.js";
+import { fromUTF16 } from "./MachineInput.js";
+import { RE2 } from "./RE2.js";
+import { quoteMeta } from "./Utils.js";
+import { RE2JSFlagsException } from "./exceptions.js";
+export { RE2JSCompileException, RE2JSException, RE2JSFlagsException, RE2JSGroupException, RE2JSInternalException, RE2JSSyntaxException, } from "./exceptions.js";
+/**
+ * A compiled representation of an RE2 regular expression
+ */
+export class RE2JS {
+    patternInput;
+    flagsInput;
+    re2Input;
+    /**
+     * Flag: case insensitive matching.
+     */
+    static CASE_INSENSITIVE = 1;
+    /**
+     * Flag: dot ({@code .}) matches all characters, including newline.
+     */
+    static DOTALL = 2;
+    /**
+     * Flag: multiline matching: {@code ^} and {@code $} match at beginning and end of line, not just
+     * beginning and end of input.
+     */
+    static MULTILINE = 4;
+    /**
+     * Flag: Unicode groups (e.g. {@code \p{Greek}} ) will be syntax errors.
+     */
+    static DISABLE_UNICODE_GROUPS = 8;
+    /**
+     * Returns a literal pattern string for the specified string.
+     *
+     * @param {string} str The string to be literalized
+     * @returns {string} A literal string replacement
+     */
+    static quote(str) {
+        return quoteMeta(str);
+    }
+    /**
+     * Helper: create new RE2JS with given regex and flags.
+     * @param {string} regex
+     * @param {number} [flags=0]
+     * @returns {RE2JS}
+     */
+    static compile(regex, flags = 0) {
+        return new RE2JS(regex, flags);
+    }
+    static validateFlags(flags) {
+        if ((flags &
+            ~(RE2JS.MULTILINE |
+                RE2JS.DOTALL |
+                RE2JS.CASE_INSENSITIVE |
+                RE2JS.DISABLE_UNICODE_GROUPS)) !==
+            0) {
+            throw new RE2JSFlagsException("Flags should only be a combination of MULTILINE, DOTALL, CASE_INSENSITIVE, DISABLE_UNICODE_GROUPS");
+        }
+    }
+    static buildRegexWithFlags(regex, flags = 0) {
+        let fregex = regex;
+        if ((flags & RE2JS.CASE_INSENSITIVE) !== 0) {
+            fregex = `(?i)${fregex}`;
+        }
+        if ((flags & RE2JS.DOTALL) !== 0) {
+            fregex = `(?s)${fregex}`;
+        }
+        if ((flags & RE2JS.MULTILINE) !== 0) {
+            fregex = `(?m)${fregex}`;
+        }
+        return fregex;
+    }
+    /**
+     * Matches a string against a regular expression.
+     *
+     * @param {string} regex the regular expression
+     * @param {string} input the input
+     * @returns {boolean} true if the regular expression matches the entire input
+     * @throws RE2JSSyntaxException if the regular expression is malformed
+     */
+    static matches(regex, input) {
+        return RE2JS.compile(regex).testExact(input);
+    }
+    /**
+     * @param {string} pattern
+     * @param {number} flags
+     */
+    constructor(pattern, flags = 0) {
+        let re2Flags = PERL;
+        if ((flags & RE2JS.DISABLE_UNICODE_GROUPS) !== 0) {
+            re2Flags &= ~UNICODE_GROUPS;
+        }
+        RE2JS.validateFlags(flags);
+        const fregex = RE2JS.buildRegexWithFlags(pattern, flags);
+        this.patternInput = pattern;
+        this.flagsInput = flags;
+        this.re2Input = RE2.compileImpl(fregex, re2Flags);
+    }
+    /**
+     * Releases memory used by internal caches associated with this pattern.
+     */
+    reset() {
+        this.re2Input.reset();
+    }
+    /**
+     * Returns the flags used in the constructor.
+     * @returns {number}
+     */
+    flags() {
+        return this.flagsInput;
+    }
+    /**
+     * Returns the pattern used in the constructor.
+     * @returns {string}
+     */
+    pattern() {
+        return this.patternInput;
+    }
+    re2() {
+        return this.re2Input;
+    }
+    /**
+     * Matches a string against a regular expression.
+     *
+     * @param {string} input the input
+     * @returns {boolean} true if the regular expression matches the entire input
+     */
+    matches(input) {
+        return this.testExact(input);
+    }
+    /**
+     * Tests whether the regular expression matches any part of the input string.
+     *
+     * @param {string} input - The input string to test against.
+     * @returns {boolean} `true` if the pattern is found anywhere in the input, `false` otherwise.
+     */
+    test(input) {
+        return this.re2Input.match(input);
+    }
+    /**
+     * Tests whether the regular expression matches the ENTIRE input string.
+     *
+     * @param {string} input - The input string to test against.
+     * @returns {boolean} `true` if the exact input string fully matches the pattern, `false` otherwise.
+     */
+    testExact(input) {
+        return (this.re2Input.executeEngine(fromUTF16(input), 0, ANCHOR_BOTH, 0) !== null);
+    }
+    toString() {
+        return this.patternInput;
+    }
+    /**
+     * Returns the number of capturing groups in this matcher's pattern.
+     */
+    groupCount() {
+        return this.re2Input.numberOfCapturingGroups();
+    }
+    /**
+     * Return a map of the capturing groups in this matcher's pattern.
+     */
+    namedGroups() {
+        return this.re2Input.namedGroups;
+    }
+}

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

@@ -0,0 +1,138 @@
+import { FOLD_CASE, NON_GREEDY, WAS_DOLLAR } from "./RE2Flags.js";
+import { Regexp } from "./Regexp.js";
+import { MAX_RUNE, simpleFold } from "./Unicode.js";
+const OP_NAMES = new Map([
+    [Regexp.Op.NO_MATCH, "no"],
+    [Regexp.Op.EMPTY_MATCH, "emp"],
+    [Regexp.Op.LITERAL, "lit"],
+    [Regexp.Op.CHAR_CLASS, "cc"],
+    [Regexp.Op.ANY_CHAR_NOT_NL, "dnl"],
+    [Regexp.Op.ANY_CHAR, "dot"],
+    [Regexp.Op.BEGIN_LINE, "bol"],
+    [Regexp.Op.END_LINE, "eol"],
+    [Regexp.Op.BEGIN_TEXT, "bot"],
+    [Regexp.Op.END_TEXT, "eot"],
+    [Regexp.Op.WORD_BOUNDARY, "wb"],
+    [Regexp.Op.NO_WORD_BOUNDARY, "nwb"],
+    [Regexp.Op.CAPTURE, "cap"],
+    [Regexp.Op.STAR, "star"],
+    [Regexp.Op.PLUS, "plus"],
+    [Regexp.Op.QUEST, "que"],
+    [Regexp.Op.REPEAT, "rep"],
+    [Regexp.Op.CONCAT, "cat"],
+    [Regexp.Op.ALTERNATE, "alt"],
+]);
+export 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.Op.STAR:
+            case Regexp.Op.PLUS:
+            case Regexp.Op.QUEST:
+            case Regexp.Op.REPEAT:
+                if ((re.flags & NON_GREEDY) !== 0) {
+                    b += "n";
+                }
+                b += name;
+                break;
+            case Regexp.Op.LITERAL:
+                if (re.runes.length > 1) {
+                    b += "str";
+                }
+                else {
+                    b += "lit";
+                }
+                if ((re.flags & FOLD_CASE) !== 0) {
+                    for (let r of re.runes) {
+                        if (simpleFold(r) !== r) {
+                            b += "fold";
+                            break;
+                        }
+                    }
+                }
+                break;
+            default:
+                b += name;
+                break;
+        }
+    }
+    b += "{";
+    switch (re.op) {
+        case Regexp.Op.END_TEXT:
+            if ((re.flags & WAS_DOLLAR) === 0) {
+                b += "\\z";
+            }
+            break;
+        case Regexp.Op.LITERAL:
+            for (let r of re.runes) {
+                b += String.fromCodePoint(r);
+            }
+            break;
+        case Regexp.Op.CONCAT:
+        case Regexp.Op.ALTERNATE:
+            for (let sub of re.subs) {
+                b += dumpRegexp(sub);
+            }
+            break;
+        case Regexp.Op.STAR:
+        case Regexp.Op.PLUS:
+        case Regexp.Op.QUEST:
+            b += dumpRegexp(re.subs[0]);
+            break;
+        case Regexp.Op.REPEAT:
+            b += `${re.min},${re.max}`;
+            b += " ";
+            b += dumpRegexp(re.subs[0]);
+            break;
+        case Regexp.Op.CAPTURE:
+            if (re.name !== null && re.name.length > 0) {
+                b += re.name;
+                b += ":";
+            }
+            b += dumpRegexp(re.subs[0]);
+            break;
+        case 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;
+};
+export const mkCharClass = (f) => {
+    const re = new Regexp(Regexp.Op.CHAR_CLASS);
+    let runes = [];
+    let lo = -1;
+    for (let i = 0; i <= 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, MAX_RUNE];
+    }
+    re.runes = runes;
+    return dumpRegexp(re);
+};