@isopodlabs/utilities 1.5.5 → 1.5.6

package/dist/regex.js

@@ -0,0 +1,1044 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endAnchor = exports.startAnchor = exports.nonWordBoundary = exports.wordBoundary = exports.octal = exports.hex = exports.whitespace = exports.word = exports.alnum = exports.alpha = exports.upper = exports.lower = exports.digit = exports.any = exports.characterClass = void 0;
+exports.range = range;
+exports.chars = chars;
+exports.union = union;
+exports.text = text;
+exports.concatenation = concatenation;
+exports.alternation = alternation;
+exports.noncapture = noncapture;
+exports.lookAhead = lookAhead;
+exports.negLookAhead = negLookAhead;
+exports.lookBehind = lookBehind;
+exports.negLookBehind = negLookBehind;
+exports.capture = capture;
+exports.repeatFrom = repeatFrom;
+exports.repeat = repeat;
+exports.zeroOrMore = zeroOrMore;
+exports.oneOrMore = oneOrMore;
+exports.optional = optional;
+exports.boundary = boundary;
+exports.reference = reference;
+exports.anchored = anchored;
+exports.parse = parse;
+exports.toRegExpString = toRegExpString;
+exports.toRegExp = toRegExp;
+exports.optimize = optimize;
+exports.runDFA = runDFA;
+exports.regexToDFA = regexToDFA;
+exports.parseGlob = parseGlob;
+exports.anchoredRe = anchoredRe;
+exports.globToRe = globToRe;
+exports.globToReMulti = globToReMulti;
+const bits_1 = require("./bits");
+/*
+Characters
+[xyz],[a-c]		Character class
+[^xyz],[^a-c]	Negated character class
+.			Wildcard: Matches any single character except line terminators: \n, \r, \u2028 or \u2029
+\d			Digit character class escape: Matches any digit (Arabic numeral). Equivalent to [0-9]
+\D			Non-digit character class escape: Matches any character that is not a digit (Arabic numeral)
+\w			Word character class escape: Matches any alphanumeric character from the basic Latin alphabet, including the underscore. Equivalent to [A-Za-z0-9_]
+\W			Non-word character class escape: Matches any character that is not a word character from the basic Latin alphabet. Equivalent to [^A-Za-z0-9_]
+\s			White space character class escape: Matches a single white space character, including space, tab, form feed, line feed, and other Unicode spaces. Equivalent to [\f\n\r\t\v\u0020\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]
+\S			Non-white space character class escape
+\t			Matches a horizontal tab.
+\r			Matches a carriage return.
+\n			Matches a linefeed.
+\v			Matches a vertical tab.
+\f			Matches a form-feed.
+[\b]		Matches a backspace.
+\0			Matches a NUL character.
+\cX			Matches a control character using caret notation, where "X" is a letter from A–Z
+\xhh		Matches the character with the code hh (two hexadecimal digits).
+\uhhhh		Matches a UTF-16 code-unit with the value hhhh (four hexadecimal digits).
+\u{hhhh} or \u{hhhhh}	(Only when the u flag is set.) Matches the character with the Unicode value U+hhhh or U+hhhhh (hexadecimal digits).
+\p{UnicodeProperty}, \P{UnicodeProperty}	Unicode character class escape: Matches a character based on its Unicode character properties
+\			Indicates that the following character should be treated specially, or "escaped"
+
+x|y			Alternation: Matches either "x" or "y"
+
+Boundary-type assertions
+^			Input boundary beginning assertion
+$			Input boundary end assertion
+\b			Word boundary assertion
+\B			Non-word-boundary assertion
+
+Other Assertions
+x(?=y)		Lookahead assertion
+x(?!y)		Negative lookahead assertion
+(?<=y)x		Lookbehind assertion
+(?<!y)x		Negative lookbehind assertion
+
+Groups and backreferences
+(x)			Capturing group
+(?<Name>x)	Named capturing group
+(?:x)		Non-capturing group
+(?flags:x), (?:flags-flags:x)	Modifier (flags can be i, m, s)
+\<int>		Backreference
+\k<Name>	Named backreference
+
+Quantifiers
+x*			Matches the preceding item "x" 0 or more times
+x+			Matches the preceding item "x" 1 or more times. Equivalent to {1,}
+x?			Matches the preceding item "x" 0 or 1 times. For example, /e?le?/ matches the "el" in "angel" and the "le" in "angle."
+x{<int>}	Matches exactly "n" occurrences of the preceding item "x"
+x{<int>,}	Matches at least "n" occurrences of the preceding item "x"
+x{n,m}		Matches at least "n" and at most "m" occurrences of the preceding item "x"
+
+Non greedy quantifiers
+x*?
+x+?
+x??
+x{n}?
+x{n,}?
+x{n,m}?
+
+*/
+const posixClasses = {
+    alnum: '\\p{L}\\p{Nl}\\p{Nd}',
+    alpha: '\\p{L}\\p{Nl}',
+    ascii: '\\x00-\\x7f',
+    blank: '\\p{Zs}\\t',
+    cntrl: '\\p{Cc}',
+    digit: '\\p{Nd}',
+    graph: '^\\p{Z}\\p{C}',
+    lower: '\\p{Ll}',
+    print: '\\p{C}',
+    punct: '\\p{P}',
+    space: '\\p{Z}\\t\\r\\n\\v\\f',
+    upper: '\\p{Lu}',
+    word: '\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}',
+    xdigit: 'A-Fa-f0-9',
+};
+class characterClass extends bits_1.SparseBits {
+    type = 'class';
+    //setChar(char: string) {
+    //	this.set(char.charCodeAt(0));
+    //}
+    test(char) {
+        return this.has(char.charCodeAt(0));
+    }
+    mutable() {
+        return new MutablecharacterClass(true).selfIntersect(this);
+    }
+    isNegated() {
+        return !!this.undef;
+    }
+    toString() {
+        let s = this.undef ? '^' : '';
+        for (const i in this.bits) {
+            const b = this.bits[i] ^ this.undef;
+            const c0 = +i * 32;
+            for (let j = 0; j < 32; j++) {
+                if (b & (1 << j)) {
+                    const c1 = c0 + j;
+                    while (j < 32 && (b & (1 << j)))
+                        j++;
+                    const c2 = c0 + j - 1;
+                    s += String.fromCharCode(c1).replace(/[-\\\]]/g, '\\$&');
+                    if (c1 !== c2)
+                        s += '-' + String.fromCharCode(c2).replace(/[-\\\]]/g, '\\$&');
+                }
+            }
+        }
+        return s;
+    }
+}
+exports.characterClass = characterClass;
+;
+class MutablecharacterClass extends characterClass {
+    setChar(char) {
+        this.set(char.charCodeAt(0));
+    }
+    setString(c) {
+        for (let i = 0; i < c.length; i++)
+            this.set(c.charCodeAt(i));
+        return this;
+    }
+    clearString(c) {
+        for (let i = 0; i < c.length; i++)
+            this.clear(c.charCodeAt(i));
+        return this;
+    }
+}
+// characterClass helpers
+function range(from, to) {
+    return new MutablecharacterClass(false).setRange(from.charCodeAt(0), to.charCodeAt(0) + 1);
+}
+function chars(chars) {
+    return new MutablecharacterClass(false).setString(chars);
+}
+function union(...classes) {
+    const result = new MutablecharacterClass(false);
+    for (const cls of classes)
+        result.selfUnion(cls);
+    return result;
+}
+// Common character class constants and ranges
+exports.any = new characterClass(true); //.clearString('\n\r\u2028\u2029');
+exports.digit = range('0', '9'); //digit
+exports.lower = range('a', 'z');
+exports.upper = range('A', 'Z');
+exports.alpha = exports.lower.union(exports.upper);
+exports.alnum = exports.alpha.union(exports.digit);
+exports.word = exports.alnum.union(chars('_')); //word
+exports.whitespace = chars(' \t\r\n\f\v'); //whitespace
+exports.hex = exports.digit.union(chars('abcdefABCDEF'));
+exports.octal = range('0', '7');
+function text(c) {
+    return c;
+}
+function concatenation(parts) {
+    return parts.length === 1 ? parts[0] : parts;
+}
+function alternation(parts) {
+    return parts.length === 1 ? parts[0]
+        : parts.length === 2 && !parts[1] ? optional(parts[0])
+            : { type: 'alt', parts };
+}
+;
+function noncapture(part, options) {
+    return { type: 'noncapture', part, options };
+}
+function lookAhead(part) { return noncapture(part, 'ahead'); }
+function negLookAhead(part) { return noncapture(part, 'neg_ahead'); }
+function lookBehind(part) { return noncapture(part, 'behind'); }
+function negLookBehind(part) { return noncapture(part, 'neg_behind'); }
+function capture(part, name) {
+    return { type: 'capture', part, name };
+}
+function repeatFrom(part, min, max = -1, mod = 'greedy') {
+    return { type: 'quantified', part, min, max, mod };
+}
+function repeat(part, n, mod = 'greedy') {
+    return { type: 'quantified', part, min: n, max: n, mod };
+}
+function zeroOrMore(part, mod = 'greedy') { return repeatFrom(part, 0, -1, mod); }
+function oneOrMore(part, mod = 'greedy') { return repeatFrom(part, 1, -1, mod); }
+function optional(part, mod = 'greedy') { return repeatFrom(part, 0, 1, mod); }
+function boundary(type) {
+    return { type };
+}
+exports.wordBoundary = boundary('wordbound');
+exports.nonWordBoundary = boundary('nowordbound');
+exports.startAnchor = boundary('inputboundstart');
+exports.endAnchor = boundary('inputboundend');
+function reference(value) {
+    return { type: 'reference', value };
+}
+function anchored(part) {
+    return [exports.startAnchor, part, exports.endAnchor];
+}
+/*
+function is0<T extends part0['type']>(part: part, type: T): part is Extract<part0, { type: T }> {
+    return typeof part !== 'string' && !Array.isArray(part) && part.type === type;
+}
+*/
+function type(part) {
+    return typeof part === 'string' ? 'text'
+        : Array.isArray(part) ? 'concat'
+            : part.type;
+}
+function is(part, istype) {
+    return type(part) === istype;
+    //return typeof part === 'string'	? type === 'text'
+    //		: Array.isArray(part)	? type === 'concat'
+    //		: part.type === type;
+}
+function typed(part) {
+    return typeof part === 'string' ? { type: 'text', part }
+        : Array.isArray(part) ? { type: 'concat', part }
+            : part;
+}
+function parse(re, unicode = true, extended = false) {
+    const stack = [];
+    let curr = [];
+    let i = 0;
+    function skipTo(c) {
+        const start = i;
+        while (i < re.length && re[i] !== c)
+            i++;
+        if (re[i] !== c)
+            throw new Error(`Missing '${c}'`);
+        return re.substring(start, i++);
+    }
+    function int() {
+        const start = i;
+        while (re[i] >= '0' && re[i] <= '9')
+            i++;
+        return parseInt(re.substring(start, i));
+    }
+    function backslashed() {
+        const c = re[i++];
+        switch (c) {
+            default: return c.charCodeAt(0);
+            case 'd': return exports.digit; //digit
+            case 'D': return exports.digit.not(); //non-digit
+            case 'w': return exports.word; //word
+            case 'W': return exports.word.not(); //non-word
+            case 's': return exports.whitespace; //whitespace
+            case 'S': return exports.whitespace.not(); //non-whitespace
+            case 'b': return 8; //backspace
+            case 't': return 9; //tab
+            case 'n': return 10; //newline
+            case 'v': return 11; //vertical tab
+            case 'f': return 12; //form feed
+            case 'r': return 13; //carriage return
+            case 'c': return re.charCodeAt(i++) & 31; //control character
+            case '0': {
+                const start = i - 1;
+                while (re[i] >= '0' && re[i] <= '7' && i - start < 4)
+                    i++;
+                return parseInt(re.substring(start, i), 8);
+            }
+            case 'x':
+                if (i + 2 > re.length)
+                    throw new Error('bad \\x escape');
+                i += 2;
+                return parseInt(re.substring(i - 2, i), 16);
+            case 'u':
+                if (unicode && re[i] === '{') {
+                    i++; // skip '{'
+                    return parseInt(skipTo('}'), 16);
+                }
+                if (i + 4 > re.length)
+                    throw new Error('bad \\u escape');
+                i += 4;
+                return parseInt(re.substring(i - 4, i), 16);
+            case 'p':
+            case 'P':
+                if (!unicode || re[i] !== '{')
+                    throw new Error('\\p and \\P can only be used with unicode enabled, and must be followed by {property}');
+                i++; // skip '{'
+                return { type: c === 'P' ? 'notunicode' : 'unicode', property: skipTo('}') };
+        }
+    }
+    function character() {
+        const code = unicode ? re.codePointAt(i++) : re.charCodeAt(i++);
+        if (code > 0xffff) {
+            ++i;
+            return code;
+        }
+        return code === 92 ? backslashed() : code;
+    }
+    function addQuantified(min, max) {
+        let mod = 'greedy';
+        if (re[i] === '?') {
+            mod = 'lazy';
+            i++;
+        }
+        else if (extended && re[i] === '+') {
+            mod = 'possessive';
+            i++;
+        }
+        const top = curr.pop();
+        if (!top)
+            throw new Error('nothing to quantify');
+        if (typeof top === 'string' && top.length > 1) {
+            curr.push(top.slice(0, -1));
+            curr.push(repeatFrom(top.slice(-1), min, max, mod));
+        }
+        else {
+            curr.push(repeatFrom(top, min, max, mod));
+        }
+    }
+    function addText(c) {
+        if (typeof curr.at(-1) === 'string') {
+            curr[curr.length - 1] += c;
+        }
+        else {
+            curr.push(c);
+        }
+    }
+    function closeAlt() {
+        let top = stack.pop();
+        if (top?.type === 'alt') {
+            top.parts.push(concatenation(curr));
+            curr = [top];
+            top = stack.pop();
+        }
+        return top;
+    }
+    const specialChars = /[\\^$*+?{()|[.]/;
+    while (i < re.length) {
+        const remaining = re.substring(i);
+        const next = remaining.search(specialChars);
+        if (next === -1) {
+            addText(remaining);
+            break;
+        }
+        if (next > 0)
+            addText(remaining.substring(0, next));
+        i += next;
+        switch (re[i++]) {
+            case '\\':
+                if (re[i] === 'b') {
+                    i++;
+                    curr.push(exports.wordBoundary);
+                }
+                else if (re[i] === 'B') {
+                    i++;
+                    curr.push(exports.nonWordBoundary);
+                }
+                else if (re[i] >= '1' && re[i] <= '9') {
+                    const n = int();
+                    curr.push({ type: 'reference', value: n });
+                }
+                else if (re[i] === 'k' && re[i + 1] === '<') {
+                    i += 2;
+                    const name = skipTo('>');
+                    curr.push({ type: 'reference', value: name });
+                }
+                else {
+                    const b = backslashed();
+                    if (typeof b === 'number')
+                        addText(String.fromCodePoint(b));
+                    else
+                        curr.push(b);
+                }
+                break;
+            case '.':
+                curr.push(exports.any);
+                break;
+            //Boundary-type assertions
+            case '^':
+                curr.push(exports.startAnchor);
+                break;
+            case '$':
+                curr.push(exports.endAnchor);
+                break;
+            //Quantifiers
+            case '*':
+                addQuantified(0, -1);
+                break;
+            case '+':
+                addQuantified(1, -1);
+                break;
+            case '?':
+                addQuantified(0, 1);
+                break;
+            case '{': {
+                const min = int();
+                let max = min;
+                if (re[i] === ',') {
+                    ++i; // skip ','
+                    max = re[i] !== '}' ? int() : -1;
+                }
+                ++i; // skip '}'
+                addQuantified(min, max);
+                break;
+            }
+            //Alternation
+            case '|': {
+                const top = stack.at(-1);
+                if (top?.type === 'alt') {
+                    top.parts.push(concatenation(curr));
+                }
+                else {
+                    stack.push({ type: 'alt', parts: [concatenation(curr)] });
+                }
+                curr = [];
+                break;
+            }
+            //Groups
+            case '(':
+                let group;
+                const dummy = ''; //text(''); // placeholder
+                if (re[i] === '?') {
+                    i++;
+                    switch (re[i++]) {
+                        case ':':
+                            group = noncapture(dummy);
+                            break;
+                        case '=':
+                            group = noncapture(dummy, 'ahead');
+                            break;
+                        case '!':
+                            group = noncapture(dummy, 'neg_ahead');
+                            break;
+                        case '<':
+                            if (re[i] === '=') {
+                                i++;
+                                group = noncapture(dummy, 'behind');
+                            }
+                            else if (re[i] === '!') {
+                                i++;
+                                group = noncapture(dummy, 'neg_behind');
+                            }
+                            else {
+                                group = capture(dummy, skipTo('>'));
+                            }
+                            break;
+                        case '>':
+                            if (extended) {
+                                group = noncapture(dummy, 'atomic');
+                                break;
+                            }
+                        default: {
+                            let set = true;
+                            const flags = {};
+                            --i; // go back to first flag character
+                            while (i < re.length) {
+                                const f = re[i++];
+                                if (f === ':')
+                                    break;
+                                if (f === '-')
+                                    set = false;
+                                else if (f === 'i' || f === 'm' || f === 's')
+                                    flags[f] = set;
+                            }
+                            group = noncapture(dummy, flags);
+                            break;
+                        }
+                    }
+                }
+                else {
+                    group = capture(dummy, '');
+                }
+                stack.push({ type: 'group', group: group, tos: curr });
+                curr = [];
+                break;
+            case ')': {
+                const top = closeAlt();
+                if (top?.type !== 'group')
+                    throw new Error('unmatched )');
+                top.group.part = concatenation(curr);
+                curr = [...top.tos, top.group];
+                break;
+            }
+            //Character classes
+            case '[': {
+                const neg = re[i] === '^';
+                if (neg)
+                    i++;
+                const cs = new characterClass(false);
+                if (re[i] === ']' || re[i] === '-')
+                    cs.set(re.charCodeAt(i++));
+                while (i < re.length && re[i] !== ']') {
+                    const from = character();
+                    if (typeof from === 'number') {
+                        if (re[i] === '-' && i + 1 < re.length && re[i + 1] !== ']') {
+                            ++i;
+                            const to = character();
+                            if (typeof to !== 'number' || from > to)
+                                throw new Error('bad character class');
+                            cs.setRange(from, to + 1);
+                        }
+                        else {
+                            cs.set(from);
+                        }
+                    }
+                    else if (is(from, 'class')) {
+                        cs.selfUnion(from);
+                    }
+                }
+                i++; // skip ']'
+                curr.push(neg ? cs.selfNot() : cs);
+                break;
+            }
+        }
+    }
+    const top = closeAlt();
+    if (top)
+        throw new Error('unmatched (');
+    return concatenation(curr);
+}
+//-----------------------------------------------------------------------------
+// Regex to string
+//-----------------------------------------------------------------------------
+function printQuantified(min, max, mod) {
+    return (min === 0 && max === -1 ? '*'
+        : min === 1 && max === -1 ? '+'
+            : min === 0 && max === 1 ? '?'
+                : max === -1 ? `{${min},}`
+                    : min === max ? `{${min}}`
+                        : `{${min},${max}}`) + (mod === 'lazy' ? '?' : mod === 'possessive' ? '+' : '');
+}
+function list(parts, join) {
+    return parts.map((p, i) => {
+        if (is(p, 'quantified') && is(p.part, 'text') && i > 0 && is(parts[i - 1], 'text'))
+            return `(?:${p.part})` + printQuantified(p.min, p.max, p.mod);
+        const s = toRegExpString(p);
+        return is(p, 'alt') ? `(?:${s})` : s;
+    }).join(join);
+}
+function toRegExpString(part) {
+    if (typeof part === 'string')
+        return part.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+    if (Array.isArray(part))
+        return list(part, '');
+    switch (part.type) {
+        case 'alt':
+            return list(part.parts, '|');
+        case 'quantified':
+            return toRegExpString(part.part) + printQuantified(part.min, part.max, part.mod);
+        case 'noncapture': {
+            let header = '';
+            const opts = part.options;
+            if (opts) {
+                if (typeof opts === 'string') {
+                    header = {
+                        ahead: '=',
+                        behind: '<=',
+                        neg_ahead: '!',
+                        neg_behind: '<!',
+                        atomic: '>'
+                    }[opts];
+                }
+                else if ((opts.i ?? opts.m ?? opts.s) !== undefined) {
+                    let posflags = (opts.i ? 'i' : '') + (opts.m ? 'm' : '') + (opts.s ? 's' : '');
+                    let negflags = (opts.i === false ? 'i' : '') + (opts.m === false ? 'm' : '') + (opts.s === false ? 's' : '');
+                    header = `${posflags}${negflags ? '-' : ''}${negflags}:`;
+                }
+            }
+            return `(?${header}${toRegExpString(part.part)})`;
+        }
+        case 'capture':
+            return `(${part.name ? `?<${part.name}>` : ''}${toRegExpString(part.part)})`;
+        case 'class': {
+            if (part.contains(exports.any))
+                return '.';
+            const neg = part.isNegated();
+            const temp = neg ? part.not() : part.mutable();
+            const has_w = temp.contains(exports.word);
+            if (has_w) {
+                if (exports.word.contains(temp))
+                    return '\\w';
+                temp.selfIntersect(exports.word.not());
+            }
+            const has_d = !has_w && temp.contains(exports.digit);
+            if (has_d) {
+                if (exports.digit.contains(temp))
+                    return '\\d';
+                temp.selfIntersect(exports.digit.not());
+            }
+            const has_s = temp.contains(exports.whitespace);
+            if (has_s) {
+                if (!has_w && !has_d && exports.whitespace.contains(temp))
+                    return '\\s';
+                temp.selfIntersect(exports.whitespace.not());
+            }
+            return `[${neg ? '^' : ''}${has_w ? '\\w' : has_d ? '\\d' : ''}${has_s ? '\\s' : ''}${temp.toString()}]`;
+            //return `[${part.toString()}]`;
+        }
+        case 'unicode':
+            return `\\p{${part.property}}`;
+        case 'notunicode':
+            return `\\P{${part.property}}`;
+        case 'wordbound':
+            return '\\b';
+        case 'nowordbound':
+            return '\\B';
+        case 'inputboundstart':
+            return '^';
+        case 'inputboundend':
+            return '$';
+        case 'reference':
+            return typeof part.value === 'number' ? `\\${part.value}` : `\\k<${part.value}>`;
+    }
+}
+function toRegExp(part, flags) {
+    return new RegExp(toRegExpString(part), flags);
+}
+//-----------------------------------------------------------------------------
+// Regex AST manipulation
+//-----------------------------------------------------------------------------
+function visit(part, visitor, previsit) {
+    if (previsit)
+        part = previsit(part) ?? part;
+    /*
+    if (typeof part === 'string')
+        return visitor(part) ?? part;
+
+    if (Array.isArray(part)) {
+        part = part.map(p => visit(p, visitor, previsit));
+
+    } else */
+    const t = typed(part);
+    switch (t.type) {
+        case 'concat':
+            part = concatenation(part.map(p => visit(p, visitor, previsit)));
+            break;
+        case 'alt':
+            part = alternation(t.parts.map(p => visit(p, visitor, previsit)));
+            break;
+        case 'quantified':
+            part = repeatFrom(visit(t.part, visitor, previsit), t.min, t.max, t.mod);
+            break;
+        case 'noncapture':
+            part = noncapture(visit(t.part, visitor, previsit), t.options);
+            break;
+        case 'capture':
+            part = capture(visit(t.part, visitor, previsit), t.name);
+            break;
+    }
+    return visitor(part) ?? part;
+}
+function commonPrefix(strings) {
+    if (strings.length < 2)
+        return '';
+    let prefix = strings[0];
+    for (let i = 1; prefix && i < strings.length; i++) {
+        let j = 0;
+        while (j < prefix.length && j < strings[i].length && prefix[j] === strings[i][j])
+            j++;
+        prefix = prefix.slice(0, j);
+    }
+    return prefix;
+}
+function optimize(part) {
+    return visit(part, p => {
+        if (Array.isArray(p)) {
+            const result = [];
+            let current = "";
+            for (const i of p) {
+                if (typeof i === 'string') {
+                    current += i;
+                }
+                else {
+                    if (current) {
+                        result.push(current);
+                        current = "";
+                    }
+                    if (is(i, 'concat'))
+                        result.push(...i);
+                    else
+                        result.push(i);
+                }
+            }
+            if (current)
+                result.push(current);
+            return concatenation(result);
+        }
+        else if (is(p, 'alt')) {
+            const unique = [...new Set(p.parts.map(toRegExpString))];
+            const strings = unique.filter((p) => typeof p === 'string');
+            const prefix = commonPrefix(strings);
+            if (prefix) {
+                return concatenation([prefix, alternation([
+                        ...strings.map(s => s.slice(prefix.length)),
+                        ...unique.filter(p => typeof p !== 'string')
+                    ])]);
+            }
+            const result = [];
+            let cs;
+            for (const part of unique) {
+                if (typeof part === 'string' && part.length === 1) {
+                    if (!cs)
+                        cs = new MutablecharacterClass(false);
+                    cs.setChar(part);
+                }
+                else if (is(part, 'class')) {
+                    if (!cs)
+                        cs = part.mutable();
+                    else
+                        cs.selfUnion(part);
+                }
+                else {
+                    if (cs) {
+                        result.push(cs);
+                        cs = undefined;
+                    }
+                    result.push(part);
+                }
+            }
+            if (cs)
+                result.push(cs);
+            return alternation(result);
+            /*
+                        // not safe to do this, as it changes the order of alternatives
+                        const single = partition(unique, p => typeof p === 'string' && p.length === 1);
+                        if (single.true) {
+                            const c = chars(single.true.map(s => s as string).join(''));
+                            return single.false ? alternation([c, ...single.false]) : c;
+                        }
+                        return alternation(unique);
+            */
+        }
+        else if (is(p, 'class')) {
+            const i = p.next(-1);
+            if (i >= 0 && p.next(i) === -1)
+                return String.fromCharCode(i);
+        }
+        return p;
+    });
+}
+// Step 1: Build Thompson NFA from regex AST
+function buildNFA(part) {
+    let stateId = 0;
+    function newState() {
+        return { id: stateId++, transitions: new Map(), epsilonTransitions: [], isAccepting: false };
+    }
+    function build(p) {
+        if (typeof p === 'string') {
+            // Character literal: start --'c'--> accept
+            const start = newState();
+            const accept = newState();
+            start.transitions.set(p, [accept]);
+            return { start, accept };
+        }
+        if (Array.isArray(p)) {
+            let current = build(p[0]);
+            for (let i = 1; i < p.length; i++) {
+                const next = build(p[i]);
+                current.accept.epsilonTransitions.push(next.start);
+                current.accept = next.accept;
+            }
+            return current;
+        }
+        switch (p.type) {
+            case 'alt': {
+                // Alternation: start --ε--> frag1.start, frag2.start, ... --ε--> accept
+                const start = newState();
+                const accept = newState();
+                for (const alt of p.parts) {
+                    const frag = build(alt);
+                    start.epsilonTransitions.push(frag.start);
+                    frag.accept.epsilonTransitions.push(accept);
+                }
+                return { start, accept };
+            }
+            case 'quantified': {
+                const frag = build(p.part);
+                const start = newState();
+                const accept = newState();
+                // Handle min repetitions
+                let current = start;
+                for (let i = 0; i < p.min; i++) {
+                    const copy = build(p.part);
+                    current.epsilonTransitions.push(copy.start);
+                    current = copy.accept;
+                }
+                // Handle optional repetitions or infinite
+                if (p.max === -1) {
+                    // Infinite: can loop back
+                    current.epsilonTransitions.push(frag.start);
+                    frag.accept.epsilonTransitions.push(frag.start, accept);
+                    current.epsilonTransitions.push(accept);
+                }
+                else {
+                    // Finite: add optional copies
+                    for (let i = p.min; i < p.max; i++) {
+                        current.epsilonTransitions.push(accept); // can skip
+                        const copy = build(p.part);
+                        current.epsilonTransitions.push(copy.start);
+                        current = copy.accept;
+                    }
+                    current.epsilonTransitions.push(accept);
+                }
+                return { start, accept };
+            }
+            case 'class': {
+                // Character class: single transition with multiple chars
+                const start = newState();
+                const accept = newState();
+                //if (p.contains(any))
+                //	return '.';
+                // Add transition for each character in the class
+                for (let i = p.next(-1); i !== -1; i = p.next(i)) {
+                    const char = String.fromCodePoint(i);
+                    const existing = start.transitions.get(char) || [];
+                    existing.push(accept);
+                    start.transitions.set(char, existing);
+                }
+                return { start, accept };
+            }
+            case 'wordbound':
+            case 'nowordbound':
+            case 'inputboundstart':
+            case 'inputboundend': {
+                // Anchors: epsilon transition with special handling
+                const start = newState();
+                const accept = newState();
+                // Mark transition with anchor type for special processing
+                start.transitions.set(`__${p.type}__`, [accept]);
+                return { start, accept };
+            }
+            case 'noncapture':
+            case 'capture':
+                // Groups: just pass through (captures handled at higher level)
+                return build(p.part);
+            default:
+                throw new Error(`Unsupported: ${p.type}`);
+        }
+    }
+    const result = build(part);
+    result.accept.isAccepting = true;
+    return result;
+}
+// Step 3: Subset Construction - convert NFA to DFA
+function NFAtoDFA(nfaStart) {
+    const nfa = [];
+    const alphabet = new Set();
+    function collectStates(state) {
+        if (!nfa[state.id]) {
+            nfa[state.id] = state;
+            for (const char of state.transitions.keys())
+                alphabet.add(char);
+            for (const targets of state.transitions.values())
+                targets.forEach(collectStates);
+            state.epsilonTransitions.forEach(collectStates);
+        }
+    }
+    collectStates(nfaStart);
+    const dfaStates = new Map();
+    let dfaStateId = 0;
+    function stateSetKey(states) {
+        return [...states].sort().join(',');
+    }
+    // Epsilon closure - find all states reachable via ε-transitions
+    function epsilonClosure(states) {
+        const closure = new Set(states);
+        const stack = [...states];
+        while (stack.length > 0) {
+            const id = stack.pop();
+            for (const next of nfa[id].epsilonTransitions) {
+                if (!closure.has(next.id)) {
+                    closure.add(next.id);
+                    stack.push(next.id);
+                }
+            }
+        }
+        return closure;
+    }
+    function createDFAState(states) {
+        const isAccepting = [...states].some(id => nfa[id]?.isAccepting);
+        return { /*id: dfaStateId++, */ nfaStates: states, transitions: new Map(), isAccepting };
+    }
+    // Start with epsilon closure of initial state
+    const start = new Set([nfaStart.id]);
+    const startClosure = epsilonClosure(start);
+    const startDFA = createDFAState(startClosure);
+    dfaStates.set(stateSetKey(startClosure), startDFA);
+    const worklist = [startDFA];
+    while (worklist.length > 0) {
+        const currentDFA = worklist.pop();
+        // For each character in alphabet
+        for (const char of alphabet) {
+            // Collect all NFA states reachable by this character
+            const next = new Set();
+            for (const id of currentDFA.nfaStates) {
+                const targets = nfa[id]?.transitions.get(char) || [];
+                targets.forEach(target => next.add(target.id));
+            }
+            if (next.size > 0) {
+                // Take epsilon closure of the result
+                const nextClosure = epsilonClosure(next);
+                // Check if this set of NFA states already has a corresponding DFA state
+                const key = stateSetKey(nextClosure);
+                let nextDFA = dfaStates.get(key);
+                if (!nextDFA) {
+                    nextDFA = createDFAState(nextClosure);
+                    dfaStates.set(key, nextDFA);
+                    worklist.push(nextDFA);
+                }
+                currentDFA.transitions.set(char, nextDFA);
+            }
+        }
+    }
+    return startDFA;
+}
+function runDFA(dfa, str) {
+    let currentState = dfa;
+    for (const char of str) {
+        currentState = currentState.transitions.get(char);
+        if (!currentState)
+            return false;
+    }
+    return currentState.isAccepting;
+}
+// Usage:
+function regexToDFA(part) {
+    const nfa = buildNFA(part);
+    return NFAtoDFA(nfa.start);
+}
+///
+function parseGlob(glob) {
+    let result = '';
+    let depth = 0;
+    for (let i = 0; i < glob.length; ++i) {
+        let c = glob[i];
+        switch (c) {
+            case '\\':
+                c = glob[++i];
+                if ('*?+.,^$()|[]a-zA-Z'.includes(c))
+                    result += '\\';
+                break;
+            case '*':
+                if (glob[i + 1] === '*') {
+                    result += '.*';
+                    ++i;
+                }
+                else {
+                    result += '[^/]*';
+                }
+                continue;
+            case '?':
+                c = '.';
+                break;
+            case '+':
+            case '.':
+            case '^':
+            case '$':
+            case '(':
+            case ')':
+            case '|':
+                result += `\\`;
+                break;
+            case '[': {
+                const end = glob.indexOf(']', i + 1);
+                if (end > i) {
+                    const next = glob[i + 1];
+                    if (next === ':' && glob[end - 1] === ':') {
+                        const p = posixClasses[glob.slice(i + 2, end - 1)];
+                        if (p) {
+                            result += `[${p}]`;
+                            i = end;
+                            continue;
+                        }
+                        else {
+                            console.log(`Warning: Unknown POSIX class ${glob.slice(i + 2, end - 1)} in glob pattern ${glob}`);
+                        }
+                    }
+                    const neg = next === '!' || next === '^';
+                    result += `[${neg ? '^' : ''}${glob.slice(neg ? i + 2 : i + 1, end)}]`;
+                    i = end;
+                    continue;
+                }
+                result += '\\';
+                break;
+            }
+            case '{':
+                ++depth;
+                c = '(';
+                break;
+            case '}':
+                if (depth > 0) {
+                    --depth;
+                    c = ')';
+                }
+                break;
+            case ',':
+                if (depth > 0)
+                    c = '|';
+                break;
+        }
+        result += c;
+    }
+    if (depth > 0) {
+        console.log(`Warning: Unmatched { in glob pattern ${glob}`);
+        result += ')'.repeat(depth);
+    }
+    return result;
+}
+function anchoredRe(re) {
+    return new RegExp(`^${re}$`);
+}
+function globToRe(glob) {
+    return anchoredRe(parseGlob(glob));
+}
+function globToReMulti(globs) {
+    return anchoredRe(globs.map(parseGlob).join('|'));
+}