@zokugun/regexp 0.3.0

package/lib/cjs/generated/parser.d.cts

@@ -0,0 +1,2 @@
+import { Token } from '../types.cjs';
+export declare const pegParse: (s: string) => Token;

package/lib/cjs/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flavor = exports.TokenType = exports.translate = exports.transform = exports.visit = exports.stringify = exports.parse = void 0;
+var escape_js_1 = require("./escape.cjs");
+Object.defineProperty(exports, "escape", { enumerable: true, get: function () { return escape_js_1.escape; } });
+var parse_js_1 = require("./parse.cjs");
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parse_js_1.parse; } });
+var stringify_js_1 = require("./stringify.cjs");
+Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return stringify_js_1.stringify; } });
+var visit_js_1 = require("./visit.cjs");
+Object.defineProperty(exports, "visit", { enumerable: true, get: function () { return visit_js_1.visit; } });
+var transform_js_1 = require("./transform.cjs");
+Object.defineProperty(exports, "transform", { enumerable: true, get: function () { return transform_js_1.transform; } });
+var translate_js_1 = require("./translate.cjs");
+Object.defineProperty(exports, "translate", { enumerable: true, get: function () { return translate_js_1.translate; } });
+var types_js_1 = require("./types.cjs");
+Object.defineProperty(exports, "TokenType", { enumerable: true, get: function () { return types_js_1.TokenType; } });
+Object.defineProperty(exports, "Flavor", { enumerable: true, get: function () { return types_js_1.Flavor; } });

package/lib/cjs/index.d.cts

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

package/lib/cjs/parse.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = parse;
+const is_it_type_1 = require("@zokugun/is-it-type");
+const parser_js_1 = require("./generated/parser.cjs");
+function parse(value) {
+    if (typeof value === 'string') {
+        return (0, parser_js_1.pegParse)(value);
+    }
+    else if ((0, is_it_type_1.isRegExp)(value)) {
+        return (0, parser_js_1.pegParse)(value.toString());
+    }
+    else {
+        throw new TypeError('The regexp to parse must be represented as a string.');
+    }
+}

package/lib/cjs/parse.d.cts

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

