@prostojs/rewrite 0.0.4 → 0.1.0

package/dist/rewrite.cjs.prod.js

@@ -1,848 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var parser = require('@prostojs/parser');
-var minimatch = require('minimatch');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
-    var n = Object.create(null);
-    if (e) {
-        for (var k in e) {
-            n[k] = e[k];
-        }
-    }
-    n["default"] = e;
-    return Object.freeze(n);
-}
-
-var minimatch__default = /*#__PURE__*/_interopDefaultLegacy(minimatch);
-
-const htmlVoidTags = [
-    'area',
-    'base',
-    'br',
-    'col',
-    'command',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'keygen',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
-];
-const htmlTextTags = [
-    'script',
-    'style',
-];
-
-async function readDir(dirPath) {
-    {
-        const path = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('path')); });
-        const fs = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('fs')); });
-        async function* getFiles(dir) {
-            const dirents = await fs.promises.readdir(dir, { withFileTypes: true });
-            for (const dirent of dirents) {
-                const res = path.resolve(dir, dirent.name);
-                if (dirent.isDirectory()) {
-                    yield* getFiles(res);
-                }
-                else {
-                    yield res;
-                }
-            }
-        }
-        return getFiles(dirPath);
-    }
-}
-async function readFile(filePath) {
-    {
-        const fs = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('fs')); });
-        return new Promise((resolve, reject) => {
-            fs.exists(filePath, (yes) => {
-                if (yes) {
-                    fs.readFile(filePath, (err, file) => {
-                        if (err)
-                            return reject(err);
-                        resolve(file.toString());
-                    });
-                }
-                else {
-                    reject('File ' + filePath + ' does not exist.');
-                }
-            });
-        });
-    }
-}
-async function writeFile(targetPath, data) {
-    {
-        const path = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('path')); });
-        const fs = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('fs')); });
-        const dirname = path.dirname(targetPath);
-        await fs.promises.mkdir(dirname, { recursive: true });
-        await fs.promises.writeFile(targetPath, data);
-        return;
-    }
-}
-async function copyFile(filePath, targetPath) {
-    {
-        if (filePath === targetPath)
-            return;
-        const path = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('path')); });
-        const fs = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('fs')); });
-        const dirname = path.dirname(targetPath);
-        await fs.promises.mkdir(dirname, { recursive: true });
-        await fs.promises.copyFile(filePath, targetPath);
-        return;
-    }
-}
-async function pathResolve(p) {
-    {
-        const path = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('path')); });
-        return path.resolve(p);
-    }
-}
-async function pathJoin(...parts) {
-    {
-        const path = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('path')); });
-        return path.join(...parts);
-    }
-}
-
-const stringNodeOptions = {
-    label: '',
-    icon: '"',
-    tokens: [/(?<quote>["'`])/, ({ customData }) => customData.quote || ''],
-    backSlash: '-ignore',
-};
-const stringNode = new parser.BasicNode(stringNodeOptions);
-function stringExpressionNodeFactory(interpolationDelimiters) {
-    return new parser.BasicNode({
-        label: 'string',
-        icon: '≈',
-        tokens: [interpolationDelimiters[0], interpolationDelimiters[1]],
-        tokenOE: 'omit-omit',
-    })
-        .addAbsorbs(stringNode, 'join')
-        .mapContent('expression', 'join-clear')
-        .onPop(({ parserContext, customData: { expression } }) => {
-        try {
-            new Function(expression);
-        }
-        catch (e) {
-            parserContext.panic('Invalid expression: ' + e.message, expression.length + interpolationDelimiters[0].length + interpolationDelimiters[1].length);
-        }
-    })
-        .initCustomData(() => ({
-        expression: '',
-        code: ({ customData }, level = 0) => ' '.repeat(level * 2) + `__ += ${customData.expression.trim()}\n`,
-    }));
-}
-
-function escapeRegex(s) {
-    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-}
-function debug(message) {
-    console.log('' + '' + '' + '[rewrite] DEBUG: ' + message + '');
-}
-
-function genSafeFunc(code) {
-    try {
-        return new Function('__ctx__', 'process', 'window', 'global', 'require', code);
-    }
-    catch (e) {
-        console.error(e.message);
-        console.error(e.stack);
-        throw e;
-    }
-}
-function escapeString(s) { return s.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\n/g, '\\n').replace(/\$/g, '\\$'); }
-function pushString(s) {
-    return `__ += \`${escapeString(s)}\`\n`;
-}
-function renderCode(context, level = 1) {
-    let s = '';
-    let result = '';
-    function renderS() {
-        if (s) {
-            result += indent + pushString(s);
-            s = '';
-        }
-    }
-    const indent = ' '.repeat(level * 2);
-    context.content.forEach(c => {
-        if (typeof c === 'string') {
-            s += c;
-        }
-        else {
-            renderS();
-            const data = c.getCustomData();
-            if (data.openCode) {
-                result += indent + data.openCode;
-            }
-            if (data.code) {
-                result += data.code(c, level);
-            }
-            result += renderCode(c, level + (data.openCode ? 1 : 0));
-            if (data.closeCode) {
-                result += indent + data.closeCode;
-            }
-        }
-    });
-    renderS();
-    return result;
-}
-function getRewriter(rootNode, debug$1 = false) {
-    function getCode(source) {
-        const result = rootNode.parse(source);
-        if (debug$1) {
-            debug('Parsed tree view:\n' + result.toTree());
-        }
-        return 'let __ = \'\'\n' +
-            'let __v = \'\'\n' +
-            'with (__ctx__) {\n' +
-            renderCode(result) +
-            '}\n' +
-            'return __';
-    }
-    function getFunc(source) {
-        const code = getCode(source);
-        const func = genSafeFunc(code);
-        return (context) => {
-            try {
-                return func(context);
-            }
-            catch (e) {
-                throwErrorFromFunction(e, code);
-            }
-        };
-    }
-    function print(source) {
-        return console.log(rootNode.parse(source).toTree());
-    }
-    return {
-        genRewriteCode: getCode,
-        genRewriteFunction: getFunc,
-        printAsTree: print,
-        rewrite: (source, context) => getFunc(source)(context || {}),
-    };
-}
-function throwErrorFromFunction(e, code) {
-    var _a;
-    const relevantLine = ((_a = e.stack) === null || _a === void 0 ? void 0 : _a.split('\n')[1]) || '';
-    const regex = /<anonymous>:(\d+):(\d+)\)/g;
-    const match = regex.exec(relevantLine);
-    if (match) {
-        const row = parseInt(match[1], 10) - 2;
-        const col = parseInt(match[2], 10) - 1;
-        const output = parser.renderCodeFragment(code.split('\n'), {
-            row,
-            error: col,
-        });
-        console.error('' + e.message + '');
-        console.error(output);
-    }
-    throw e;
-}
-function getStringExpressionRewriter(interpolationDelimiters = ['{{', '}}']) {
-    const stringExpression = stringExpressionNodeFactory(interpolationDelimiters);
-    const rootNode = new parser.BasicNode({}).addRecognizes(stringExpression);
-    function getCode(source) {
-        const result = rootNode.parse(source);
-        return 'let __ = []\n' +
-            'with (__ctx__) {\n' +
-            result.content.map(c => `__.push(${typeof c === 'string'
-                ? `\`${escapeString(c)}\``
-                : `${c.getCustomData().expression}`})`).join('\n  ') +
-            '}\n' +
-            'return __.length === 1 ? __[0] : __.join(\'\')';
-    }
-    function getFunc(source) {
-        const code = getCode(source);
-        const func = genSafeFunc(code);
-        return (context) => {
-            try {
-                return func(context);
-            }
-            catch (e) {
-                throwErrorFromFunction(e, code);
-            }
-        };
-    }
-    function print(source) {
-        return console.log(rootNode.parse(source).toTree());
-    }
-    return {
-        genRewriteCode: getCode,
-        genRewriteFunction: getFunc,
-        printAsTree: print,
-        rewrite: (source, context) => getFunc(source)(context || {}),
-    };
-}
-
-const docTypeNodeOptions = {
-    label: 'Document Type',
-    tokens: ['<!DOCTYPE ', '>'],
-};
-const cDataNodeOptions = {
-    icon: '<![CDATA[',
-    tokens: ['<![CDATA[', ']]>'],
-};
-const commentNodeOptions = {
-    label: 'comment',
-    icon: '“',
-    tokens: ['<!--', '-->'],
-};
-const valueNodeOptions = {
-    label: 'value',
-    icon: '=',
-    tokens: [/=(?<quote>["'`])/, ({ customData }) => customData.quote || ''],
-    backSlash: '-ignore',
-    tokenOE: 'omit-omit',
-};
-const valueNode = new parser.BasicNode(valueNodeOptions);
-const unquotedValueNodeOptions = {
-    label: 'value',
-    icon: '=',
-    tokens: [/=(?<content>\w+)/, /[\s\/\>]/],
-    tokenOE: 'omit-eject',
-};
-const unquotedValueNode = new parser.BasicNode(unquotedValueNodeOptions);
-const innerNodeOptions = {
-    label: 'inner',
-    tokens: ['>', '</'],
-    tokenOE: '-eject',
-};
-const htmlBlockTypes = [
-    {
-        key: 'for',
-        exprRequired: true,
-        compatible: ['if'],
-        opening: true,
-        renderOpen: (v) => `for (${v || ''}) {\n`,
-    },
-    {
-        key: 'if',
-        exprRequired: true,
-        compatible: ['for'],
-        opening: true,
-        renderOpen: (v) => `if (${v || ''}) {\n`,
-    },
-    {
-        key: 'else-if',
-        closingKey: 'IF',
-        exprRequired: true,
-        opening: false,
-        overtakes: ['if', 'else-if'],
-        renderOpen: (v) => `} else if (${v || ''}) {\n`,
-    },
-    {
-        key: 'else',
-        closingKey: 'IF',
-        exprRequired: false,
-        opening: false,
-        overtakes: ['if', 'else-if'],
-        renderOpen: () => '} else {\n',
-    },
-];
-const htmlBlockTypesO = {};
-htmlBlockTypes.forEach(b => htmlBlockTypesO[b.key] = b);
-const getHtmlParser = (opts, recognizeTextDirective = false) => {
-    const rootNode = new parser.BasicNode({ icon: 'Html Mode' });
-    const docTypeNode = new parser.BasicNode(docTypeNodeOptions);
-    const cDataNode = new parser.BasicNode(cDataNodeOptions);
-    const commentNode = new parser.BasicNode(commentNodeOptions);
-    const innerNode = new parser.BasicNode(innerNodeOptions);
-    const stringExpressionNode = stringExpressionNodeFactory(opts.exprDelimeters);
-    const attrNode = attributeNodeFactory();
-    const attrBlockOperationNode = attributeNodeFactory('↳', opts.blockOperation, 'block');
-    const attrExprNode = attributeNodeFactory('≈', opts.attrExpression, 'expr');
-    const attrNodes = [attrBlockOperationNode, attrExprNode, attrNode];
-    const textDirectiveNode = new parser.BasicNode({
-        icon: 'T',
-        tokens: [
-            new RegExp(`^\\s*(?:<!--)${escapeRegex(opts.directive)}\\s*text-mode-on\\s*-->\\s*$`, 'm'),
-            new RegExp(`^\\s*(?:<!--)${escapeRegex(opts.directive)}\\s*text-mode-off\\s*-->\\s*$`, 'm'),
-        ],
-        tokenOE: 'omit-omit',
-    })
-        .onMatch(({ parserContext }) => parserContext.jump())
-        .onPop(({ parserContext }) => parserContext.jump());
-    const tagNode = new parser.BasicNode({
-        tokens: [
-            /<(?<tag>[\w:\-\.]+)/,
-            ({ customData }) => {
-                if (customData.isVoid)
-                    return /\/?>\s*/;
-                if (customData.isText)
-                    return new RegExp(`\\s*<\\/(?<endTag>${escapeRegex(customData.tag)})\\s*>\\s*`);
-                return /(?:\/\>|\<\/(?<endTag>[\w:\-\.]+)\s*\>\s*)/;
-            },
-        ],
-    })
-        .onMatch(({ context, customData }) => {
-        context.icon = customData.tag,
-            customData.isVoid = opts.voidTags.includes(customData.tag);
-        customData.isText = opts.textTags.includes(customData.tag);
-        if (customData.isVoid) {
-            context.clearRecognizes(innerNode);
-        }
-        if (customData.isText && !recognizeTextDirective) {
-            context.addAbsorbs(innerNode, 'join');
-        }
-    })
-        .onBeforeChildParse((child, { customData }) => {
-        if (customData.isText && child.node === innerNode) {
-            child.clearRecognizes();
-            if (recognizeTextDirective) {
-                child.addRecognizes(textDirectiveNode);
-            }
-            child.removeOnAppendContent();
-            child.endsWith = {
-                token: new RegExp(`<\\/(?<endTag>${escapeRegex(customData.tag)})\\s*>`),
-                eject: true,
-            };
-        }
-    })
-        .onAfterChildParse((child, { context }) => {
-        if (child.node === innerNode) {
-            context.clearRecognizes();
-        }
-    })
-        .onPop(({ customData: { isVoid, tag, endTag, operations }, parserContext, customData, context }) => {
-        var _a, _b;
-        if (operations && operations.length) {
-            operations = operations.sort((a) => a.key === 'for' ? -1 : 1);
-            customData.operation = operations[0].key;
-            for (let i = 0; i < operations.length; i++) {
-                const { key, value } = operations[i];
-                const descr = htmlBlockTypesO[key];
-                if (!descr) {
-                    parserContext.panicBlock(`Unknown block operation "${key}".`, tag.length, tag.length + 1);
-                }
-                if (descr.exprRequired && !value) {
-                    parserContext.panicBlock(`Expression required for "${key}" operation.`, tag.length, tag.length + 1);
-                }
-                if (!descr.exprRequired && !!value) {
-                    parserContext.panicBlock(`Unexpected expression for "${key}" operation.`, tag.length, tag.length + 1);
-                }
-                if (descr.overtakes) {
-                    const prevNode = context.getPrevNode();
-                    const prevContext = context.getPrevContext();
-                    if (typeof prevNode === 'string' && prevNode.replace(/[\s\n\r]/g, '')) {
-                        parserContext.panicBlock(`Unexpected block operation "${descr.key}".`, tag.length, tag.length + 1);
-                    }
-                    if (!prevContext ||
-                        !descr.overtakes.includes(prevContext.getCustomData().operation)) {
-                        parserContext.panicBlock(`Unexpected block operation "${descr.key}".`, tag.length, tag.length + 1);
-                    }
-                    const prevData = prevContext.getCustomData();
-                    prevData.closeCode = '';
-                }
-            }
-            if (operations.length === 1) {
-                const descr = htmlBlockTypesO[operations[0].key];
-                customData.openCode = descr.renderOpen(operations[0].value);
-                customData.closeCode = '}\n';
-            }
-            else if (operations.length === 2) {
-                const descr1 = htmlBlockTypesO[operations[0].key];
-                const descr2 = htmlBlockTypesO[operations[1].key];
-                if (!((_a = descr1.compatible) === null || _a === void 0 ? void 0 : _a.includes(descr2.key)) || !((_b = descr2.compatible) === null || _b === void 0 ? void 0 : _b.includes(descr1.key))) {
-                    parserContext.panicBlock(`Block operation "${descr1.key}" is not compatible with "${descr2.key}".`, tag.length, tag.length + 1);
-                }
-                customData.openCode = descr1.renderOpen(operations[0].value) + descr2.renderOpen(operations[1].value);
-                customData.closeCode = '}\n}\n';
-            }
-            else {
-                parserContext.panicBlock(`Too many block operations "${operations.map(o => o.key).join(', ')}".`, tag.length, tag.length + 1);
-            }
-        }
-        if (!isVoid && typeof endTag === 'string' && tag !== endTag) {
-            parserContext.panicBlock(`Open tag <${tag}> and closing tag </${endTag}> must be equal.`, tag.length || 0, endTag.length + 1);
-        }
-    })
-        .addRecognizes(innerNode, ...attrNodes)
-        .addHoistChildren({
-        node: attrBlockOperationNode,
-        as: 'operations',
-        asArray: true,
-        deep: 1,
-        mapRule: 'customData',
-    });
-    if (recognizeTextDirective) {
-        rootNode.addRecognizes(textDirectiveNode);
-        innerNode.addRecognizes(textDirectiveNode);
-        cDataNode.addRecognizes(textDirectiveNode);
-    }
-    rootNode.addRecognizes(docTypeNode, commentNode, tagNode, stringExpressionNode);
-    innerNode.addRecognizes(commentNode, cDataNode, tagNode, stringExpressionNode);
-    commentNode.addRecognizes(stringExpressionNode);
-    cDataNode.addRecognizes(stringExpressionNode);
-    return {
-        rootNode,
-        innerNode,
-        commentNode,
-        cDataNode,
-        docTypeNode,
-        stringExpressionNode,
-        attrNode,
-        attrBlockOperationNode,
-        attrExprNode,
-        tagNode,
-        textDirectiveNode,
-    };
-};
-const getHtmlRewriter = (opts, debug = false) => {
-    return getRewriter(getHtmlParser(opts).rootNode, debug);
-};
-function attributeNodeFactory(icon = '=', prefix, type = 'plain') {
-    const attrNodeOptions = {
-        label: '',
-        icon,
-        tokens: [
-            prefix ? new RegExp(`${escapeRegex(prefix)}(?<key>[\\w:\\-\\.]+)`) : /(?<key>[\w:\-\.]+)/,
-            /[\s\n\/>]/,
-        ],
-        tokenOE: 'omit-eject',
-    };
-    const quoteEsc = {
-        '"': '&quot;',
-        '\'': '&apos;',
-    };
-    function escapeVal(value, quote) {
-        let v = '';
-        if (value) {
-            v += '=';
-            v += quote ? (quote + value.replace(new RegExp(quote, 'g'), quoteEsc[quote]) + quote) : value;
-        }
-        return v;
-    }
-    const children = [unquotedValueNode, valueNode];
-    const codeFuncs = {
-        plain: ({ customData: { key, value, quote } }, level = 0) => {
-            return ' '.repeat(level * 2) + pushString(key + escapeVal(value, quote));
-        },
-        block: () => '',
-        expr: ({ customData: { key, value, quote } }, level = 0) => {
-            const q = (quote || '');
-            const indent = ' '.repeat(level * 2);
-            let s = indent + '__v = ' + (value || '\'\'') + '\n';
-            s += indent + 'if (typeof __v === \'boolean\') {\n';
-            s += indent + `  if (__v) __ += \`${key}\`\n`;
-            s += indent + '} else {\n';
-            s += indent + `  __ += \`${key}=${q}` + '${' + ` (__v || '').replace(/${q}/g, '${quoteEsc[q]}') }${q}\`\n`;
-            s += indent + '}\n';
-            return s;
-        },
-    };
-    const attrNode = new parser.BasicNode(attrNodeOptions)
-        .addPopsAfterNode(...children)
-        .addHoistChildren({
-        node: valueNode,
-        as: 'quote',
-        deep: 1,
-        mapRule: 'customData.quote',
-    })
-        .onPop(({ parserContext, customData: { value, quote } }) => {
-        if (type === 'expr' && value) {
-            try {
-                new Function(value);
-            }
-            catch (e) {
-                parserContext.panic('Invalid expression: ' + e.message, value.length + 1);
-            }
-        }
-        if (type === 'expr' && !quote) {
-            parserContext.panic('Expression must be quoted.', (value === null || value === void 0 ? void 0 : value.length) || 1);
-        }
-    })
-        .addAbsorbs(children, 'join->value')
-        .initCustomData(() => ({
-        key: '',
-        code: codeFuncs[type],
-    }));
-    return attrNode;
-}
-
-const textBlockTypes = [
-    {
-        key: 'FOR',
-        exprRequired: true,
-        opening: true,
-        code: ({ customData }) => `for ${customData.expression} {\n`,
-    },
-    {
-        key: 'IF',
-        exprRequired: true,
-        opening: true,
-        code: ({ customData }) => `if ${customData.expression} {\n`,
-    },
-    {
-        key: 'ELSEIF',
-        closingKey: 'IF',
-        exprRequired: true,
-        opening: false,
-        overtakes: ['IF', 'ELSEIF'],
-        code: ({ customData }) => `} else if ${customData.expression} {\n`,
-    },
-    {
-        key: 'ELSE',
-        closingKey: 'IF',
-        exprRequired: false,
-        opening: false,
-        overtakes: ['IF', 'ELSEIF'],
-        code: () => '} else {\n',
-    },
-];
-const textBlockTypesO = {};
-textBlockTypes.forEach(b => textBlockTypesO[b.key] = b);
-const getTextParser = (opts, recognizeHtmlDirective = false) => {
-    const rootNode = new parser.BasicNode({ icon: 'Text Mode' });
-    const stringExpressionNode = stringExpressionNodeFactory(opts.exprDelimeters);
-    const blockOperationNode = new parser.BasicNode({
-        label: '',
-        icon: '↳',
-        tokens: [
-            new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.blockOperation)}\\s*(?<block>\\w+[^\\S\\r\\n]*\\w*)[^\\S\\r\\n]*(?<expression>\\(.*\\))?(?<rest>[^\\n]*)?$`, 'm'),
-            new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.blockOperation)}\\s*(?<endBlock>END[^\\S\\r\\n]*\\w*)[^\\S\\r\\n]*(?<endExpression>\\(.*\\))?(?<endRest>[^\\n]*)?$`, 'm'),
-        ],
-        tokenOE: 'omit-omit',
-    })
-        .onMatchStartToken(({ customData, parserContext, matched }) => {
-        const { block, expression, rest } = matched.groups;
-        const descr = textBlockTypesO[block.replace(/[\s\n]/g, '')];
-        if (!descr) {
-            parserContext.panic(`Unknown block operation "${block.trim()}".`, -matched[0].indexOf(block));
-        }
-        if (descr.exprRequired && !expression) {
-            parserContext.panic(`Expression required for "${block.trim()}" operation.`, -matched[0].length);
-        }
-        if (!descr.exprRequired && !!expression) {
-            parserContext.panic(`Unexpected expression for "${block.trim()}" operation.`, -matched[0].indexOf(expression));
-        }
-        if (rest) {
-            parserContext.panic(`Unexpected text "${rest}" in "${block.trim()}" operation.`, -matched[0].length + rest.length);
-        }
-        if (descr.opening) {
-            return true;
-        }
-        if (descr.overtakes && descr.overtakes.includes(customData.block)) {
-            parserContext.pop();
-            return true;
-        }
-        if (customData.block) {
-            parserContext.panic(`Unexpected block operation "${block.trim()}" after "${customData.block}" block.`);
-        }
-        else {
-            parserContext.panic(`Unexpected block operation "${block.trim()}".`);
-        }
-    })
-        .onMatch(({ customData, context, parserContext }) => {
-        customData.block = customData.block.replace(/[\s\n]/g, '');
-        customData.descr = textBlockTypesO[customData.block];
-        customData.openCode = customData.descr.code(context);
-        parserContext.jump();
-    })
-        .onPop(({ parserContext }) => parserContext.jump())
-        .onMatchEndToken(({ customData, matched, parserContext }) => {
-        const { endBlock } = matched.groups;
-        const endKey = 'END' + (customData.descr.closingKey || customData.descr.key);
-        if (endKey !== endBlock.replace(/[\s\n]/g, '')) {
-            parserContext.panic('Wrong closing block instruction ' + endBlock, matched[0].length);
-        }
-        customData.closeCode = '}\n';
-        return true;
-    })
-        .popsAtEOFSource(true);
-    const revealNode = new parser.BasicNode({
-        icon: ':',
-        tokens: [
-            new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.revealLine)}[^\\S\\r\\n]*`, 'm'),
-            /$/m,
-        ],
-        tokenOE: 'omit-',
-    })
-        .addRecognizes(stringExpressionNode)
-        .popsAtEOFSource(true);
-    const ignoreDirectiveNode = new parser.BasicNode({
-        icon: ':',
-        tokens: [
-            new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.directive)}\\s*ignore-next-line\\s*$`, 'm'),
-            /^[^\n]*$/m,
-        ],
-        tokenOE: 'omit-',
-    })
-        .popsAtEOFSource(true);
-    const htmlDirectiveNode = new parser.BasicNode({
-        icon: 'H',
-        tokens: [
-            new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.directive)}\\s*html-mode-on\\s*$`, 'm'),
-            new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.directive)}\\s*html-mode-off\\s*$`, 'm'),
-        ],
-        tokenOE: 'omit-omit',
-    })
-        .onMatch(({ parserContext }) => parserContext.jump())
-        .onPop(({ parserContext }) => parserContext.jump());
-    blockOperationNode.addRecognizes(ignoreDirectiveNode, blockOperationNode, revealNode, stringExpressionNode);
-    rootNode.addRecognizes(ignoreDirectiveNode, blockOperationNode, revealNode, stringExpressionNode);
-    if (recognizeHtmlDirective) {
-        rootNode.addRecognizes(htmlDirectiveNode);
-        blockOperationNode.addRecognizes(htmlDirectiveNode);
-    }
-    return {
-        stringExpressionNode,
-        revealNode,
-        ignoreDirectiveNode,
-        blockOperationNode,
-        rootNode,
-        htmlDirectiveNode,
-    };
-};
-const getTextRewriter = (opts, debug = false) => {
-    return getRewriter(getTextParser(opts).rootNode, debug);
-};
-
-const defaultDelimeters = ['{{', '}}'];
-class ProstoRewrite {
-    constructor(options) {
-        var _a, _b;
-        this.options = {
-            defaultMode: (options === null || options === void 0 ? void 0 : options.defaultMode) || 'auto',
-            debug: (options === null || options === void 0 ? void 0 : options.debug) || false,
-            htmlPattern: ((options === null || options === void 0 ? void 0 : options.htmlPattern) || ['*.{html,xhtml,xml,svg}']).map(p => new minimatch__default.Minimatch(p, { matchBase: true })) ,
-            textPattern: ((options === null || options === void 0 ? void 0 : options.textPattern) || [
-                '*.{js,jsx,ts,tsx,txt,json,yml,yaml,md,ini}',
-                'Dockerfile',
-                '*config',
-                '.gitignore',
-            ]).map(p => new minimatch__default.Minimatch(p, { matchBase: true })) ,
-            html: {
-                exprDelimeters: defaultDelimeters,
-                attrExpression: ':',
-                blockOperation: 'v-',
-                directive: '!@',
-                voidTags: ((_a = options === null || options === void 0 ? void 0 : options.html) === null || _a === void 0 ? void 0 : _a.voidTags) || htmlVoidTags,
-                textTags: ((_b = options === null || options === void 0 ? void 0 : options.html) === null || _b === void 0 ? void 0 : _b.textTags) || htmlTextTags,
-                ...options === null || options === void 0 ? void 0 : options.html,
-            },
-            text: {
-                exprDelimeters: defaultDelimeters,
-                blockOperation: '=',
-                revealLine: ':',
-                directive: '!@',
-                ...options === null || options === void 0 ? void 0 : options.text,
-            },
-        };
-    }
-    get mixedRewriter() {
-        const textNodes = getTextParser(this.options.text, true);
-        const htmlNodes = getHtmlParser(this.options.html, true);
-        textNodes.htmlDirectiveNode.addRecognizes(...htmlNodes.rootNode.recognizes);
-        htmlNodes.textDirectiveNode.addRecognizes(...textNodes.rootNode.recognizes);
-        return {
-            text: getRewriter(textNodes.rootNode, this.options.debug),
-            html: getRewriter(htmlNodes.rootNode, this.options.debug),
-        };
-    }
-    get textRewriter() {
-        return getTextRewriter(this.options.text, this.options.debug);
-    }
-    get htmlRewriter() {
-        return getHtmlRewriter(this.options.html, this.options.debug);
-    }
-    async rewriteFile(opts, context) {
-        const file = await readFile(opts.input);
-        const mode = this.determineMode(opts.mode || this.options.defaultMode, opts.input, file);
-        let output = file;
-        const modes = this.mixedRewriter;
-        if (mode) {
-            this.debug('Parsing file in ' + mode + ' mode. ' + '' + '' + opts.input);
-            output = modes[mode].rewrite(file, context);
-        }
-        else {
-            this.debug('File isn\'t recognized as text nor as html. ' + '' + '' + opts.input);
-        }
-        if (opts.output) {
-            if (mode) {
-                await writeFile(opts.output, output);
-                this.debug('File has been rewritten in ' + mode + ' mode. ' + '' + '' + opts.output);
-            }
-            else {
-                await copyFile(opts.input, opts.output);
-                this.debug('File rewriting was skipped. File copied. ' + '' + '' + opts.output);
-            }
-        }
-        return output;
-    }
-    async rewriteDir(opts, context) {
-        const files = await readDir(opts.baseDir);
-        const dirPath = await pathResolve(opts.baseDir);
-        const include = opts.include && opts.include.length ? opts.include.map(s => new minimatch__default.Minimatch(s, { matchBase: true })) : null;
-        const exclude = opts.exclude && opts.exclude.length ? opts.exclude.map(s => new minimatch__default.Minimatch(s, { matchBase: true })) : null;
-        for await (const filePath of files) {
-            let included = true;
-            let excluded = false;
-            if (include)
-                included = !!include.find(m => m.match(filePath));
-            if (exclude && included)
-                excluded = !!exclude.find(m => m.match(filePath));
-            if (!included || excluded)
-                continue;
-            const relativeFilePath = filePath.slice(dirPath.length);
-            let targetPath;
-            if (opts.output) {
-                targetPath = await pathJoin(opts.output, relativeFilePath);
-            }
-            const output = await this.rewriteFile({
-                mode: opts.mode,
-                input: filePath,
-                output: targetPath,
-            }, context);
-            if (opts.onFile) {
-                opts.onFile(filePath, output);
-            }
-        }
-    }
-    determineMode(mode, path, content) {
-        if (mode === 'text')
-            return 'text';
-        if (mode === 'html')
-            return 'html';
-        if (mode === 'auto') {
-            const isText = !!this.options.textPattern.find(m => m.match(path));
-            const isHtml = !!this.options.htmlPattern.find(m => m.match(path));
-            if (isText && isHtml) {
-                if (/^<!DOCTYPE\s/.test(content))
-                    return 'html';
-                if (/^<\?xml\s/.test(content))
-                    return 'html';
-                return 'text';
-            }
-            if (isText)
-                return 'text';
-            if (isHtml)
-                return 'html';
-        }
-    }
-    debug(message) {
-        if (!this.options.debug)
-            return;
-        debug(message);
-    }
-}
-
-exports.ProstoRewrite = ProstoRewrite;
-exports.genSafeFunc = genSafeFunc;
-exports.getRewriter = getRewriter;
-exports.getStringExpressionRewriter = getStringExpressionRewriter;
-exports.pushString = pushString;
-exports.renderCode = renderCode;