@zokugun/regexp 0.3.0

package/lib/esm/index.d.mts

@@ -0,0 +1,7 @@
+export { escape } from './escape.mjs';
+export { parse } from './parse.mjs';
+export { stringify } from './stringify.mjs';
+export { visit } from './visit.mjs';
+export { transform, type TransformContext } from './transform.mjs';
+export { translate } from './translate.mjs';
+export { TokenType, Flavor, type Token } from './types.mjs';

package/lib/esm/index.mjs

@@ -0,0 +1,7 @@
+export { escape } from './escape.mjs';
+export { parse } from './parse.mjs';
+export { stringify } from './stringify.mjs';
+export { visit } from './visit.mjs';
+export { transform } from './transform.mjs';
+export { translate } from './translate.mjs';
+export { TokenType, Flavor } from './types.mjs';

package/lib/esm/parse.d.mts

@@ -0,0 +1,2 @@
+import { type Token } from './types.mjs';
+export declare function parse(value: string | RegExp): Token;

package/lib/esm/parse.mjs

@@ -0,0 +1,13 @@
+import { isRegExp } from '@zokugun/is-it-type';
+import { pegParse } from './generated/parser.mjs';
+export function parse(value) {
+    if (typeof value === 'string') {
+        return pegParse(value);
+    }
+    else if (isRegExp(value)) {
+        return pegParse(value.toString());
+    }
+    else {
+        throw new TypeError('The regexp to parse must be represented as a string.');
+    }
+}

package/lib/esm/stringify.d.mts

@@ -0,0 +1,2 @@
+import { type Token } from './types.mjs';
+export declare function stringify(tokens?: Token | Token[] | RegExp): string;

package/lib/esm/stringify.mjs