package/lib/cjs/stringify.cjs

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = stringify;
+const is_it_type_1 = require("@zokugun/is-it-type");
+const types_js_1 = require("./types.cjs");
+function stringify(tokens) {
+    if (Array.isArray(tokens)) {
+        let result = '';
+        for (const token of tokens) {
+            result += stringify(token);
+        }
+        return result;
+    }
+    else if ((0, is_it_type_1.isRegExp)(tokens)) {
+        return tokens.toString();
+    }
+    else if (tokens) {
+        return toString(tokens, '');
+    }
+    else {
+        return '';
+    }
+}
+function toString(value, result) {
+    if (value.type === types_js_1.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 === types_js_1.TokenType.ANY) {
+        result += '.';
+    }
+    else if (value.type === types_js_1.TokenType.BACK_REFERENCE) {
+        result += `\\${value.code}`;
+    }
+    else if (value.type === types_js_1.TokenType.BACKSPACE) {
+        result += '\\b';
+    }
+    else if (value.type === types_js_1.TokenType.BEGIN) {
+        result += '^';
+    }
+    else if (value.type === types_js_1.TokenType.CAPTURE_GROUP) {
+        result += '(';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === types_js_1.TokenType.CARRIAGE_RETURN) {
+        result += '\\r';
+    }
+    else if (value.type === types_js_1.TokenType.CHARSET) {
+        result += '[';
+        if (value.negated) {
+            result += '^';
+        }
+        for (const item of value.body) {
+            result = toString(item, result);
+        }
+        result += ']';
+    }
+    else if (value.type === types_js_1.TokenType.CONTROL) {
+        result += `\\c${value.code}`;
+    }
+    else if (value.type === types_js_1.TokenType.DIGIT) {
+        result += '\\d';
+    }
+    else if (value.type === types_js_1.TokenType.END) {
+        result += '$';
+    }
+    else if (value.type === types_js_1.TokenType.ESCAPE) {
+        result += `\\${value.code}`;
+    }
+    else if (value.type === types_js_1.TokenType.FORM_FEED) {
+        result += '\\f';
+    }
+    else if (value.type === types_js_1.TokenType.HEX) {
+        result += `\\x${value.code}`;
+    }
+    else if (value.type === types_js_1.TokenType.LINE_FEED) {
+        result += '\\n';
+    }
+    else if (value.type === types_js_1.TokenType.LITERAL) {
+        result += value.text;
+    }
+    else if (value.type === types_js_1.TokenType.MATCH) {
+        for (const item of value.body) {
+            result = toString(item, result);
+        }
+    }
+    else if (value.type === types_js_1.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 === types_js_1.TokenType.MODIFIER) {
+        result += '(?';
+        result += value.positive.join('');
+        if (value.negative.length > 0) {
+            result += `-${value.negative.join('')}`;
+        }
+        result += ')';
+    }
+    else if (value.type === types_js_1.TokenType.NAMED_BACK_REFERENCE) {
+        result += `\\k<${value.name}>`;
+    }
+    else if (value.type === types_js_1.TokenType.NAMED_GROUP) {
+        result += `(?<${value.name}>`;
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === types_js_1.TokenType.NEGATIVE_LOOKAHEAD) {
+        result += '(?!';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === types_js_1.TokenType.NEGATIVE_LOOKBEHIND) {
+        result += '(?<!';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === types_js_1.TokenType.NON_CAPTURE_GROUP) {
+        result += '(?:';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === types_js_1.TokenType.NON_DIGIT) {
+        result += '\\D';
+    }
+    else if (value.type === types_js_1.TokenType.NON_UNICODE_PROPERTY) {
+        result += `\\P{${value.property}}`;
+    }
+    else if (value.type === types_js_1.TokenType.NON_WHITE_SPACE) {
+        result += '\\S';
+    }
+    else if (value.type === types_js_1.TokenType.NON_WORD) {
+        result += '\\W';
+    }
+    else if (value.type === types_js_1.TokenType.NON_WORD_BOUNDARY) {
+        result += '\\B';
+    }
+    else if (value.type === types_js_1.TokenType.NUL) {
+        result += '\\0';
+    }
+    else if (value.type === types_js_1.TokenType.OCTAL) {
+        result += `\\0${value.code}`;
+    }
+    else if (value.type === types_js_1.TokenType.PATTERN) {
+        result += '/';
+        result = toString(value.body, result);
+        result += '/';
+        if (value.modifiers) {
+            result += value.modifiers.positive.join('');
+        }
+    }
+    else if (value.type === types_js_1.TokenType.POSITIVE_LOOKAHEAD) {
+        result += '(?=';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === types_js_1.TokenType.POSITIVE_LOOKBEHIND) {
+        result += '(?<=';
+        result = toString(value.body, result);
+        result += ')';
+    }
+    else if (value.type === types_js_1.TokenType.QUANTIFIED) {
+        result = toString(value.body, result);
+        result = toString(value.quantifier, result);
+    }
+    else if (value.type === types_js_1.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 === types_js_1.TokenType.RANGE) {
+        result = toString(value.begin, result);
+        result += '-';
+        result = toString(value.end, result);
+    }
+    else if (value.type === types_js_1.TokenType.TAB) {
+        result += '\\t';
+    }
+    else if (value.type === types_js_1.TokenType.UNICODE) {
+        result += `\\u{${value.code}}`;
+    }
+    else if (value.type === types_js_1.TokenType.UNICODE_PROPERTY) {
+        result += `\\p{${value.property}}`;
+    }
+    else if (value.type === types_js_1.TokenType.UTF16) {
+        result += `\\u${value.code}`;
+    }
+    else if (value.type === types_js_1.TokenType.VERTICAL_TAB) {
+        result += '\\v';
+    }
+    else if (value.type === types_js_1.TokenType.WHITE_SPACE) {
+        result += '\\s';
+    }
+    else if (value.type === types_js_1.TokenType.WORD) {
+        result += '\\w';
+    }
+    else if (value.type === types_js_1.TokenType.WORD_BOUNDARY) {
+        result += '\\b';
+    }
+    return result;
+}

package/lib/cjs/stringify.d.cts

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

