@isopodlabs/utilities 1.5.5 → 1.5.6

package/dist/regexp.js

@@ -0,0 +1,659 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endAnchor = exports.startAnchor = exports.nonWordBoundary = exports.wordBoundary = exports.octal = exports.hex = exports.alnum = exports.alpha = exports.upper = exports.lower = exports.whitespace = exports.word = 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.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) {
+        this.set(char.charCodeAt(0));
+    }
+    test(char) {
+        return this.has(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;
+    }
+    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;
+    }
+    static fromString(value) {
+        return new characterClass(false).setString(value);
+    }
+}
+exports.characterClass = characterClass;
+;
+// characterClass helpers
+function range(from, to) {
+    return new characterClass(false).setRange(from.charCodeAt(0), to.charCodeAt(0) + 1);
+}
+function chars(chars) {
+    return new characterClass(false).setString(chars);
+}
+function union(...classes) {
+    const result = new characterClass(false);
+    for (const cls of classes)
+        result.union(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.word = range('a', 'z').union(range('A', 'Z')).union(range('0', '9')).union(chars('_')); //word
+exports.whitespace = chars(' \t\r\n\f\v'); //whitespace
+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.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] : { 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, greedy = true) {
+    return { type: 'quantified', part, min, max, greedy };
+}
+function repeat(part, n, greedy = true) {
+    return { type: 'quantified', part, min: n, max: n, greedy };
+}
+function zeroOrMore(part, greedy = true) { return repeatFrom(part, 0, -1, greedy); }
+function oneOrMore(part, greedy = true) { return repeatFrom(part, 1, -1, greedy); }
+function optional(part, greedy = true) { return repeatFrom(part, 0, 1, greedy); }
+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 is(part, type) {
+    return typeof part === 'string' ? type === 'text'
+        : Array.isArray(part) ? type === 'concat'
+            : part.type === type;
+}
+function parse(re, unicode = true) {
+    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) {
+        const greedy = re[i] !== '?';
+        if (!greedy)
+            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, greedy));
+        }
+        else {
+            curr.push(repeatFrom(top, min, max, greedy));
+        }
+    }
+    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;
+                        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++;
+                let 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);
+}
+function list(parts, join) {
+    return parts.map(p => {
+        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) + (part.min === 0 && part.max === -1 ? '*'
+                : part.min === 1 && part.max === -1 ? '+'
+                    : part.min === 0 && part.max === 1 ? '?'
+                        : part.max === -1 ? `{${part.min},}`
+                            : part.min === part.max ? `{${part.min}}`
+                                : `{${part.min},${part.max}}`) + (part.greedy ? '' : '?');
+        case 'noncapture': {
+            let header = '';
+            const opts = part.options;
+            if (opts) {
+                if (typeof opts === 'string') {
+                    header = {
+                        ahead: '=',
+                        behind: '<=',
+                        neg_ahead: '!',
+                        neg_behind: '<!'
+                    }[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':
+            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 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('|'));
+}

package/dist/string.d.ts

@@ -26,7 +26,3 @@ export declare class StringParser {
     match(re: RegExp): string | undefined;
     exec(re: RegExp): RegExpExecArray | undefined;
 }
-export declare function parseGlob(glob: string): string;
-export declare function anchoredRe(re: string): RegExp;
-export declare function globToRe(glob: string): RegExp;
-export declare function globToReMulti(globs: string[]): RegExp;