@@ -0,0 +1,225 @@
+import { isRegExp } from '@zokugun/is-it-type';
+import { TokenType } from './types.mjs';
+export function stringify(tokens) {
+    if (Array.isArray(tokens)) {
+        let result = '';
+        for (const token of tokens) {
+            result += stringify(token);
+        }
+        return result;
+    }
+    else if (isRegExp(tokens)) {
+        return tokens.toString();
+    }
+    else if (tokens) {
+        return toString(tokens, '');
+    }
+    else {
+        return '';
+    }
+}
+function toString(value, result) {
+    if (value.type === TokenType.ALTERNATE) {
+        for (let i = 0, l = (value.body).length; i < l; i++) {
+            if (i !== 0) {
+                result += '|';
+            }
+            result = toString((value.body)[i], result);
+        }
+    }
+    else if (value.type === TokenType.ANY) {
+        result += '.';
+    }
+    else if (value.type === TokenType.BACK_REFERENCE) {
+        result += `\\${value.code}`;
+    }
+    else if (value.type === TokenType.BACKSPACE) {
+        result += '\\b';
+    }
+    else if (value.type === TokenType.BEGIN) {
+        result += '^';
+    }
+    else if (value.type === TokenType.CAPTURE_GROUP) {
+        result += '(';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === TokenType.CARRIAGE_RETURN) {
+        result += '\\r';
+    }
+    else if (value.type === TokenType.CHARSET) {
+        result += '[';
+        if (value.negated) {
+            result += '^';
+        }
+        for (const item of value.body) {
+            result = toString(item, result);
+        }
+        result += ']';
+    }
+    else if (value.type === TokenType.CONTROL) {
+        result += `\\c${value.code}`;
+    }
+    else if (value.type === TokenType.DIGIT) {
+        result += '\\d';
+    }
+    else if (value.type === TokenType.END) {
+        result += '$';
+    }
+    else if (value.type === TokenType.ESCAPE) {
+        result += `\\${value.code}`;
+    }
+    else if (value.type === TokenType.FORM_FEED) {
+        result += '\\f';
+    }
+    else if (value.type === TokenType.HEX) {
+        result += `\\x${value.code}`;
+    }
+    else if (value.type === TokenType.LINE_FEED) {
+        result += '\\n';
+    }
+    else if (value.type === TokenType.LITERAL) {
+        result += value.text;
+    }
+    else if (value.type === TokenType.MATCH) {
+        for (const item of value.body) {
+            result = toString(item, result);
+        }
+    }
+    else if (value.type === TokenType.MODIFIED_GROUP) {
+        result += '(?';
+        result += value.modifiers.positive.join('');
+        if (value.modifiers.negative.length > 0) {
+            result += `-${value.modifiers.negative.join('')}`;
+        }
+        result += ':';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === TokenType.MODIFIER) {
+        result += '(?';
+        result += value.positive.join('');
+        if (value.negative.length > 0) {
+            result += `-${value.negative.join('')}`;
+        }
+        result += ')';
+    }
+    else if (value.type === TokenType.NAMED_BACK_REFERENCE) {
+        result += `\\k<${value.name}>`;
+    }
+    else if (value.type === TokenType.NAMED_GROUP) {
+        result += `(?<${value.name}>`;
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === TokenType.NEGATIVE_LOOKAHEAD) {
+        result += '(?!';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === TokenType.NEGATIVE_LOOKBEHIND) {
+        result += '(?<!';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === TokenType.NON_CAPTURE_GROUP) {
+        result += '(?:';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === TokenType.NON_DIGIT) {
+        result += '\\D';
+    }
+    else if (value.type === TokenType.NON_UNICODE_PROPERTY) {
+        result += `\\P{${value.property}}`;
+    }
+    else if (value.type === TokenType.NON_WHITE_SPACE) {
+        result += '\\S';
+    }
+    else if (value.type === TokenType.NON_WORD) {
+        result += '\\W';
+    }
+    else if (value.type === TokenType.NON_WORD_BOUNDARY) {
+        result += '\\B';
+    }
+    else if (value.type === TokenType.NUL) {
+        result += '\\0';
+    }
+    else if (value.type === TokenType.OCTAL) {
+        result += `\\0${value.code}`;
+    }
+    else if (value.type === TokenType.PATTERN) {
+        result += '/';
+        result = toString(value.body, result);
+        result += '/';
+        if (value.modifiers) {
+            result += value.modifiers.positive.join('');
+        }
+    }
+    else if (value.type === TokenType.POSITIVE_LOOKAHEAD) {
+        result += '(?=';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === TokenType.POSITIVE_LOOKBEHIND) {
+        result += '(?<=';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === TokenType.QUANTIFIED) {
+        result = toString(value.body, result);
+        result = toString(value.quantifier, result);
+    }
+    else if (value.type === TokenType.QUANTIFIER) {
+        if (value.max === Infinity) {
+            if (value.min === 0) {
+                result += '*';
+            }
+            else if (value.min === 1) {
+                result += '+';
+            }
+            else {
+                result += `{${value.min},}`;
+            }
+        }
+        else if (value.min === 0 && value.max === 1) {
+            result += '?';
+        }
+        else if (value.min === value.max) {
+            result += `{${value.min}}`;
+        }
+        else {
+            result += `{${value.min},${value.max}}`;
+        }
+    }
+    else if (value.type === TokenType.RANGE) {
+        result = toString(value.begin, result);
+        result += '-';
+        result = toString(value.end, result);
+    }
+    else if (value.type === TokenType.TAB) {
+        result += '\\t';
+    }
+    else if (value.type === TokenType.UNICODE) {
+        result += `\\u{${value.code}}`;
+    }
+    else if (value.type === TokenType.UNICODE_PROPERTY) {
+        result += `\\p{${value.property}}`;
+    }
+    else if (value.type === TokenType.UTF16) {
+        result += `\\u${value.code}`;
+    }
+    else if (value.type === TokenType.VERTICAL_TAB) {
+        result += '\\v';
+    }
+    else if (value.type === TokenType.WHITE_SPACE) {
+        result += '\\s';
+    }
+    else if (value.type === TokenType.WORD) {
+        result += '\\w';
+    }
+    else if (value.type === TokenType.WORD_BOUNDARY) {
+        result += '\\b';
+    }
+    return result;
+}