package/lib/cjs/transform.cjs

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = transform;
+const parse_js_1 = require("./parse.cjs");
+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 = (0, parse_js_1.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 = (0, parse_js_1.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/cjs/transform.d.cts

@@ -0,0 +1,7 @@
+import { type Token, type TokenType, type Transformer } from './types.cjs';
+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/cjs/translate.cjs

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translate = translate;
+const is_it_type_1 = require("@zokugun/is-it-type");
+const parse_js_1 = require("./parse.cjs");
+const stringify_js_1 = require("./stringify.cjs");
+const transform_js_1 = require("./transform.cjs");
+const types_js_1 = require("./types.cjs");
+const TRANSLATORS = {
+    [types_js_1.Flavor.ES2018]: translateES2018,
+};
+function translate(value, target, toString = true) {
+    const translator = TRANSLATORS[target];
+    if (!translator) {
+        if (typeof value === 'string') {
+            return value;
+        }
+        if ((0, is_it_type_1.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 ((0, is_it_type_1.isRegExp)(value) || (0, is_it_type_1.isString)(value)) {
+        result = translator((0, parse_js_1.parse)(value));
+    }
+    else {
+        result = translator(value);
+    }
+    if (toString) {
+        return (0, stringify_js_1.stringify)(result);
+    }
+    else {
+        return result;
+    }
+}
+function translateES2018(ast) {
+    const astToken = ast;
+    let caseless = false;
+    let inCharset = false;
+    let sets = null;
+    (0, transform_js_1.transform)(astToken, {
+        [types_js_1.TokenType.CHARSET]: function (token) {
+            const charset = token;
+            inCharset = true;
+            sets = {};
+            this.transform(charset.body, token, 'body');
+            inCharset = false;
+        },
+        [types_js_1.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);
+                }
+            }
+        },
+        [types_js_1.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: types_js_1.TokenType.NON_CAPTURE_GROUP,
+                body: modifier.body,
+            }, true);
+        },
+        [types_js_1.TokenType.MODIFIER]: function (token) {
+            const modifier = token;
+            if (modifier.positive.includes('i')) {
+                caseless = true;
+            }
+            if (modifier.negative.includes('i')) {
+                caseless = false;
+            }
+            this.remove();
+        },
+        [types_js_1.TokenType.RANGE]: function (token) {
+            const range = token;
+            if (caseless) {
+                let beginUpper;
+                let beginLower;
+                if (range.begin.type === types_js_1.TokenType.LITERAL) {
+                    beginUpper = range.begin.text.toUpperCase();
+                    beginLower = range.begin.text.toLowerCase();
+                }
+                let endUpper;
+                let endLower;
+                if (range.end.type === types_js_1.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;
+}

package/lib/cjs/translate.d.cts

@@ -0,0 +1,4 @@
+import { Flavor, type Token } from './types.cjs';
+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/cjs/types.cjs

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flavor = exports.TokenType = void 0;
+var TokenType;
+(function (TokenType) {
+    TokenType["ALTERNATE"] = "alternate";
+    TokenType["ANY"] = "any";
+    TokenType["BACK_REFERENCE"] = "back-reference";
+    TokenType["BACKSPACE"] = "backspace";
+    TokenType["BEGIN"] = "begin";
+    TokenType["CAPTURE_GROUP"] = "capture-group";
+    TokenType["CARRIAGE_RETURN"] = "carriage-return";
+    TokenType["CHARSET"] = "charset";
+    TokenType["CONTROL"] = "control";
+    TokenType["DIGIT"] = "digit";
+    TokenType["END"] = "end";
+    TokenType["ESCAPE"] = "escape";
+    TokenType["FORM_FEED"] = "form-feed";
+    TokenType["HEX"] = "hex";
+    TokenType["LINE_FEED"] = "line-feed";
+    TokenType["LITERAL"] = "literal";
+    TokenType["MATCH"] = "match";
+    TokenType["MODIFIED_GROUP"] = "modified-group";
+    TokenType["MODIFIER"] = "modifier";
+    TokenType["NAMED_BACK_REFERENCE"] = "named-back-reference";
+    TokenType["NAMED_GROUP"] = "named-group";
+    TokenType["NEGATIVE_LOOKAHEAD"] = "negative-lookahead";
+    TokenType["NEGATIVE_LOOKBEHIND"] = "negative-lookbehind";
+    TokenType["NON_CAPTURE_GROUP"] = "non-capture-group";
+    TokenType["NON_DIGIT"] = "non-digit";
+    TokenType["NON_UNICODE_PROPERTY"] = "non-unicode-property";
+    TokenType["NON_WHITE_SPACE"] = "non-white-space";
+    TokenType["NON_WORD"] = "non-word";
+    TokenType["NON_WORD_BOUNDARY"] = "non-word-boundary";
+    TokenType["NUL"] = "nul";
+    TokenType["OCTAL"] = "octal";
+    TokenType["PATTERN"] = "pattern";
+    TokenType["POSITIVE_LOOKAHEAD"] = "positive-lookahead";
+    TokenType["POSITIVE_LOOKBEHIND"] = "positive-lookbehind";
+    TokenType["QUANTIFIED"] = "quantified";
+    TokenType["QUANTIFIER"] = "quantifier";
+    TokenType["RANGE"] = "range";
+    TokenType["TAB"] = "tab";
+    TokenType["UNICODE"] = "unicode";
+    TokenType["UNICODE_PROPERTY"] = "unicode-property";
+    TokenType["UTF16"] = "utf-16";
+    TokenType["VERTICAL_TAB"] = "vertical-tab";
+    TokenType["WHITE_SPACE"] = "white-space";
+    TokenType["WORD"] = "word";
+    TokenType["WORD_BOUNDARY"] = "word-boundary";
+})(TokenType || (exports.TokenType = TokenType = {}));
+var Flavor;
+(function (Flavor) {
+    Flavor["ES2018"] = "es2018";
+})(Flavor || (exports.Flavor = Flavor = {}));