package/lib/esm/transform.d.mts

@@ -0,0 +1,7 @@
+import { type Token, type TokenType, type Transformer } from './types.mjs';
+export type TransformContext = {
+    remove(): void;
+    replace(token: Token | string | Token[], transform?: boolean): void;
+    transform(tokensArg: Token | Token[] | undefined, parentArg: Token | null, keyArg: string | null): void;
+};
+export declare function transform(tokens: Token | Token[] | undefined, callback?: Transformer | Partial<Record<TokenType, Transformer>>): void;

package/lib/esm/transform.mjs

@@ -0,0 +1,116 @@
+import { parse } from './parse.mjs';
+export function transform(tokens, callback) {
+    if (typeof callback === 'function') {
+        transformFunc(tokens, null, null, callback);
+    }
+    else if (callback) {
+        transformMap(tokens, callback);
+    }
+}
+function transformFunc(tokens, parent, key, callback) {
+    if (Array.isArray(tokens)) {
+        let i = -1;
+        let notSkipped = true;
+        const that = {
+            remove() {
+                tokens.splice(i, 1);
+                --i;
+                notSkipped = false;
+            },
+            replace(token, transform) {
+                let replacement;
+                if (typeof token === 'string') {
+                    replacement = parse(token).body;
+                }
+                else {
+                    replacement = token;
+                }
+                if (Array.isArray(replacement)) {
+                    tokens.splice(i, 1, ...replacement);
+                }
+                else {
+                    tokens.splice(i, 1, replacement);
+                }
+                if (transform) {
+                    --i;
+                }
+                else if (Array.isArray(replacement)) {
+                    i += replacement.length - 1;
+                }
+                notSkipped = false;
+            },
+            transform(tokensArg, parentArg, keyArg) {
+                transformFunc(tokensArg, parentArg, keyArg, callback);
+                notSkipped = false;
+            },
+        };
+        while (++i < tokens.length) {
+            const token = tokens[i];
+            callback.call(that, token, parent, key, i);
+            if (notSkipped) {
+                if ('body' in token && token.body) {
+                    transformFunc(token.body, token, 'body', callback);
+                }
+            }
+            else {
+                notSkipped = true;
+            }
+        }
+    }
+    else if (parent) {
+        let notSkipped = true;
+        const that = {
+            remove() {
+                if (parent && key) {
+                    delete parent[key];
+                }
+                notSkipped = false;
+            },
+            replace(token, transform) {
+                let replacement;
+                if (typeof token === 'string') {
+                    replacement = parse(token).body;
+                }
+                else {
+                    replacement = token;
+                }
+                if (parent && key) {
+                    parent[key] = replacement;
+                }
+                if (transform && replacement) {
+                    transformFunc(replacement, parent, key, callback);
+                }
+                notSkipped = false;
+            },
+            transform(tokensArg, parentArg, keyArg) {
+                transformFunc(tokensArg, parentArg, keyArg, callback);
+                notSkipped = false;
+            },
+        };
+        callback.call(that, tokens, parent, key, null);
+        if (notSkipped) {
+            const maybeBody = tokens.body;
+            if (maybeBody) {
+                transformFunc(maybeBody, tokens, 'body', callback);
+            }
+        }
+        else {
+            notSkipped = true;
+        }
+    }
+    else {
+        callback.call(null, tokens, null, null, null);
+        const maybeBody = tokens.body;
+        if (maybeBody) {
+            transformFunc(maybeBody, tokens, 'body', callback);
+        }
+    }
+}
+function transformMap(tokens, callbackMap) {
+    transformFunc(tokens, null, null, function (token, parent, key, index) {
+        const fn = callbackMap[token.type];
+        if (fn) {
+            fn.call(this, token, parent, key, index);
+        }
+    });
+}

package/lib/esm/translate.d.mts

@@ -0,0 +1,4 @@
+import { Flavor, type Token } from './types.mjs';
+export declare function translate(value: string | RegExp | Token | Token[], target: Flavor, toString?: true): string;
+export declare function translate(value: Token[], target: Flavor, toString: false): Token[];
+export declare function translate(value: string | RegExp | Token, target: Flavor, toString: false): Token;

package/lib/esm/translate.mjs

@@ -0,0 +1,136 @@
+import { isRegExp, isString } from '@zokugun/is-it-type';
+import { parse } from './parse.mjs';
+import { stringify } from './stringify.mjs';
+import { transform } from './transform.mjs';
+import { TokenType, Flavor } from './types.mjs';
+const TRANSLATORS = {
+    [Flavor.ES2018]: translateES2018,
+};
+export function translate(value, target, toString = true) {
+    const translator = TRANSLATORS[target];
+    if (!translator) {
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (isRegExp(value)) {
+            return value.toString();
+        }
+        return value;
+    }
+    let result;
+    if (Array.isArray(value)) {
+        result = [];
+        for (const item of value) {
+            result.push(translator(item));
+        }
+    }
+    else if (isRegExp(value) || isString(value)) {
+        result = translator(parse(value));
+    }
+    else {
+        result = translator(value);
+    }
+    if (toString) {
+        return stringify(result);
+    }
+    else {
+        return result;
+    }
+}
+function translateES2018(ast) {
+    const astToken = ast;
+    let caseless = false;
+    let inCharset = false;
+    let sets = null;
+    transform(astToken, {
+        [TokenType.CHARSET]: function (token) {
+            const charset = token;
+            inCharset = true;
+            sets = {};
+            this.transform(charset.body, token, 'body');
+            inCharset = false;
+        },
+        [TokenType.LITERAL]: function (token) {
+            const literal = token;
+            if (caseless) {
+                let text = '';
+                let upper;
+                let lower;
+                let upperLower;
+                for (const c of literal.text.split('')) {
+                    upper = c.toUpperCase();
+                    lower = c.toLowerCase();
+                    if (upper === lower) {
+                        text += upper;
+                    }
+                    else {
+                        upperLower = `${upper}${lower}`;
+                        if (inCharset) {
+                            if (!sets[upperLower]) {
+                                sets[upperLower] = true;
+                                text += upperLower;
+                            }
+                        }
+                        else {
+                            text += `[${upperLower}]`;
+                        }
+                    }
+                }
+                if (literal.text !== text) {
+                    this.replace(text);
+                }
+            }
+        },
+        [TokenType.MODIFIED_GROUP]: function (token) {
+            const modifier = token;
+            if (modifier.modifiers.positive.includes('i')) {
+                caseless = true;
+            }
+            if (modifier.modifiers.negative.includes('i')) {
+                caseless = false;
+            }
+            this.replace({
+                type: TokenType.NON_CAPTURE_GROUP,
+                body: modifier.body,
+            }, true);
+        },
+        [TokenType.MODIFIER]: function (token) {
+            const modifier = token;
+            if (modifier.positive.includes('i')) {
+                caseless = true;
+            }
+            if (modifier.negative.includes('i')) {
+                caseless = false;
+            }
+            this.remove();
+        },
+        [TokenType.RANGE]: function (token) {
+            const range = token;
+            if (caseless) {
+                let beginUpper;
+                let beginLower;
+                if (range.begin.type === TokenType.LITERAL) {
+                    beginUpper = range.begin.text.toUpperCase();
+                    beginLower = range.begin.text.toLowerCase();
+                }
+                let endUpper;
+                let endLower;
+                if (range.end.type === TokenType.LITERAL) {
+                    endUpper = range.end.text.toUpperCase();
+                    endLower = range.end.text.toLowerCase();
+                }
+                if (beginUpper && endUpper && beginUpper !== beginLower && (beginUpper.codePointAt(0) - endUpper.codePointAt(0)) === (beginLower.codePointAt(0) - endLower.codePointAt(0))) {
+                    const range = `${beginUpper}-${endUpper}${beginLower}-${endLower}`;
+                    if (sets[range]) {
+                        this.remove();
+                    }
+                    else {
+                        sets[range] = true;
+                        this.replace(range);
+                    }
+                }
+            }
+        },
+    });
+    return astToken;
+}