@prostojs/rewrite 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,3987 +1,853 @@
+import { Node, printTree, textContent } from "@prostojs/parser";
+import { Minimatch } from "minimatch";
+//#region src/constants.ts
 const htmlVoidTags = [
-    'area',
-    'base',
-    'br',
-    'col',
-    'command',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'keygen',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
+	"area",
+	"base",
+	"br",
+	"col",
+	"command",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"keygen",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
 ];
-const htmlTextTags = [
-    'script',
-    'style',
-];
-
-const errorMessage = 'Work with files supported only in NodeJS environment.';
+const htmlTextTags = ["script", "style"];
+//#endregion
+//#region src/files.ts
+const errorMessage = "Work with files supported only in NodeJS environment.";
+let _fs;
+let _path;
+async function getFs() {
+	if (!_fs) _fs = await import("fs");
+	return _fs;
+}
+async function getPath() {
+	if (!_path) _path = await import("path");
+	return _path;
+}
 async function readDir(dirPath) {
-    if (__NODE_JS__) {
-        const path = await import('path');
-        const fs = await import('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);
-    }
-    throw new Error(errorMessage);
+	if (__NODE_JS__) {
+		const path = await getPath();
+		const fs = await getFs();
+		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);
+	}
+	throw new Error(errorMessage);
 }
 async function readFile(filePath) {
-    if (__NODE_JS__) {
-        const fs = await import('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.');
-                }
-            });
-        });
-    }
-    throw new Error(errorMessage);
+	if (__NODE_JS__) {
+		const fs = await getFs();
+		try {
+			return (await fs.promises.readFile(filePath)).toString();
+		} catch {
+			throw new Error("File " + filePath + " does not exist.");
+		}
+	}
+	throw new Error(errorMessage);
 }
 async function writeFile(targetPath, data) {
-    if (__NODE_JS__) {
-        const path = await import('path');
-        const fs = await import('fs');
-        const dirname = path.dirname(targetPath);
-        await fs.promises.mkdir(dirname, { recursive: true });
-        await fs.promises.writeFile(targetPath, data);
-        return;
-    }
-    throw new Error(errorMessage);
+	if (__NODE_JS__) {
+		const path = await getPath();
+		const fs = await getFs();
+		const dirname = path.dirname(targetPath);
+		await fs.promises.mkdir(dirname, { recursive: true });
+		await fs.promises.writeFile(targetPath, data);
+		return;
+	}
+	throw new Error(errorMessage);
 }
 async function copyFile(filePath, targetPath) {
-    if (__NODE_JS__) {
-        if (filePath === targetPath)
-            return;
-        const path = await import('path');
-        const fs = await import('fs');
-        const dirname = path.dirname(targetPath);
-        await fs.promises.mkdir(dirname, { recursive: true });
-        await fs.promises.copyFile(filePath, targetPath);
-        return;
-    }
-    throw new Error(errorMessage);
+	if (__NODE_JS__) {
+		if (filePath === targetPath) return;
+		const path = await getPath();
+		const fs = await getFs();
+		const dirname = path.dirname(targetPath);
+		await fs.promises.mkdir(dirname, { recursive: true });
+		await fs.promises.copyFile(filePath, targetPath);
+		return;
+	}
+	throw new Error(errorMessage);
 }
 async function pathResolve(p) {
-    if (__NODE_JS__) {
-        const path = await import('path');
-        return path.resolve(p);
-    }
-    throw new Error(errorMessage);
+	if (__NODE_JS__) return (await getPath()).resolve(p);
+	throw new Error(errorMessage);
 }
 async function pathJoin(...parts) {
-    if (__NODE_JS__) {
-        const path = await import('path');
-        return path.join(...parts);
-    }
-    throw new Error(errorMessage);
-}
-
-const dim = '';
-const reset = '';
-class ProstoTree {
-    constructor(options) {
-        var _a, _b, _c, _d;
-        const label = (options === null || options === void 0 ? void 0 : options.label) || 'label';
-        const children = (options === null || options === void 0 ? void 0 : options.children) || 'children';
-        const branchWidth = typeof (options === null || options === void 0 ? void 0 : options.branchWidth) === 'number' ? options === null || options === void 0 ? void 0 : options.branchWidth : 2;
-        const hLine = (((_a = options === null || options === void 0 ? void 0 : options.branches) === null || _a === void 0 ? void 0 : _a.hLine) || '─').repeat(branchWidth - 1);
-        const branches = {
-            end: ((_b = options === null || options === void 0 ? void 0 : options.branches) === null || _b === void 0 ? void 0 : _b.end) || dim + '└',
-            middle: ((_c = options === null || options === void 0 ? void 0 : options.branches) === null || _c === void 0 ? void 0 : _c.middle) || dim + '├',
-            vLine: ((_d = options === null || options === void 0 ? void 0 : options.branches) === null || _d === void 0 ? void 0 : _d.vLine) || dim + '│',
-            hLine,
-        };
-        this.options = {
-            label: label,
-            children: children,
-            renderLabel: (options === null || options === void 0 ? void 0 : options.renderLabel) || (n => typeof n === 'string' ? n : n[label]),
-            branches,
-            branchWidth,
-        };
-    }
-    _render(root, opts) {
-        const { children, renderLabel } = this.options;
-        let s = `${renderLabel(root, '')}\n`;
-        const { end, middle, vLine, hLine } = this.options.branches;
-        const endBranch = end + hLine + reset + ' ';
-        const middleBranch = middle + hLine + reset + ' ';
-        const { branchWidth } = this.options;
-        if (root) {
-            treeNode(root);
-        }
-        function treeNode(node, behind = '', level = 1) {
-            const items = (node && node[children]);
-            const count = items && items.length || 0;
-            if (items) {
-                if ((opts === null || opts === void 0 ? void 0 : opts.level) && opts.level < level) {
-                    s += behind + endBranch + renderCollapsedChildren(items.length) + '\n';
-                }
-                else {
-                    let itemsToRender = items;
-                    const collapsedCount = Math.max(0, count - ((opts === null || opts === void 0 ? void 0 : opts.childrenLimit) || count));
-                    if ((opts === null || opts === void 0 ? void 0 : opts.childrenLimit) && count > opts.childrenLimit) {
-                        itemsToRender = opts.showLast ? items.slice(count - opts.childrenLimit) : items.slice(0, opts.childrenLimit);
-                    }
-                    if (collapsedCount && (opts === null || opts === void 0 ? void 0 : opts.showLast))
-                        s += behind + middleBranch + renderCollapsedChildren(collapsedCount) + '\n';
-                    itemsToRender.forEach((childNode, i) => {
-                        const last = i + 1 === count;
-                        const branch = last ? endBranch : middleBranch;
-                        const nextBehind = behind + (last ? ' ' : vLine) + ' '.repeat(branchWidth);
-                        s += behind + branch + renderLabel(childNode, nextBehind) + '\n';
-                        if (typeof childNode === 'object') {
-                            treeNode(childNode, nextBehind, level + 1);
-                        }
-                    });
-                    if (collapsedCount && !(opts === null || opts === void 0 ? void 0 : opts.showLast))
-                        s += behind + endBranch + renderCollapsedChildren(collapsedCount) + '\n';
-                }
-            }
-        }
-        return s;
-    }
-    render(root, opts) {
-        return this._render(root, opts);
-    }
-    print(root, opts) {
-        const s = this.render(root, opts);
-        console.log(s);
-        return s;
-    }
-}
-function renderCollapsedChildren(count) {
-    return dim + '+ ' + '' + count.toString() + ` item${count === 1 ? '' : 's'}` + reset;
-}
-
-function renderCodeFragment(lines, options) {
-    const row = (options.row || 1) - 1;
-    const rowEnd = options.rowEnd ? options.rowEnd - 1 : -1;
-    const limit = Math.min(options.limit || 6, lines.length);
-    const offset = Math.min(options.offset || 3, lines.length);
-    const error = options.error;
-    const errorEnd = options.errorEnd;
-    let output = '';
-    const delta = rowEnd - row;
-    const maxIndex = lines.length;
-    if (delta > limit) {
-        let longestLine = 0;
-        const newLimit = Math.floor(limit / 2);
-        for (let i = 0; i < newLimit + offset; i++) {
-            const index = row + i - offset;
-            const line = lines[index] || '';
-            longestLine = Math.max(line.length, longestLine);
-            output += renderLine(line, index < maxIndex ? index + 1 : '', index === row ? error : undefined, index === row || index === rowEnd ? 'bold' : '');
-        }
-        let output2 = '';
-        for (let i = newLimit + offset; i > 0; i--) {
-            const index = rowEnd - i + offset;
-            const line = lines[index] || '';
-            longestLine = Math.max(line.length, longestLine);
-            output2 += renderLine(line, index < maxIndex ? index + 1 : '', index === rowEnd ? errorEnd : undefined, index === row || index === rowEnd ? 'bold' : '');
-        }
-        output += renderLine('—'.repeat(longestLine), '———', undefined, 'dim') + output2;
-    }
-    else {
-        for (let i = 0; i < limit + offset; i++) {
-            const index = row + i - offset;
-            if (index <= lines.length + 1) {
-                const errorCol = index === row ? error : index === rowEnd ? errorEnd : undefined;
-                output += renderLine(lines[index], index < maxIndex ? index + 1 : '', errorCol, index === row || index === rowEnd ? 'bold' : '');
-            }
-        }
-    }
-    return output;
-}
-function lineStyles(s) {
-    return '' + (s || '')
-        .replace(/([a-z_]+)/ig, '' + '$1' + '\x1b[39;33m')
-        .replace(/([\=\.\/'"`\:\+]+)/ig, '' + '$1' + '');
-}
-function lineStylesError(s) {
-    return '' + (s || '') + '';
-}
-function renderLine(line, index, error, style = '') {
-    const st = (style === 'bold' ? '' : '') + (style === 'dim' ? '' : '');
-    if (typeof error === 'number') {
-        const errorLength = (/[\.-\s\(\)\*\/\+\{\}\[\]\?\'\"\`\<\>]/.exec(line.slice(error + 1)) || { index: line.length - error }).index + 1;
-        return renderLineNumber(index, true) +
-            st +
-            lineStyles(line.slice(0, error)) +
-            lineStylesError(line.slice(error, error + errorLength)) +
-            lineStyles(line.slice(error + errorLength)) +
-            renderLineNumber('', true) + ' '.repeat(error) + '' + '' + '~'.repeat(Math.max(1, errorLength));
-    }
-    return renderLineNumber(index, undefined, style === 'bold') + st + lineStyles(line);
-}
-function renderLineNumber(i, isError = false, bold = false) {
-    let s = '      ';
-    const sep = i === '———';
-    if (i && i > 0 || typeof i === 'string') {
-        s = '      ' + String(i);
-    }
-    s = s.slice(s.length - 5);
-    return '\n' + '' + (sep ? '' : '') +
-        (isError ? '' + '' : (bold ? '' : '')) +
-        s + (sep ? i : ' | ') + '';
-}
-
-function escapeRegex$1(s) {
-    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-}
-
-class ProstoParserNodeBase {
-    addRecognizes(...args) {
-        for (const node of args) {
-            if (!this.options.recognizes)
-                this.options.recognizes = [];
-            if (!this.options.recognizes.includes(node)) {
-                this.options.recognizes.push(node);
-            }
-        }
-        return this;
-    }
-    addAbsorbs(node, rule = 'append') {
-        this.options.absorbs = this.options.absorbs || {};
-        if (Array.isArray(node)) {
-            node.forEach(n => {
-                this.options.absorbs[n.id] = rule;
-                this.addRecognizes(n);
-            });
-        }
-        else {
-            this.options.absorbs[node.id] = rule;
-            this.addRecognizes(node);
-        }
-        return this;
-    }
-    addPopsAfterNode(...args) {
-        for (const node of args) {
-            if (!this.options.popsAfterNode)
-                this.options.popsAfterNode = [];
-            if (!this.options.popsAfterNode.includes(node)) {
-                this.options.popsAfterNode.push(node);
-            }
-        }
-        this.addRecognizes(...args);
-        return this;
-    }
-    addHoistChildren(...args) {
-        if (!this.options.hoistChildren)
-            this.options.hoistChildren = [];
-        this.options.hoistChildren.push(...args);
-        return this;
-    }
-    set icon(value) {
-        this.options.icon = value;
-    }
-    set label(value) {
-        this.options.label = value;
-    }
-    get startsWith() {
-        return this.options.startsWith;
-    }
-    set startsWith(value) {
-        this.options.startsWith = value;
-    }
-    get endsWith() {
-        return this.options.endsWith;
-    }
-    set endsWith(value) {
-        this.options.endsWith = value;
-    }
-    getPopsAtEOFSource() {
-        return this.options.popsAtEOFSource;
-    }
-    popsAtEOFSource(value) {
-        this.options.popsAtEOFSource = value;
-        return this;
-    }
-    get absorbs() {
-        return this.options.absorbs;
-    }
-    get badToken() {
-        return this.options.badToken;
-    }
-    set badToken(value) {
-        this.options.badToken = value;
-    }
-    get skipToken() {
-        return this.options.skipToken;
-    }
-    set skipToken(value) {
-        this.options.skipToken = value;
-    }
-    get recognizes() {
-        return this.options.recognizes || [];
-    }
-    set recognizes(value) {
-        this.options.recognizes = value;
-    }
-    get hoistChildren() {
-        return this.options.hoistChildren || [];
-    }
-    set hoistChildren(value) {
-        this.options.hoistChildren = value;
-    }
-    getMapContent() {
-        return this.options.mapContent;
-    }
-    mapContent(key, value = 'copy') {
-        this.options.mapContent = this.options.mapContent || {};
-        this.options.mapContent[key] = value;
-        return this;
-    }
-    onMatch(value) {
-        this.options.onMatch = value;
-        return this;
-    }
-    onAppendContent(value) {
-        this.options.onAppendContent = value;
-        return this;
-    }
-    onAfterChildParse(value) {
-        this.options.onAfterChildParse = value;
-        return this;
-    }
-    onBeforeChildParse(value) {
-        this.options.onBeforeChildParse = value;
-        return this;
-    }
-    onMatchStartToken(value) {
-        if (this.options.startsWith) {
-            this.options.startsWith.onMatchToken = value;
-        }
-        return this;
-    }
-    onMatchEndToken(value) {
-        if (this.options.endsWith) {
-            this.options.endsWith.onMatchToken = value;
-        }
-        return this;
-    }
-    initCustomData(value) {
-        this.options.initCustomData = value;
-        return this;
-    }
-    onPop(value) {
-        this.options.onPop = value;
-        return this;
-    }
-    get popsAfterNode() {
-        return this.options.popsAfterNode || [];
-    }
-    set popsAfterNode(nodes) {
-        this.options.popsAfterNode = nodes;
-    }
-    clearStartsWith() {
-        delete this.options.startsWith;
-        return this;
-    }
-    clearEndsWith() {
-        delete this.options.endsWith;
-        return this;
-    }
-    clearPopsAtEOFSource() {
-        delete this.options.popsAtEOFSource;
-        return this;
-    }
-    clearBadToken() {
-        delete this.options.badToken;
-        return this;
-    }
-    clearSkipToken() {
-        delete this.options.skipToken;
-        return this;
-    }
-    clearAbsorbs(node) {
-        if (this.options.absorbs) {
-            if (node && Array.isArray(node)) {
-                for (const n of node) {
-                    delete this.options.absorbs[n.id];
-                }
-            }
-            else if (node) {
-                delete this.options.absorbs[node.id];
-            }
-            else {
-                this.options.absorbs = {};
-            }
-        }
-        return this;
-    }
-    clearRecognizes(...args) {
-        var _a;
-        if (args.length) {
-            this.options.recognizes = (_a = this.options.recognizes) === null || _a === void 0 ? void 0 : _a.filter(n => !args.includes(n));
-        }
-        else {
-            this.options.recognizes = [];
-        }
-        return this;
-    }
-    clearHoistChildren() {
-        delete this.options.hoistChildren;
-        return this;
-    }
-    clearMapContent() {
-        delete this.options.mapContent;
-        return this;
-    }
-    removeOnPop() {
-        delete this.options.onPop;
-        return this;
-    }
-    removeOnMatch() {
-        delete this.options.onMatch;
-        return this;
-    }
-    removeOnAppendContent() {
-        delete this.options.onAppendContent;
-        return this;
-    }
-    removeOnBeforeChildParse() {
-        delete this.options.onBeforeChildParse;
-        return this;
-    }
-    removeOnAfterChildParse() {
-        delete this.options.onAfterChildParse;
-        return this;
-    }
-    fireNodeMatched(matched, cbData) {
-        return this.options.startsWith ? this.fireMatched(this.options.startsWith, matched, cbData) : { confirmed: true };
-    }
-    fireNodeEndMatched(matched, cbData) {
-        return this.options.endsWith ? this.fireMatched(this.options.endsWith, matched, cbData) : { confirmed: true };
-    }
-    fireMatched(descr, matched, cbData) {
-        const { omit, eject, onMatchToken } = descr;
-        let cbResult = true;
-        if (onMatchToken) {
-            cbResult = onMatchToken({
-                ...cbData,
-                matched,
-            });
-        }
-        const cbOmit = typeof cbResult === 'object' ? cbResult.omit : undefined;
-        const cbEject = typeof cbResult === 'object' ? cbResult.eject : undefined;
-        return {
-            omit: cbOmit !== undefined ? cbOmit : omit,
-            eject: cbEject !== undefined ? cbEject : eject,
-            confirmed: cbResult !== false,
-        };
-    }
-    getStartTokenRg() {
-        return this.getRgOutOfTokenDescriptor(this.options.startsWith);
-    }
-    getEndTokenRg() {
-        return this.getRgOutOfTokenDescriptor(this.options.endsWith);
-    }
-    getConstraintTokens() {
-        return {
-            skip: this.getRgOutOfTokenDescriptor(this.options.skipToken ? { token: this.options.skipToken } : undefined) || undefined,
-            bad: this.getRgOutOfTokenDescriptor(this.options.badToken ? { token: this.options.badToken } : undefined) || undefined,
-        };
-    }
-    getRgOutOfTokenDescriptor(descr) {
-        if (descr) {
-            const prefix = descr.ignoreBackSlashed ? /(?<=(?:^|[^\\])(?:\\\\)*)/.source : '';
-            let token;
-            if (typeof descr.token === 'function') {
-                token = descr.token(this);
-            }
-            else {
-                token = descr.token;
-            }
-            if (token instanceof RegExp) {
-                return new RegExp(prefix + token.source, token.flags);
-            }
-            else {
-                return new RegExp(`${prefix}(?:${[token].flat().map(t => escapeRegex$1(t)).join('|')})`);
-            }
-        }
-    }
-}
-
-class ProstoHoistManager {
-    constructor() {
-        this.data = {};
-    }
-    addHoistOptions(ctx) {
-        if (ctx.hoistChildren) {
-            ctx.hoistChildren.forEach(options => {
-                const nodeId = typeof options.node === 'object' ? options.node.id : options.node;
-                const hoist = this.data[nodeId] = (this.data[nodeId] || {});
-                if (hoist) {
-                    hoist[ctx.index] = {
-                        options,
-                        context: ctx,
-                    };
-                }
-            });
-        }
-    }
-    removeHoistOptions(ctx) {
-        if (ctx.hoistChildren) {
-            ctx.hoistChildren.forEach(options => {
-                const nodeId = typeof options.node === 'object' ? options.node.id : options.node;
-                const hoist = this.data[nodeId];
-                if (hoist) {
-                    delete hoist[ctx.index];
-                }
-            });
-        }
-    }
-    processHoistOptions(ctx) {
-        const id = ctx.node.id;
-        const hoist = this.data[id];
-        if (hoist) {
-            Object.keys(hoist).map(i => hoist[i]).forEach(({ options, context }) => {
-                const customData = context.getCustomData();
-                if (options.deep === true || Number(options.deep) >= (ctx.level - context.level)) {
-                    if (options.asArray) {
-                        const hoisted = customData[options.as] = (customData[options.as] || []);
-                        if (!Array.isArray(hoisted)) {
-                            if (!options.onConflict || options.onConflict === 'error') {
-                                throw new Error(`Can not hoist "${ctx.node.name}" to "${context.node.name}" as "${options.as}". "${options.as}" already exists and it is not an Array Type.`);
-                            }
-                            else if (options.onConflict === 'overwrite') {
-                                customData[options.as] = [doTheMapRule(options, ctx)];
-                            }
-                            else if (options.onConflict !== 'ignore') {
-                                throw new Error(`Unsupported hoisting option onConflict "${options.onConflict}"`);
-                            }
-                        }
-                        else {
-                            hoisted.push(doTheMapRule(options, ctx));
-                        }
-                    }
-                    else {
-                        if (customData[options.as]) {
-                            if (!options.onConflict || options.onConflict === 'error') {
-                                throw new Error(`Can not hoist multiple "${ctx.node.name}" to "${context.node.name}" as "${options.as}". "${options.as}" already exists.`);
-                            }
-                            else if (options.onConflict === 'overwrite') {
-                                customData[options.as] = doTheMapRule(options, ctx);
-                            }
-                            else if (options.onConflict !== 'ignore') {
-                                throw new Error(`Unsupported hoisting option onConflict "${options.onConflict}"`);
-                            }
-                        }
-                        else {
-                            customData[options.as] = doTheMapRule(options, ctx);
-                        }
-                    }
-                    if (options.removeChildFromContent) {
-                        context.content = context.content.filter(c => c !== ctx);
-                    }
-                }
-            });
-        }
-        function doTheMapRule(options, ctx) {
-            var _a;
-            if (typeof options.mapRule === 'function') {
-                return options.mapRule(ctx);
-            }
-            if (options.mapRule === 'content.join') {
-                return ctx.content.join('');
-            }
-            if ((_a = options.mapRule) === null || _a === void 0 ? void 0 : _a.startsWith('customData')) {
-                const key = options.mapRule.slice(11);
-                if (key) {
-                    return ctx.getCustomData()[key];
-                }
-                else {
-                    return ctx.getCustomData();
-                }
-            }
-            return ctx;
-        }
-    }
-}
-
-const banner = '' + '[parser]' + '';
-class ProstoParserContext {
-    constructor(root) {
-        this.root = root;
-        this.nodes = {};
-        this.pos = 0;
-        this.index = 0;
-        this.behind = '';
-        this.here = '';
-        this.src = '';
-        this.stack = [];
-        this.l = 0;
-        this.hoistManager = new ProstoHoistManager();
-        this.context = root;
-    }
-    parse(src) {
-        this.src = src,
-            this.here = src,
-            this.l = src.length;
-        const cache = {};
-        while (this.pos < this.l) {
-            const searchTokens = this.context.getSearchTokens();
-            let closestIndex = Number.MAX_SAFE_INTEGER;
-            let closestToken;
-            let matched;
-            for (const t of searchTokens) {
-                const key = t.g.source;
-                t.g.lastIndex = this.pos;
-                let cached = cache[key];
-                if (cached === null)
-                    continue;
-                if (cached && cached.index < this.pos) {
-                    cached = null;
-                    delete cache[key];
-                }
-                if (!cached) {
-                    cached = t.g.exec(this.src);
-                    if (cached || (this.pos === 0 && !cached)) {
-                        cache[key] = cached;
-                    }
-                }
-                if (cached && cached.index < closestIndex) {
-                    closestIndex = cached.index;
-                    matched = cached;
-                    closestToken = t;
-                    if (closestIndex === this.pos)
-                        break;
-                }
-            }
-            if (closestToken && matched) {
-                const toAppend = this.src.slice(this.pos, closestIndex);
-                if (toAppend) {
-                    this.context.appendContent(toAppend);
-                    this.jump(toAppend.length);
-                }
-                const matchedToken = matched[0];
-                if (closestToken.node) {
-                    const { omit, eject, confirmed } = closestToken.node.fireNodeMatched(matched, this.getCallbackData(matched));
-                    if (!confirmed)
-                        continue;
-                    let toAppend = '';
-                    if (eject) {
-                        this.context.appendContent(matchedToken);
-                    }
-                    else if (!omit) {
-                        toAppend = matchedToken;
-                    }
-                    this.jump(matchedToken.length);
-                    this.pushNewContext(closestToken.node, toAppend ? [toAppend] : []);
-                    this.context.fireOnMatch(matched);
-                    continue;
-                }
-                else {
-                    const { omit, eject, confirmed } = this.context.fireNodeEndMatched(matched, this.getCallbackData(matched));
-                    if (!confirmed)
-                        continue;
-                    if (!eject && !omit) {
-                        this.context.appendContent(matchedToken);
-                    }
-                    if (!eject) {
-                        this.jump(matchedToken.length);
-                    }
-                    this.context.mapNamedGroups(matched);
-                    this.pop();
-                    continue;
-                }
-            }
-            else {
-                this.context.appendContent(this.here);
-                this.jump(this.here.length);
-            }
-        }
-        if (this.context !== this.root) {
-            while (this.context.getPopsAtEOFSource() && this.stack.length > 0)
-                this.pop();
-        }
-        if (this.context !== this.root) {
-            this.panicBlock(`Unexpected end of the source string while parsing "${this.context.node.name}" (${this.context.index}) node.`);
-        }
-        return this.root;
-    }
-    pop() {
-        const parentContext = this.stack.pop();
-        this.context.fireOnPop();
-        if (parentContext) {
-            parentContext.fireAfterChildParse(this.context);
-            parentContext.fireAbsorb(this.context);
-            this.context.cleanup();
-            const node = this.context.node;
-            this.context = parentContext;
-            if (parentContext.popsAfterNode.includes(node)) {
-                this.pop();
-            }
-        }
-        else {
-            this.context.cleanup();
-        }
-    }
-    pushNewContext(newNode, content) {
-        this.index++;
-        const ctx = newNode.createContext(this.index, this.stack.length + 1, this);
-        ctx.content = content;
-        this.context.fireBeforeChildParse(ctx);
-        this.context.pushChild(ctx);
-        this.stack.push(this.context);
-        this.hoistManager.addHoistOptions(this.context);
-        this.context = ctx;
-        return ctx;
-    }
-    fromStack(depth = 0) {
-        return this.stack[this.stack.length - depth - 1];
-    }
-    jump(n = 1) {
-        this.pos += n;
-        this.behind = this.src.slice(0, this.pos);
-        this.here = this.src.slice(this.pos, this.l);
-        return this.pos;
-    }
-    getCallbackData(matched) {
-        return {
-            parserContext: this,
-            context: this.context,
-            matched,
-            customData: this.context.getCustomData(),
-        };
-    }
-    getPosition(offset = 0) {
-        var _a;
-        const past = this.src.slice(0, this.pos + offset).split('\n');
-        const row = past.length;
-        const col = ((_a = past.pop()) === null || _a === void 0 ? void 0 : _a.length) || 0;
-        return {
-            row, col, pos: this.pos,
-        };
-    }
-    panic(message, errorBackOffset = 0) {
-        if (this.pos > 0) {
-            const { row, col } = this.getPosition(-errorBackOffset);
-            console.error(banner + '', message, '');
-            console.log(this.context.toTree({ childrenLimit: 5, showLast: true, level: 1 }));
-            console.error(renderCodeFragment(this.src.split('\n'), {
-                row: row,
-                error: col,
-            }));
-        }
-        throw new Error(message);
-    }
-    panicBlock(message, topBackOffset = 0, bottomBackOffset = 0) {
-        if (this.pos > 0) {
-            const { row, col } = this.getPosition(-bottomBackOffset);
-            console.error(banner + '', message, '');
-            console.log(this.context.toTree({ childrenLimit: 13, showLast: true, level: 12 }));
-            console.error(renderCodeFragment(this.src.split('\n'), {
-                row: this.context.startPos.row,
-                error: this.context.startPos.col - topBackOffset,
-                rowEnd: row,
-                errorEnd: col,
-            }));
-        }
-        throw new Error(message);
-    }
-}
-
-const styles = {
-    banner: (s) => '' + s + '',
-    text: (s) => '' + s + '',
-    valuesDim: (s) => '' + '' + s + '' + '',
-    boolean: (s) => '' + s + '',
-    booleanDim: (s) => '' + '' + s + '' + '',
-    underscore: (s) => '' + s + '',
-    values: (s) => (typeof s === 'string' ? '' : '') + cut(s.toString(), 30) + '',
-    nodeDim: (s) => '' + '' + s + '' + '',
-    node: (s) => '' + s + '',
-};
-const stringOutputLimit = 70;
-const parserTree = new ProstoTree({
-    children: 'content',
-    renderLabel: (context) => {
-        if (typeof context === 'string') {
-            return styles.text('«' + cut(context, stringOutputLimit) + '' + '»');
-        }
-        else if (typeof context === 'object' && context instanceof ProstoParserNodeContext) {
-            let keys = '';
-            const data = context.getCustomData();
-            Object.keys(data).forEach(key => {
-                const val = data[key];
-                if (typeof val === 'string' || typeof val === 'number') {
-                    keys += ' ' + styles.valuesDim(key + '(') + styles.values(val) + styles.valuesDim(')');
-                }
-                else if (Array.isArray(val)) {
-                    keys += ' ' + styles.valuesDim(key + `[${val.length}]`);
-                }
-                else if (typeof val === 'object') {
-                    keys += ' ' + styles.valuesDim(`{ ${key} }`);
-                }
-                else if (typeof val === 'boolean' && val) {
-                    const st = key ? styles.boolean : styles.booleanDim;
-                    keys += ' ' + `${styles.underscore(st(key))}${st(val ? '☑' : '☐')}`;
-                }
-            });
-            return styles.node(context.icon + (context.label ? ' ' : '')) + styles.nodeDim(context.label) + keys;
-        }
-        return '';
-    },
-});
-function cut(s, n) {
-    const c = s.replace(/\n/g, '\\n');
-    if (c.length <= n)
-        return c;
-    return c.slice(0, n) + '' + '…';
-}
-
-class ProstoParserNodeContext extends ProstoParserNodeBase {
-    constructor(_node, index, level, parserContext) {
-        super();
-        this._node = _node;
-        this.index = index;
-        this.level = level;
-        this.content = [];
-        this._customData = {};
-        this.hasNodes = [];
-        this.count = {};
-        this.mapContentRules = {
-            'first': (content) => content[0],
-            'shift': (content) => content.shift(),
-            'pop': (content) => content.pop(),
-            'last': (content) => content[content.length - 1],
-            'join': (content) => content.join(''),
-            'join-clear': (content) => content.splice(0).join(''),
-            'copy': (content) => content,
-        };
-        this.options = _node.getOptions();
-        if (this.options.initCustomData) {
-            this._customData = this.options.initCustomData();
-        }
-        this._label = this.options.label || '';
-        this._icon = this.options.icon || '◦';
-        this.parserContext = parserContext || new ProstoParserContext(this);
-        if (parserContext) {
-            this.parent = parserContext.context || parserContext.root;
-        }
-        this.startPos = this.parserContext.getPosition();
-        this.endPos = this.parserContext.getPosition();
-    }
-    getOptions() {
-        return this.options;
-    }
-    extractCustomDataTree() {
-        let content = this.content;
-        if (this.contentCopiedTo) {
-            content = this.customData[this.contentCopiedTo];
-        }
-        if (Array.isArray(content)) {
-            return content.map(c => {
-                if (typeof c === 'string') {
-                    return c;
-                }
-                else {
-                    return extract(c);
-                }
-            });
-        }
-        else {
-            const c = content;
-            if (c instanceof ProstoParserNodeContext) {
-                return extract(c);
-            }
-            else {
-                return content;
-            }
-        }
-        function extract(c) {
-            const cd = { ...c.getCustomData() };
-            if (c.contentCopiedTo) {
-                cd[c.contentCopiedTo] = c.extractCustomDataTree();
-            }
-            return cd;
-        }
-    }
-    getPrevNode(n = 1) {
-        if (this.parent) {
-            const index = this.parent.content.findIndex(n => n === this) - n;
-            if (index >= 0)
-                return this.parent.content[index];
-        }
-    }
-    getPrevContext(n = 1) {
-        if (this.parent) {
-            const contexts = this.parent.content.filter(n => n instanceof ProstoParserNodeContext);
-            const index = contexts.findIndex(n => n === this) - n;
-            if (index >= 0)
-                return contexts[index];
-        }
-    }
-    set icon(value) {
-        this._icon = value;
-    }
-    get icon() {
-        return this._icon;
-    }
-    set label(value) {
-        this._label = value;
-    }
-    get label() {
-        return this._label;
-    }
-    getCustomData() {
-        return this._customData;
-    }
-    get customData() {
-        return this._customData;
-    }
-    get nodeId() {
-        return this._node.id;
-    }
-    get node() {
-        return this._node;
-    }
-    toTree(options) {
-        return parserTree.render(this, options);
-    }
-    getSearchTokens() {
-        var _a;
-        const rg = this.getEndTokenRg();
-        const tokens = rg ? [{
-                rg,
-                y: addFlag(rg, 'y'),
-                g: addFlag(rg, 'g'),
-            }] : [];
-        (_a = this.options.recognizes) === null || _a === void 0 ? void 0 : _a.forEach(node => {
-            const rg = node.getStartTokenRg();
-            if (rg) {
-                tokens.push({
-                    rg,
-                    y: addFlag(rg, 'y'),
-                    g: addFlag(rg, 'g'),
-                    node,
-                });
-            }
-        });
-        function addFlag(rg, f) {
-            return new RegExp(rg.source, rg.flags + f);
-        }
-        return tokens;
-    }
-    appendContent(input) {
-        let s = input;
-        this.endPos = this.parserContext.getPosition();
-        let { skip, bad } = this.getConstraintTokens();
-        skip = skip ? new RegExp(skip.source, skip.flags + 'g') : skip;
-        bad = bad ? new RegExp(bad.source, bad.flags + 'g') : bad;
-        if (skip) {
-            s = s.replace(skip, '');
-        }
-        if (bad) {
-            const m = bad.exec(s);
-            if (m) {
-                this.parserContext.jump(m.index);
-                this.parserContext.panic(`The token "${m[0].replace(/"/g, '\\"')}" is not allowed in "${this.node.name}".`);
-            }
-        }
-        s = this.fireOnAppendContent(s);
-        if (s) {
-            this.content.push(s);
-        }
-    }
-    cleanup() {
-        this.options = null;
-    }
-    pushChild(child) {
-        const absorbRule = this.options.absorbs && this.options.absorbs[child.node.id];
-        if (!absorbRule) {
-            this.content.push(child);
-        }
-    }
-    fireAbsorb(child) {
-        const absorbRule = this.options.absorbs && this.options.absorbs[child.node.id];
-        if (absorbRule) {
-            switch (absorbRule) {
-                case 'append':
-                    this.content.push(...child.content);
-                    break;
-                case 'join':
-                    this.appendContent(child.content.join(''));
-                    break;
-                default:
-                    const [action, target] = absorbRule.split('->');
-                    const cd = this.getCustomData();
-                    if (action === 'copy') {
-                        cd[target] = child.content;
-                    }
-                    else if (action === 'join') {
-                        cd[target] = child.content.join('');
-                    }
-                    else {
-                        this.parserContext.panic(`Absorb action "${action}" is not supported.`);
-                    }
-            }
-        }
-    }
-    has(node) {
-        return this.hasNodes.includes(node);
-    }
-    countOf(node) {
-        return this.count[node.id] || 0;
-    }
-    mapNamedGroups(matched) {
-        if (matched.groups) {
-            const cd = this.getCustomData();
-            for (const [key, value] of Object.entries(matched.groups)) {
-                if (key === 'content') {
-                    this.appendContent(value);
-                }
-                else {
-                    cd[key] = value;
-                }
-            }
-        }
-    }
-    fireOnPop() {
-        this.endPos = this.parserContext.getPosition();
-        this.processMappings();
-        const data = this.parserContext.getCallbackData();
-        this.node.beforeOnPop(data);
-        if (this.options.onPop) {
-            this.options.onPop(data);
-        }
-    }
-    fireOnMatch(matched) {
-        this.mapNamedGroups(matched);
-        const data = this.parserContext.getCallbackData(matched);
-        this.node.beforeOnMatch(data);
-        if (this.options.onMatch) {
-            return this.options.onMatch(data);
-        }
-    }
-    fireBeforeChildParse(child) {
-        const data = this.parserContext.getCallbackData();
-        this.node.beforeOnBeforeChildParse(child, data);
-        if (this.options.onBeforeChildParse) {
-            return this.options.onBeforeChildParse(child, data);
-        }
-    }
-    fireAfterChildParse(child) {
-        if (!this.hasNodes.includes(child.node)) {
-            this.hasNodes.push(child.node);
-        }
-        this.count[child.node.id] = this.count[child.node.id] || 0;
-        this.count[child.node.id]++;
-        const data = this.parserContext.getCallbackData();
-        this.node.beforeOnAfterChildParse(child, data);
-        if (this.options.onAfterChildParse) {
-            return this.options.onAfterChildParse(child, data);
-        }
-    }
-    fireOnAppendContent(s) {
-        let _s = s;
-        const data = this.parserContext.getCallbackData();
-        _s = this.node.beforeOnAppendContent(_s, data);
-        if (this.options.onAppendContent) {
-            _s = this.options.onAppendContent(_s, data);
-        }
-        return _s;
-    }
-    processMappings() {
-        this.parserContext.hoistManager.removeHoistOptions(this);
-        this.parserContext.hoistManager.processHoistOptions(this);
-        this.processMapContent();
-    }
-    processMapContent() {
-        const targetNodeOptions = this.options;
-        if (targetNodeOptions.mapContent) {
-            Object.keys(targetNodeOptions.mapContent).forEach((key) => {
-                const keyOfT = key;
-                if (targetNodeOptions.mapContent && targetNodeOptions.mapContent[keyOfT]) {
-                    const mapRule = targetNodeOptions.mapContent[keyOfT];
-                    if (typeof mapRule === 'function') {
-                        this._customData[keyOfT] = mapRule(this.content);
-                    }
-                    else {
-                        const ruleKey = mapRule;
-                        if (ruleKey === 'copy')
-                            this.contentCopiedTo = keyOfT;
-                        this._customData[keyOfT] = this.mapContentRules[ruleKey](this.content);
-                    }
-                    if (!this.contentCopiedTo && (typeof mapRule === 'function' || ['first', 'shift', 'pop', 'last'].includes(mapRule))) {
-                        this.contentCopiedTo = keyOfT;
-                    }
-                }
-            });
-        }
-    }
-}
-
-let idCounter = 0;
-class ProstoParserNode extends ProstoParserNodeBase {
-    constructor(options) {
-        super();
-        this.options = options;
-        this.id = idCounter++;
-    }
-    getOptions() {
-        return {
-            label: this.options.label || '',
-            icon: this.options.icon || '',
-            startsWith: (this.options.startsWith ? { ...this.options.startsWith } : this.options.startsWith),
-            endsWith: (this.options.endsWith ? { ...this.options.endsWith } : this.options.endsWith),
-            popsAfterNode: [...(this.options.popsAfterNode || [])],
-            popsAtEOFSource: this.options.popsAtEOFSource || false,
-            badToken: this.options.badToken || '',
-            skipToken: this.options.skipToken || '',
-            recognizes: [...(this.options.recognizes || [])],
-            hoistChildren: [...(this.options.hoistChildren || [])],
-            mapContent: {
-                ...this.options.mapContent,
-            },
-            onPop: this.options.onPop,
-            onMatch: this.options.onMatch,
-            onAppendContent: this.options.onAppendContent,
-            onAfterChildParse: this.options.onAfterChildParse,
-            onBeforeChildParse: this.options.onBeforeChildParse,
-            initCustomData: this.options.initCustomData,
-            absorbs: this.options.absorbs,
-        };
-    }
-    createContext(index, level, rootContext) {
-        return new ProstoParserNodeContext(this, index, level, rootContext);
-    }
-    get name() {
-        return this.constructor.name + '[' + this.id.toString() + ']' + '(' + (this.options.label || this.options.icon || '') + ')';
-    }
-    parse(source) {
-        return this.createContext(0, 0).parserContext.parse(source);
-    }
-    beforeOnPop(data) {
-    }
-    beforeOnMatch(data) {
-    }
-    beforeOnAppendContent(s, data) {
-        return s;
-    }
-    beforeOnAfterChildParse(child, data) {
-    }
-    beforeOnBeforeChildParse(child, data) {
-    }
-}
-
-class BasicNode extends ProstoParserNode {
-    constructor(options) {
-        var _a, _b;
-        const startsWith = (options === null || options === void 0 ? void 0 : options.tokens) ? { token: options === null || options === void 0 ? void 0 : options.tokens[0] } : undefined;
-        const endsWith = (options === null || options === void 0 ? void 0 : options.tokens) ? { token: options === null || options === void 0 ? void 0 : options.tokens[1] } : undefined;
-        const [startOption, endOption] = ((_a = options.tokenOE) === null || _a === void 0 ? void 0 : _a.split('-')) || [];
-        const [startBSlash, endBSlash] = ((_b = options.backSlash) === null || _b === void 0 ? void 0 : _b.split('-')) || [];
-        if (startsWith) {
-            startsWith.omit = startOption === 'omit';
-            startsWith.eject = startOption === 'eject';
-            startsWith.ignoreBackSlashed = startBSlash === 'ignore';
-        }
-        if (endsWith) {
-            endsWith.omit = endOption === 'omit';
-            endsWith.eject = endOption === 'eject';
-            endsWith.ignoreBackSlashed = endBSlash === 'ignore';
-        }
-        super({
-            icon: options.icon || '',
-            label: typeof options.label === 'string' ? options.label : '',
-            startsWith,
-            endsWith,
-            badToken: options.badToken,
-            skipToken: options.skipToken,
-        });
-        if (options.recursive) {
-            this.addAbsorbs(this, 'join');
-        }
-    }
-}
-
-const stringNodeOptions = {
-    label: '',
-    icon: '"',
-    tokens: [/(?<quote>["'`])/, ({ customData }) => customData.quote || ''],
-    backSlash: '-ignore',
+	if (__NODE_JS__) return (await getPath()).join(...parts);
+	throw new Error(errorMessage);
+}
+//#endregion
+//#region src/string-expression.ts
+const quoteEndRegex$1 = {
+	"\"": /(?<=(?<!\\)(?:\\\\)*)"/,
+	"'": /(?<=(?<!\\)(?:\\\\)*)'/,
+	"`": /(?<=(?<!\\)(?:\\\\)*)`/
 };
-const stringNode = new BasicNode(stringNodeOptions);
+const stringNode = new Node({
+	name: "string",
+	start: { token: /(?<quote>["'`])/ },
+	end: { token: (ctx) => {
+		const q = ctx.node.data.quote;
+		if (!q) return "";
+		return quoteEndRegex$1[q] || "";
+	} },
+	data: { quote: "" }
+});
 function stringExpressionNodeFactory(interpolationDelimiters) {
-    return new 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`,
-    }));
-}
-
+	return new Node({
+		name: "string-expression",
+		start: {
+			token: interpolationDelimiters[0],
+			omit: true
+		},
+		end: {
+			token: interpolationDelimiters[1],
+			omit: true
+		},
+		recognizes: [stringNode],
+		data: {
+			expression: "",
+			code: (node, level = 0) => " ".repeat(level * 2) + `__ += ${node.data.expression.trim()}\n`
+		}
+	}).onClose((node) => {
+		node.data.expression = node.content.map((c) => {
+			if (typeof c === "string") return c;
+			return textContent(c);
+		}).join("");
+		node.content.length = 0;
+		try {
+			new Function(node.data.expression);
+		} catch (e) {
+			throw new Error("Invalid expression: " + e.message);
+		}
+	});
+}
+//#endregion
+//#region src/utils.ts
 function escapeRegex(s) {
-    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+	return s.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 }
 function debug(message) {
-    console.log('' + '' + '' + '[rewrite] DEBUG: ' + message + '');
+	console.log(__DYE_YELLOW__ + __DYE_BOLD__ + __DYE_DIM__ + "[rewrite] DEBUG: " + message + __DYE_RESET__);
+}
+//#endregion
+//#region src/rw-common.ts
+function genFunc(code) {
+	try {
+		return new Function("__ctx__", "process", "window", "global", "require", code);
+	} catch (e) {
+		console.error(e.message);
+		console.error(e.stack);
+		throw e;
+	}
+}
+/** @deprecated Use genFunc instead */
+const genSafeFunc = genFunc;
+function escapeString(s) {
+	return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\n/g, "\\n").replace(/\$/g, "\\$");
 }
-
-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;
+	return `__ += \`${escapeString(s)}\`\n`;
+}
+function renderCode(parsed, level = 1) {
+	let s = "";
+	let result = "";
+	function renderS() {
+		if (s) {
+			result += indent + pushString(s);
+			s = "";
+		}
+	}
+	const indent = " ".repeat(level * 2);
+	parsed.content.forEach((c) => {
+		if (typeof c === "string") s += c;
+		else {
+			renderS();
+			const data = c.data;
+			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 buildRewriter(rootNode, codeGen, cacheSize = 128) {
+	const cache = /* @__PURE__ */ new Map();
+	function getFunc(source) {
+		let func = cache.get(source);
+		if (func) return func;
+		const code = codeGen(source);
+		const compiled = genFunc(code);
+		func = (context) => {
+			try {
+				return compiled(context);
+			} catch (e) {
+				throwErrorFromFunction(e, code);
+			}
+		};
+		if (cache.size >= cacheSize) {
+			const firstKey = cache.keys().next().value;
+			if (firstKey !== void 0) cache.delete(firstKey);
+		}
+		cache.set(source, func);
+		return func;
+	}
+	function print(source) {
+		return console.log(printTree(rootNode.parse(source)));
+	}
+	return {
+		genRewriteCode: codeGen,
+		genRewriteFunction: getFunc,
+		printAsTree: print,
+		rewrite: (source, context) => getFunc(source)(context || {})
+	};
+}
+const coalesceRe = /__ \+= `([^`]*)`\n\s*__ \+= `/g;
+function coalesceStrings(code) {
+	let prev = "";
+	while (prev !== code) {
+		prev = code;
+		code = code.replace(coalesceRe, "__ += `$1");
+	}
+	return code;
 }
 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 || {}),
-    };
+	return buildRewriter(rootNode, (source) => {
+		const result = rootNode.parse(source);
+		if (debug$1) debug("Parsed tree view:\n" + printTree(result));
+		return "let __ = ''\nlet __v = ''\nwith (__ctx__) {\n" + coalesceStrings(renderCode(result)) + "}\nreturn __";
+	});
 }
 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 = 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 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 BasicNode(valueNodeOptions);
-const unquotedValueNodeOptions = {
-    label: 'value',
-    icon: '=',
-    tokens: [/=(?<content>\w+)/, /[\s\/\>]/],
-    tokenOE: 'omit-eject',
-};
-const unquotedValueNode = new BasicNode(unquotedValueNodeOptions);
-const innerNodeOptions = {
-    label: 'inner',
-    tokens: ['>', '</'],
-    tokenOE: '-eject',
-};
+	const relevantLine = e.stack?.split("\n")[1] || "";
+	const match = /<anonymous>:(\d+):(\d+)\)/g.exec(relevantLine);
+	if (match) {
+		const row = parseInt(match[1], 10) - 2;
+		const col = parseInt(match[2], 10) - 1;
+		const output = renderCodeFragmentSimple(code.split("\n"), row, col);
+		console.error(__DYE_RED_BRIGHT__ + e.message + __DYE_COLOR_OFF__);
+		console.error(output);
+	}
+	throw e;
+}
+function renderCodeFragmentSimple(lines, row, errorCol) {
+	const start = Math.max(0, row - 2);
+	const end = Math.min(lines.length, row + 3);
+	let output = "";
+	for (let i = start; i < end; i++) {
+		const lineNum = String(i + 1).padStart(4, " ");
+		output += `${lineNum}${i === row ? " > " : "   "}${lines[i]}\n`;
+		if (i === row && errorCol >= 0) output += "       " + " ".repeat(errorCol) + "^\n";
+	}
+	return output;
+}
+function getStringExpressionRewriter(interpolationDelimiters = ["{{", "}}"]) {
+	const rootNode = new Node({
+		name: "string-expr-root",
+		recognizes: [stringExpressionNodeFactory(interpolationDelimiters)],
+		eofClose: true
+	});
+	return buildRewriter(rootNode, (source) => {
+		return "let __ = []\nwith (__ctx__) {\n" + rootNode.parse(source).content.map((c) => `__.push(${typeof c === "string" ? `\`${escapeString(c)}\`` : `${c.data.expression}`})`).join("\n  ") + "}\nreturn __.length === 1 ? __[0] : __.join('')";
+	});
+}
+//#endregion
+//#region src/rw-html-parser.ts
 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',
-    },
+	{
+		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);
+htmlBlockTypes.forEach((b) => htmlBlockTypesO[b.key] = b);
 const getHtmlParser = (opts, recognizeTextDirective = false) => {
-    const rootNode = new BasicNode({ icon: 'Html Mode' });
-    const docTypeNode = new BasicNode(docTypeNodeOptions);
-    const cDataNode = new BasicNode(cDataNodeOptions);
-    const commentNode = new BasicNode(commentNodeOptions);
-    const innerNode = new 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 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 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 stringExpressionNode = stringExpressionNodeFactory(opts.exprDelimiters);
+	const docTypeNode = new Node({
+		name: "doctype",
+		start: "<!DOCTYPE ",
+		end: ">"
+	});
+	const cDataNode = new Node({
+		name: "cdata",
+		start: "<![CDATA[",
+		end: "]]>",
+		recognizes: [stringExpressionNode]
+	});
+	const commentNode = new Node({
+		name: "comment",
+		start: "<!--",
+		end: "-->",
+		recognizes: [stringExpressionNode]
+	});
+	const attrNode = attributeNodeFactory();
+	const attrBlockOperationNode = attributeNodeFactory("↳", opts.blockOperation, "block");
+	const attrExprNode = attributeNodeFactory("≈", opts.attrExpression, "expr");
+	const attrNodes = [
+		attrBlockOperationNode,
+		attrExprNode,
+		attrNode
+	];
+	const textDirectiveNode = new Node({
+		name: "text-directive",
+		start: {
+			token: new RegExp(`^\\s*(?:<!--)${escapeRegex(opts.directive)}\\s*text-mode-on\\s*-->\\s*$\\n?`, "m"),
+			omit: true
+		},
+		end: {
+			token: new RegExp(`^\\s*(?:<!--)${escapeRegex(opts.directive)}\\s*text-mode-off\\s*-->\\s*$\\n?`, "m"),
+			omit: true
+		}
+	});
+	const innerNode = new Node({
+		name: "inner",
+		start: { token: (ctx) => {
+			const parentData = ctx.parent?.data;
+			if (parentData?.isText || parentData?.isVoid) return /\b\B/;
+			return ">";
+		} },
+		end: {
+			token: "</",
+			eject: true
+		},
+		recognizes: [
+			commentNode,
+			cDataNode,
+			stringExpressionNode
+		]
+	});
+	const textInnerNode = new Node({
+		name: "textInner",
+		start: { token: (ctx) => {
+			if ((ctx.parent?.data)?.isText) return ">";
+			return /\b\B/;
+		} },
+		end: {
+			token: "</",
+			eject: true
+		}
+	});
+	const tagNode = new Node({
+		name: "tag",
+		start: { token: /<(?<tag>[\w:\-.]+)/ },
+		end: { token: (ctx) => {
+			const data = ctx.node.data;
+			if (data.isVoid) return /\/?>\s*/;
+			if (data.isText) return new RegExp(`\\s*<\\/(?<endTag>${escapeRegex(data.tag)})\\s*>\\s*`);
+			return /(?:\/>|<\/(?<endTag>[\w:\-.]+)\s*>\s*)/;
+		} },
+		data: {
+			tag: "",
+			code: () => ""
+		},
+		recognizes: [...attrNodes]
+	}).onOpen((node) => {
+		node.data.isVoid = opts.voidTags.includes(node.data.tag);
+		node.data.isText = opts.textTags.includes(node.data.tag);
+	}).onChild((child, parent) => {
+		if (child.node === attrBlockOperationNode) {
+			if (!parent.data.operations) parent.data.operations = [];
+			parent.data.operations.push(child.data);
+		}
+	}).onClose((node) => {
+		const { isVoid, tag, endTag, operations } = node.data;
+		let ops = operations;
+		if (ops && ops.length) {
+			ops = ops.sort((a) => a.key === "for" ? -1 : 1);
+			node.data.operation = ops[0].key;
+			for (let i = 0; i < ops.length; i++) {
+				const { key, value } = ops[i];
+				const descr = htmlBlockTypesO[key];
+				if (!descr) throw new Error(`Unknown block operation "${key}".`);
+				if (descr.exprRequired && !value) throw new Error(`Expression required for "${key}" operation.`);
+				if (!descr.exprRequired && !!value) throw new Error(`Unexpected expression for "${key}" operation.`);
+				if (descr.overtakes) {
+					const parentContent = node.parent?.content;
+					if (parentContent) {
+						let prevSibling = null;
+						for (let j = parentContent.length - 1; j >= 0; j--) {
+							const item = parentContent[j];
+							if (item === node) continue;
+							if (typeof item === "string") {
+								if (item.replace(/[\s\n\r]/g, "")) throw new Error(`Unexpected block operation "${descr.key}".`);
+							} else {
+								prevSibling = item;
+								break;
+							}
+						}
+						if (!prevSibling || !descr.overtakes.includes(prevSibling.data.operation)) throw new Error(`Unexpected block operation "${descr.key}".`);
+						const prevData = prevSibling.data;
+						prevData.closeCode = "";
+					}
+				}
+			}
+			if (ops.length === 1) {
+				const descr = htmlBlockTypesO[ops[0].key];
+				node.data.openCode = descr.renderOpen(ops[0].value);
+				node.data.closeCode = "}\n";
+			} else if (ops.length === 2) {
+				const descr1 = htmlBlockTypesO[ops[0].key];
+				const descr2 = htmlBlockTypesO[ops[1].key];
+				if (!descr1.compatible?.includes(descr2.key) || !descr2.compatible?.includes(descr1.key)) throw new Error(`Block operation "${descr1.key}" is not compatible with "${descr2.key}".`);
+				node.data.openCode = descr1.renderOpen(ops[0].value) + descr2.renderOpen(ops[1].value);
+				node.data.closeCode = "}\n}\n";
+			} else throw new Error(`Too many block operations "${ops.map((o) => o.key).join(", ")}".`);
+		}
+		if (!isVoid && typeof endTag === "string" && tag !== endTag) throw new Error(`Open tag <${tag}> and closing tag </${endTag}> must be equal.`);
+	});
+	tagNode.recognize(textInnerNode, innerNode);
+	innerNode.recognize(tagNode);
+	if (recognizeTextDirective) {
+		innerNode.recognize(textDirectiveNode);
+		cDataNode.recognize(textDirectiveNode);
+		textInnerNode.recognize(textDirectiveNode);
+	}
+	const rootNode = new Node({
+		name: "html-root",
+		eofClose: true,
+		recognizes: [
+			docTypeNode,
+			commentNode,
+			tagNode,
+			stringExpressionNode
+		]
+	});
+	if (recognizeTextDirective) rootNode.recognize(textDirectiveNode);
+	return {
+		rootNode,
+		innerNode,
+		commentNode,
+		cDataNode,
+		docTypeNode,
+		stringExpressionNode,
+		attrNode,
+		attrBlockOperationNode,
+		attrExprNode,
+		tagNode,
+		textDirectiveNode
+	};
 };
 const getHtmlRewriter = (opts, debug = false) => {
-    return getRewriter(getHtmlParser(opts).rootNode, debug);
+	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 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 quoteEndRegex = {
+	"\"": /(?<=(?<!\\)(?:\\\\)*)"/,
+	"'": /(?<=(?<!\\)(?:\\\\)*)'/,
+	"`": /(?<=(?<!\\)(?:\\\\)*)`/
+};
+const quoteReplaceRegex = {
+	"\"": /"/g,
+	"'": /'/g
+};
+function attributeNodeFactory(icon = "=", prefix, type = "plain") {
+	const valueNode = new Node({
+		name: `${icon}-value`,
+		start: {
+			token: /=(?<quote>["'`])/,
+			omit: true
+		},
+		end: {
+			token: (ctx) => {
+				const q = ctx.node.data.quote;
+				if (!q) return "";
+				return quoteEndRegex[q] || "";
+			},
+			omit: true
+		},
+		data: { quote: "" }
+	});
+	const unquotedValueNode = new Node({
+		name: `${icon}-unquoted-value`,
+		start: {
+			token: /=(?<content>\w+)/,
+			omit: true
+		},
+		end: {
+			token: /[\s/>]/,
+			eject: true
+		},
+		data: { content: "" }
+	});
+	const quoteEsc = {
+		"\"": "&quot;",
+		"'": "&apos;"
+	};
+	function escapeVal(value, quote) {
+		let v = "";
+		if (value) {
+			v += "=";
+			v += quote ? quote + value.replace(quoteReplaceRegex[quote], quoteEsc[quote]) + quote : value;
+		}
+		return v;
+	}
+	return new Node({
+		name: `attr-${type}`,
+		start: {
+			token: prefix ? new RegExp(`${escapeRegex(prefix)}(?<key>[\\w:\\-\\.]+)`) : /(?<key>[\w:\-.]+)/,
+			omit: true
+		},
+		end: {
+			token: /[\s\n/>]/,
+			eject: true
+		},
+		recognizes: [unquotedValueNode, valueNode],
+		data: {
+			key: "",
+			code: {
+				plain: (node, level = 0) => {
+					const { key, value, quote } = node.data;
+					return " ".repeat(level * 2) + pushString(key + escapeVal(value, quote));
+				},
+				block: () => "",
+				expr: (node, level = 0) => {
+					const { key, value, quote } = node.data;
+					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;
+				}
+			}[type]
+		}
+	}).onChild((child, parent) => {
+		if (child.node === valueNode) {
+			parent.data.quote = child.data.quote;
+			parent.data.value = textContent(child);
+		} else if (child.node === unquotedValueNode) parent.data.value = child.data.content;
+		const idx = parent.content.indexOf(child);
+		if (idx >= 0) parent.content.splice(idx, 1);
+	}).onClose((node) => {
+		node.content.length = 0;
+		if (type === "expr" && node.data.value) try {
+			new Function(node.data.value);
+		} catch (e) {
+			throw new Error("Invalid expression: " + e.message);
+		}
+		if (type === "expr" && !node.data.quote) throw new Error("Expression must be quoted.");
+	});
+}
+//#endregion
+//#region src/rw-text-parser.ts
 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',
-    },
+	{
+		key: "FOR",
+		exprRequired: true,
+		opening: true,
+		code: (node) => `for ${node.data.expression} {\n`
+	},
+	{
+		key: "IF",
+		exprRequired: true,
+		opening: true,
+		code: (node) => `if ${node.data.expression} {\n`
+	},
+	{
+		key: "ELSEIF",
+		closingKey: "IF",
+		exprRequired: true,
+		opening: false,
+		overtakes: ["IF", "ELSEIF"],
+		code: (node) => `} else if ${node.data.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);
+textBlockTypes.forEach((b) => textBlockTypesO[b.key] = b);
 const getTextParser = (opts, recognizeHtmlDirective = false) => {
-    const rootNode = new BasicNode({ icon: 'Text Mode' });
-    const stringExpressionNode = stringExpressionNodeFactory(opts.exprDelimeters);
-    const blockOperationNode = new 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 BasicNode({
-        icon: ':',
-        tokens: [
-            new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.revealLine)}[^\\S\\r\\n]*`, 'm'),
-            /$/m,
-        ],
-        tokenOE: 'omit-',
-    })
-        .addRecognizes(stringExpressionNode)
-        .popsAtEOFSource(true);
-    const ignoreDirectiveNode = new BasicNode({
-        icon: ':',
-        tokens: [
-            new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.directive)}\\s*ignore-next-line\\s*$`, 'm'),
-            /^[^\n]*$/m,
-        ],
-        tokenOE: 'omit-',
-    })
-        .popsAtEOFSource(true);
-    const htmlDirectiveNode = new 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 rootNode = new Node({
+		name: "text-root",
+		eofClose: true
+	});
+	const stringExpressionNode = stringExpressionNodeFactory(opts.exprDelimiters);
+	const esc = escapeRegex(opts.blockOperation);
+	const blockStartPattern = new RegExp(`^\\s*(?:\\/\\/|#)${esc}\\s*(?<block>(?!END)\\w+[^\\S\\r\\n]*\\w*)[^\\S\\r\\n]*(?<expression>\\(.*\\))?(?<rest>[^\\n]*)?$\\n?`, "m");
+	const blockEndPattern = new RegExp(`^\\s*(?:\\/\\/|#)${esc}\\s*(?<endBlock>END[^\\S\\r\\n]*\\w*)[^\\S\\r\\n]*(?<endExpression>\\(.*\\))?(?<endRest>[^\\n]*)?$\\n?`, "m");
+	const blockOvertakePattern = new RegExp(`^\\s*(?:\\/\\/|#)${esc}\\s*(?:ELSE\\s*IF|ELSE)[^\\S\\r\\n]*(?:\\(.*\\))?[^\\n]*$`, "m");
+	const blockOperationNode = new Node({
+		name: "block-operation",
+		start: {
+			token: () => blockStartPattern,
+			omit: true
+		},
+		end: [{
+			token: blockEndPattern,
+			omit: true
+		}, {
+			token: (ctx) => {
+				const block = ctx.node.data.block?.replace(/[\s\n]/g, "");
+				if (block === "IF" || block === "ELSEIF") return blockOvertakePattern;
+				return /\b\B/;
+			},
+			eject: true
+		}],
+		eofClose: true,
+		data: {
+			block: "",
+			expression: "",
+			rest: "",
+			descr: null,
+			endBlock: "",
+			endExpression: "",
+			endRest: "",
+			code: () => "",
+			openCode: "",
+			closeCode: ""
+		}
+	}).onOpen((node) => {
+		const block = node.data.block.replace(/[\s\n]/g, "");
+		const { expression, rest } = node.data;
+		const descr = textBlockTypesO[block];
+		if (!descr) throw new Error(`Unknown block operation "${block.trim()}".`);
+		if (descr.exprRequired && !expression) throw new Error(`Expression required for "${block.trim()}" operation.`);
+		if (!descr.exprRequired && !!expression) throw new Error(`Unexpected expression for "${block.trim()}" operation.`);
+		if (rest) throw new Error(`Unexpected text "${rest}" in "${block.trim()}" operation.`);
+		if (!descr.opening) {
+			const parentContent = node.parent?.content;
+			if (parentContent) {
+				let prevSiblingNode = null;
+				for (let j = parentContent.length - 1; j >= 0; j--) {
+					const item = parentContent[j];
+					if (typeof item === "string") {
+						if (item.replace(/[\s\n\r]/g, "")) throw new Error(`Unexpected block operation "${block.trim()}".`);
+					} else {
+						prevSiblingNode = item;
+						break;
+					}
+				}
+				if (!prevSiblingNode || !descr.overtakes?.includes(prevSiblingNode.data.block)) throw new Error(`Unexpected block operation "${block.trim()}".`);
+				prevSiblingNode.data.closeCode = "";
+			} else throw new Error(`Unexpected block operation "${block.trim()}".`);
+		}
+		node.data.block = block;
+		node.data.descr = descr;
+		node.data.openCode = descr.code(node);
+	}).onClose((node, match) => {
+		if (match?.groups?.endBlock) {
+			const endBlock = match.groups.endBlock.replace(/[\s\n]/g, "");
+			if ("END" + (node.data.descr.closingKey || node.data.descr.key) !== endBlock) throw new Error("Wrong closing block instruction " + match.groups.endBlock);
+		}
+		node.data.closeCode = "}\n";
+	});
+	const revealNode = new Node({
+		name: "reveal",
+		start: {
+			token: new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.revealLine)}[^\\S\\r\\n]*`, "m"),
+			omit: true
+		},
+		end: { token: /$/m },
+		eofClose: true,
+		recognizes: [stringExpressionNode]
+	});
+	const ignoreDirectiveNode = new Node({
+		name: "ignore-directive",
+		start: {
+			token: new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.directive)}\\s*ignore-next-line\\s*$\\n?`, "m"),
+			omit: true
+		},
+		end: { token: /^[^\n]*$/m },
+		eofClose: true
+	});
+	const htmlDirectiveNode = new Node({
+		name: "html-directive",
+		start: {
+			token: new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.directive)}\\s*html-mode-on\\s*$\\n?`, "m"),
+			omit: true
+		},
+		end: {
+			token: new RegExp(`^\\s*(?:\\/\\/|#)${escapeRegex(opts.directive)}\\s*html-mode-off\\s*$\\n?`, "m"),
+			omit: true
+		}
+	});
+	blockOperationNode.recognize(ignoreDirectiveNode, blockOperationNode, revealNode, stringExpressionNode);
+	rootNode.recognize(ignoreDirectiveNode, blockOperationNode, revealNode, stringExpressionNode);
+	if (recognizeHtmlDirective) {
+		rootNode.recognize(htmlDirectiveNode);
+		blockOperationNode.recognize(htmlDirectiveNode);
+	}
+	return {
+		stringExpressionNode,
+		revealNode,
+		ignoreDirectiveNode,
+		blockOperationNode,
+		rootNode,
+		htmlDirectiveNode
+	};
 };
 const getTextRewriter = (opts, debug = false) => {
-    return getRewriter(getTextParser(opts).rootNode, debug);
+	return getRewriter(getTextParser(opts).rootNode, debug);
 };
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var balancedMatch = balanced$1;
-function balanced$1(a, b, str) {
-  if (a instanceof RegExp) a = maybeMatch(a, str);
-  if (b instanceof RegExp) b = maybeMatch(b, str);
-
-  var r = range(a, b, str);
-
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str.slice(0, r[0]),
-    body: str.slice(r[0] + a.length, r[1]),
-    post: str.slice(r[1] + b.length)
-  };
-}
-
-function maybeMatch(reg, str) {
-  var m = str.match(reg);
-  return m ? m[0] : null;
-}
-
-balanced$1.range = range;
-function range(a, b, str) {
-  var begs, beg, left, right, result;
-  var ai = str.indexOf(a);
-  var bi = str.indexOf(b, ai + 1);
-  var i = ai;
-
-  if (ai >= 0 && bi > 0) {
-    if(a===b) {
-      return [ai, bi];
-    }
-    begs = [];
-    left = str.length;
-
-    while (i >= 0 && !result) {
-      if (i == ai) {
-        begs.push(i);
-        ai = str.indexOf(a, i + 1);
-      } else if (begs.length == 1) {
-        result = [ begs.pop(), bi ];
-      } else {
-        beg = begs.pop();
-        if (beg < left) {
-          left = beg;
-          right = bi;
-        }
-
-        bi = str.indexOf(b, i + 1);
-      }
-
-      i = ai < bi && ai >= 0 ? ai : bi;
-    }
-
-    if (begs.length) {
-      result = [ left, right ];
-    }
-  }
-
-  return result;
-}
-
-var balanced = balancedMatch;
-
-var braceExpansion = expandTop;
-
-var escSlash = '\0SLASH'+Math.random()+'\0';
-var escOpen = '\0OPEN'+Math.random()+'\0';
-var escClose = '\0CLOSE'+Math.random()+'\0';
-var escComma = '\0COMMA'+Math.random()+'\0';
-var escPeriod = '\0PERIOD'+Math.random()+'\0';
-
-function numeric(str) {
-  return parseInt(str, 10) == str
-    ? parseInt(str, 10)
-    : str.charCodeAt(0);
-}
-
-function escapeBraces(str) {
-  return str.split('\\\\').join(escSlash)
-            .split('\\{').join(escOpen)
-            .split('\\}').join(escClose)
-            .split('\\,').join(escComma)
-            .split('\\.').join(escPeriod);
-}
-
-function unescapeBraces(str) {
-  return str.split(escSlash).join('\\')
-            .split(escOpen).join('{')
-            .split(escClose).join('}')
-            .split(escComma).join(',')
-            .split(escPeriod).join('.');
-}
-
-
-// Basically just str.split(","), but handling cases
-// where we have nested braced sections, which should be
-// treated as individual members, like {a,{b,c},d}
-function parseCommaParts(str) {
-  if (!str)
-    return [''];
-
-  var parts = [];
-  var m = balanced('{', '}', str);
-
-  if (!m)
-    return str.split(',');
-
-  var pre = m.pre;
-  var body = m.body;
-  var post = m.post;
-  var p = pre.split(',');
-
-  p[p.length-1] += '{' + body + '}';
-  var postParts = parseCommaParts(post);
-  if (post.length) {
-    p[p.length-1] += postParts.shift();
-    p.push.apply(p, postParts);
-  }
-
-  parts.push.apply(parts, p);
-
-  return parts;
-}
-
-function expandTop(str) {
-  if (!str)
-    return [];
-
-  // I don't know why Bash 4.3 does this, but it does.
-  // Anything starting with {} will have the first two bytes preserved
-  // but *only* at the top level, so {},a}b will not expand to anything,
-  // but a{},b}c will be expanded to [a}c,abc].
-  // One could argue that this is a bug in Bash, but since the goal of
-  // this module is to match Bash's rules, we escape a leading {}
-  if (str.substr(0, 2) === '{}') {
-    str = '\\{\\}' + str.substr(2);
-  }
-
-  return expand(escapeBraces(str), true).map(unescapeBraces);
-}
-
-function embrace(str) {
-  return '{' + str + '}';
-}
-function isPadded(el) {
-  return /^-?0\d/.test(el);
-}
-
-function lte(i, y) {
-  return i <= y;
-}
-function gte(i, y) {
-  return i >= y;
-}
-
-function expand(str, isTop) {
-  var expansions = [];
-
-  var m = balanced('{', '}', str);
-  if (!m) return [str];
-
-  // no need to expand pre, since it is guaranteed to be free of brace-sets
-  var pre = m.pre;
-  var post = m.post.length
-    ? expand(m.post, false)
-    : [''];
-
-  if (/\$$/.test(m.pre)) {    
-    for (var k = 0; k < post.length; k++) {
-      var expansion = pre+ '{' + m.body + '}' + post[k];
-      expansions.push(expansion);
-    }
-  } else {
-    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-    var isSequence = isNumericSequence || isAlphaSequence;
-    var isOptions = m.body.indexOf(',') >= 0;
-    if (!isSequence && !isOptions) {
-      // {a},b}
-      if (m.post.match(/,.*\}/)) {
-        str = m.pre + '{' + m.body + escClose + m.post;
-        return expand(str);
-      }
-      return [str];
-    }
-
-    var n;
-    if (isSequence) {
-      n = m.body.split(/\.\./);
-    } else {
-      n = parseCommaParts(m.body);
-      if (n.length === 1) {
-        // x{{a,b}}y ==> x{a}y x{b}y
-        n = expand(n[0], false).map(embrace);
-        if (n.length === 1) {
-          return post.map(function(p) {
-            return m.pre + n[0] + p;
-          });
-        }
-      }
-    }
-
-    // at this point, n is the parts, and we know it's not a comma set
-    // with a single entry.
-    var N;
-
-    if (isSequence) {
-      var x = numeric(n[0]);
-      var y = numeric(n[1]);
-      var width = Math.max(n[0].length, n[1].length);
-      var incr = n.length == 3
-        ? Math.abs(numeric(n[2]))
-        : 1;
-      var test = lte;
-      var reverse = y < x;
-      if (reverse) {
-        incr *= -1;
-        test = gte;
-      }
-      var pad = n.some(isPadded);
-
-      N = [];
-
-      for (var i = x; test(i, y); i += incr) {
-        var c;
-        if (isAlphaSequence) {
-          c = String.fromCharCode(i);
-          if (c === '\\')
-            c = '';
-        } else {
-          c = String(i);
-          if (pad) {
-            var need = width - c.length;
-            if (need > 0) {
-              var z = new Array(need + 1).join('0');
-              if (i < 0)
-                c = '-' + z + c.slice(1);
-              else
-                c = z + c;
-            }
-          }
-        }
-        N.push(c);
-      }
-    } else {
-      N = [];
-
-      for (var j = 0; j < n.length; j++) {
-        N.push.apply(N, expand(n[j], false));
-      }
-    }
-
-    for (var j = 0; j < N.length; j++) {
-      for (var k = 0; k < post.length; k++) {
-        var expansion = pre + N[j] + post[k];
-        if (!isTop || isSequence || expansion)
-          expansions.push(expansion);
-      }
-    }
-  }
-
-  return expansions;
-}
-
-var expand$1 = /*@__PURE__*/getDefaultExportFromCjs(braceExpansion);
-
-const MAX_PATTERN_LENGTH = 1024 * 64;
-const assertValidPattern = (pattern) => {
-    if (typeof pattern !== 'string') {
-        throw new TypeError('invalid pattern');
-    }
-    if (pattern.length > MAX_PATTERN_LENGTH) {
-        throw new TypeError('pattern is too long');
-    }
-};
-
-// translate the various posix character classes into unicode properties
-// this works across all unicode locales
-// { <posix class>: [<translation>, /u flag required, negated]
-const posixClasses = {
-    '[:alnum:]': ['\\p{L}\\p{Nl}\\p{Nd}', true],
-    '[:alpha:]': ['\\p{L}\\p{Nl}', true],
-    '[:ascii:]': ['\\x' + '00-\\x' + '7f', false],
-    '[:blank:]': ['\\p{Zs}\\t', true],
-    '[:cntrl:]': ['\\p{Cc}', true],
-    '[:digit:]': ['\\p{Nd}', true],
-    '[:graph:]': ['\\p{Z}\\p{C}', true, true],
-    '[:lower:]': ['\\p{Ll}', true],
-    '[:print:]': ['\\p{C}', true],
-    '[:punct:]': ['\\p{P}', true],
-    '[:space:]': ['\\p{Z}\\t\\r\\n\\v\\f', true],
-    '[:upper:]': ['\\p{Lu}', true],
-    '[:word:]': ['\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}', true],
-    '[:xdigit:]': ['A-Fa-f0-9', false],
-};
-// only need to escape a few things inside of brace expressions
-// escapes: [ \ ] -
-const braceEscape = (s) => s.replace(/[[\]\\-]/g, '\\$&');
-// escape all regexp magic characters
-const regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-// everything has already been escaped, we just have to join
-const rangesToString = (ranges) => ranges.join('');
-// takes a glob string at a posix brace expression, and returns
-// an equivalent regular expression source, and boolean indicating
-// whether the /u flag needs to be applied, and the number of chars
-// consumed to parse the character class.
-// This also removes out of order ranges, and returns ($.) if the
-// entire class just no good.
-const parseClass = (glob, position) => {
-    const pos = position;
-    /* c8 ignore start */
-    if (glob.charAt(pos) !== '[') {
-        throw new Error('not in a brace expression');
-    }
-    /* c8 ignore stop */
-    const ranges = [];
-    const negs = [];
-    let i = pos + 1;
-    let sawStart = false;
-    let uflag = false;
-    let escaping = false;
-    let negate = false;
-    let endPos = pos;
-    let rangeStart = '';
-    WHILE: while (i < glob.length) {
-        const c = glob.charAt(i);
-        if ((c === '!' || c === '^') && i === pos + 1) {
-            negate = true;
-            i++;
-            continue;
-        }
-        if (c === ']' && sawStart && !escaping) {
-            endPos = i + 1;
-            break;
-        }
-        sawStart = true;
-        if (c === '\\') {
-            if (!escaping) {
-                escaping = true;
-                i++;
-                continue;
-            }
-            // escaped \ char, fall through and treat like normal char
-        }
-        if (c === '[' && !escaping) {
-            // either a posix class, a collation equivalent, or just a [
-            for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
-                if (glob.startsWith(cls, i)) {
-                    // invalid, [a-[] is fine, but not [a-[:alpha]]
-                    if (rangeStart) {
-                        return ['$.', false, glob.length - pos, true];
-                    }
-                    i += cls.length;
-                    if (neg)
-                        negs.push(unip);
-                    else
-                        ranges.push(unip);
-                    uflag = uflag || u;
-                    continue WHILE;
-                }
-            }
-        }
-        // now it's just a normal character, effectively
-        escaping = false;
-        if (rangeStart) {
-            // throw this range away if it's not valid, but others
-            // can still match.
-            if (c > rangeStart) {
-                ranges.push(braceEscape(rangeStart) + '-' + braceEscape(c));
-            }
-            else if (c === rangeStart) {
-                ranges.push(braceEscape(c));
-            }
-            rangeStart = '';
-            i++;
-            continue;
-        }
-        // now might be the start of a range.
-        // can be either c-d or c-] or c<more...>] or c] at this point
-        if (glob.startsWith('-]', i + 1)) {
-            ranges.push(braceEscape(c + '-'));
-            i += 2;
-            continue;
-        }
-        if (glob.startsWith('-', i + 1)) {
-            rangeStart = c;
-            i += 2;
-            continue;
-        }
-        // not the start of a range, just a single character
-        ranges.push(braceEscape(c));
-        i++;
-    }
-    if (endPos < i) {
-        // didn't see the end of the class, not a valid class,
-        // but might still be valid as a literal match.
-        return ['', false, 0, false];
-    }
-    // if we got no ranges and no negates, then we have a range that
-    // cannot possibly match anything, and that poisons the whole glob
-    if (!ranges.length && !negs.length) {
-        return ['$.', false, glob.length - pos, true];
-    }
-    // if we got one positive range, and it's a single character, then that's
-    // not actually a magic pattern, it's just that one literal character.
-    // we should not treat that as "magic", we should just return the literal
-    // character. [_] is a perfectly valid way to escape glob magic chars.
-    if (negs.length === 0 &&
-        ranges.length === 1 &&
-        /^\\?.$/.test(ranges[0]) &&
-        !negate) {
-        const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
-        return [regexpEscape(r), false, endPos - pos, false];
-    }
-    const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';
-    const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';
-    const comb = ranges.length && negs.length
-        ? '(' + sranges + '|' + snegs + ')'
-        : ranges.length
-            ? sranges
-            : snegs;
-    return [comb, uflag, endPos - pos, true];
-};
-
-/**
- * Un-escape a string that has been escaped with {@link escape}.
- *
- * If the {@link windowsPathsNoEscape} option is used, then square-brace
- * escapes are removed, but not backslash escapes.  For example, it will turn
- * the string `'[*]'` into `*`, but it will not turn `'\\*'` into `'*'`,
- * becuase `\` is a path separator in `windowsPathsNoEscape` mode.
- *
- * When `windowsPathsNoEscape` is not set, then both brace escapes and
- * backslash escapes are removed.
- *
- * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped
- * or unescaped.
- */
-const unescape = (s, { windowsPathsNoEscape = false, } = {}) => {
-    return windowsPathsNoEscape
-        ? s.replace(/\[([^\/\\])\]/g, '$1')
-        : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, '$1$2').replace(/\\([^\/])/g, '$1');
-};
-
-// parse a single path portion
-const types = new Set(['!', '?', '+', '*', '@']);
-const isExtglobType = (c) => types.has(c);
-// Patterns that get prepended to bind to the start of either the
-// entire string, or just a single path portion, to prevent dots
-// and/or traversal patterns, when needed.
-// Exts don't need the ^ or / bit, because the root binds that already.
-const startNoTraversal = '(?!(?:^|/)\\.\\.?(?:$|/))';
-const startNoDot = '(?!\\.)';
-// characters that indicate a start of pattern needs the "no dots" bit,
-// because a dot *might* be matched. ( is not in the list, because in
-// the case of a child extglob, it will handle the prevention itself.
-const addPatternStart = new Set(['[', '.']);
-// cases where traversal is A-OK, no dot prevention needed
-const justDots = new Set(['..', '.']);
-const reSpecials = new Set('().*{}+?[]^$\\!');
-const regExpEscape$1 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-// any single thing other than /
-const qmark$1 = '[^/]';
-// * => any number of characters
-const star$1 = qmark$1 + '*?';
-// use + when we need to ensure that *something* matches, because the * is
-// the only thing in the path portion.
-const starNoEmpty = qmark$1 + '+?';
-// remove the \ chars that we added if we end up doing a nonmagic compare
-// const deslash = (s: string) => s.replace(/\\(.)/g, '$1')
-class AST {
-    type;
-    #root;
-    #hasMagic;
-    #uflag = false;
-    #parts = [];
-    #parent;
-    #parentIndex;
-    #negs;
-    #filledNegs = false;
-    #options;
-    #toString;
-    // set to true if it's an extglob with no children
-    // (which really means one child of '')
-    #emptyExt = false;
-    constructor(type, parent, options = {}) {
-        this.type = type;
-        // extglobs are inherently magical
-        if (type)
-            this.#hasMagic = true;
-        this.#parent = parent;
-        this.#root = this.#parent ? this.#parent.#root : this;
-        this.#options = this.#root === this ? options : this.#root.#options;
-        this.#negs = this.#root === this ? [] : this.#root.#negs;
-        if (type === '!' && !this.#root.#filledNegs)
-            this.#negs.push(this);
-        this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
-    }
-    get hasMagic() {
-        /* c8 ignore start */
-        if (this.#hasMagic !== undefined)
-            return this.#hasMagic;
-        /* c8 ignore stop */
-        for (const p of this.#parts) {
-            if (typeof p === 'string')
-                continue;
-            if (p.type || p.hasMagic)
-                return (this.#hasMagic = true);
-        }
-        // note: will be undefined until we generate the regexp src and find out
-        return this.#hasMagic;
-    }
-    // reconstructs the pattern
-    toString() {
-        if (this.#toString !== undefined)
-            return this.#toString;
-        if (!this.type) {
-            return (this.#toString = this.#parts.map(p => String(p)).join(''));
-        }
-        else {
-            return (this.#toString =
-                this.type + '(' + this.#parts.map(p => String(p)).join('|') + ')');
-        }
-    }
-    #fillNegs() {
-        /* c8 ignore start */
-        if (this !== this.#root)
-            throw new Error('should only call on root');
-        if (this.#filledNegs)
-            return this;
-        /* c8 ignore stop */
-        // call toString() once to fill this out
-        this.toString();
-        this.#filledNegs = true;
-        let n;
-        while ((n = this.#negs.pop())) {
-            if (n.type !== '!')
-                continue;
-            // walk up the tree, appending everthing that comes AFTER parentIndex
-            let p = n;
-            let pp = p.#parent;
-            while (pp) {
-                for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
-                    for (const part of n.#parts) {
-                        /* c8 ignore start */
-                        if (typeof part === 'string') {
-                            throw new Error('string part in extglob AST??');
-                        }
-                        /* c8 ignore stop */
-                        part.copyIn(pp.#parts[i]);
-                    }
-                }
-                p = pp;
-                pp = p.#parent;
-            }
-        }
-        return this;
-    }
-    push(...parts) {
-        for (const p of parts) {
-            if (p === '')
-                continue;
-            /* c8 ignore start */
-            if (typeof p !== 'string' && !(p instanceof AST && p.#parent === this)) {
-                throw new Error('invalid part: ' + p);
-            }
-            /* c8 ignore stop */
-            this.#parts.push(p);
-        }
-    }
-    toJSON() {
-        const ret = this.type === null
-            ? this.#parts.slice().map(p => (typeof p === 'string' ? p : p.toJSON()))
-            : [this.type, ...this.#parts.map(p => p.toJSON())];
-        if (this.isStart() && !this.type)
-            ret.unshift([]);
-        if (this.isEnd() &&
-            (this === this.#root ||
-                (this.#root.#filledNegs && this.#parent?.type === '!'))) {
-            ret.push({});
-        }
-        return ret;
-    }
-    isStart() {
-        if (this.#root === this)
-            return true;
-        // if (this.type) return !!this.#parent?.isStart()
-        if (!this.#parent?.isStart())
-            return false;
-        if (this.#parentIndex === 0)
-            return true;
-        // if everything AHEAD of this is a negation, then it's still the "start"
-        const p = this.#parent;
-        for (let i = 0; i < this.#parentIndex; i++) {
-            const pp = p.#parts[i];
-            if (!(pp instanceof AST && pp.type === '!')) {
-                return false;
-            }
-        }
-        return true;
-    }
-    isEnd() {
-        if (this.#root === this)
-            return true;
-        if (this.#parent?.type === '!')
-            return true;
-        if (!this.#parent?.isEnd())
-            return false;
-        if (!this.type)
-            return this.#parent?.isEnd();
-        // if not root, it'll always have a parent
-        /* c8 ignore start */
-        const pl = this.#parent ? this.#parent.#parts.length : 0;
-        /* c8 ignore stop */
-        return this.#parentIndex === pl - 1;
-    }
-    copyIn(part) {
-        if (typeof part === 'string')
-            this.push(part);
-        else
-            this.push(part.clone(this));
-    }
-    clone(parent) {
-        const c = new AST(this.type, parent);
-        for (const p of this.#parts) {
-            c.copyIn(p);
-        }
-        return c;
-    }
-    static #parseAST(str, ast, pos, opt) {
-        let escaping = false;
-        let inBrace = false;
-        let braceStart = -1;
-        let braceNeg = false;
-        if (ast.type === null) {
-            // outside of a extglob, append until we find a start
-            let i = pos;
-            let acc = '';
-            while (i < str.length) {
-                const c = str.charAt(i++);
-                // still accumulate escapes at this point, but we do ignore
-                // starts that are escaped
-                if (escaping || c === '\\') {
-                    escaping = !escaping;
-                    acc += c;
-                    continue;
-                }
-                if (inBrace) {
-                    if (i === braceStart + 1) {
-                        if (c === '^' || c === '!') {
-                            braceNeg = true;
-                        }
-                    }
-                    else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {
-                        inBrace = false;
-                    }
-                    acc += c;
-                    continue;
-                }
-                else if (c === '[') {
-                    inBrace = true;
-                    braceStart = i;
-                    braceNeg = false;
-                    acc += c;
-                    continue;
-                }
-                if (!opt.noext && isExtglobType(c) && str.charAt(i) === '(') {
-                    ast.push(acc);
-                    acc = '';
-                    const ext = new AST(c, ast);
-                    i = AST.#parseAST(str, ext, i, opt);
-                    ast.push(ext);
-                    continue;
-                }
-                acc += c;
-            }
-            ast.push(acc);
-            return i;
-        }
-        // some kind of extglob, pos is at the (
-        // find the next | or )
-        let i = pos + 1;
-        let part = new AST(null, ast);
-        const parts = [];
-        let acc = '';
-        while (i < str.length) {
-            const c = str.charAt(i++);
-            // still accumulate escapes at this point, but we do ignore
-            // starts that are escaped
-            if (escaping || c === '\\') {
-                escaping = !escaping;
-                acc += c;
-                continue;
-            }
-            if (inBrace) {
-                if (i === braceStart + 1) {
-                    if (c === '^' || c === '!') {
-                        braceNeg = true;
-                    }
-                }
-                else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {
-                    inBrace = false;
-                }
-                acc += c;
-                continue;
-            }
-            else if (c === '[') {
-                inBrace = true;
-                braceStart = i;
-                braceNeg = false;
-                acc += c;
-                continue;
-            }
-            if (isExtglobType(c) && str.charAt(i) === '(') {
-                part.push(acc);
-                acc = '';
-                const ext = new AST(c, part);
-                part.push(ext);
-                i = AST.#parseAST(str, ext, i, opt);
-                continue;
-            }
-            if (c === '|') {
-                part.push(acc);
-                acc = '';
-                parts.push(part);
-                part = new AST(null, ast);
-                continue;
-            }
-            if (c === ')') {
-                if (acc === '' && ast.#parts.length === 0) {
-                    ast.#emptyExt = true;
-                }
-                part.push(acc);
-                acc = '';
-                ast.push(...parts, part);
-                return i;
-            }
-            acc += c;
-        }
-        // unfinished extglob
-        // if we got here, it was a malformed extglob! not an extglob, but
-        // maybe something else in there.
-        ast.type = null;
-        ast.#hasMagic = undefined;
-        ast.#parts = [str.substring(pos - 1)];
-        return i;
-    }
-    static fromGlob(pattern, options = {}) {
-        const ast = new AST(null, undefined, options);
-        AST.#parseAST(pattern, ast, 0, options);
-        return ast;
-    }
-    // returns the regular expression if there's magic, or the unescaped
-    // string if not.
-    toMMPattern() {
-        // should only be called on root
-        /* c8 ignore start */
-        if (this !== this.#root)
-            return this.#root.toMMPattern();
-        /* c8 ignore stop */
-        const glob = this.toString();
-        const [re, body, hasMagic, uflag] = this.toRegExpSource();
-        // if we're in nocase mode, and not nocaseMagicOnly, then we do
-        // still need a regular expression if we have to case-insensitively
-        // match capital/lowercase characters.
-        const anyMagic = hasMagic ||
-            this.#hasMagic ||
-            (this.#options.nocase &&
-                !this.#options.nocaseMagicOnly &&
-                glob.toUpperCase() !== glob.toLowerCase());
-        if (!anyMagic) {
-            return body;
-        }
-        const flags = (this.#options.nocase ? 'i' : '') + (uflag ? 'u' : '');
-        return Object.assign(new RegExp(`^${re}$`, flags), {
-            _src: re,
-            _glob: glob,
-        });
-    }
-    // returns the string match, the regexp source, whether there's magic
-    // in the regexp (so a regular expression is required) and whether or
-    // not the uflag is needed for the regular expression (for posix classes)
-    // TODO: instead of injecting the start/end at this point, just return
-    // the BODY of the regexp, along with the start/end portions suitable
-    // for binding the start/end in either a joined full-path makeRe context
-    // (where we bind to (^|/), or a standalone matchPart context (where
-    // we bind to ^, and not /).  Otherwise slashes get duped!
-    //
-    // In part-matching mode, the start is:
-    // - if not isStart: nothing
-    // - if traversal possible, but not allowed: ^(?!\.\.?$)
-    // - if dots allowed or not possible: ^
-    // - if dots possible and not allowed: ^(?!\.)
-    // end is:
-    // - if not isEnd(): nothing
-    // - else: $
-    //
-    // In full-path matching mode, we put the slash at the START of the
-    // pattern, so start is:
-    // - if first pattern: same as part-matching mode
-    // - if not isStart(): nothing
-    // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
-    // - if dots allowed or not possible: /
-    // - if dots possible and not allowed: /(?!\.)
-    // end is:
-    // - if last pattern, same as part-matching mode
-    // - else nothing
-    //
-    // Always put the (?:$|/) on negated tails, though, because that has to be
-    // there to bind the end of the negated pattern portion, and it's easier to
-    // just stick it in now rather than try to inject it later in the middle of
-    // the pattern.
-    //
-    // We can just always return the same end, and leave it up to the caller
-    // to know whether it's going to be used joined or in parts.
-    // And, if the start is adjusted slightly, can do the same there:
-    // - if not isStart: nothing
-    // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
-    // - if dots allowed or not possible: (?:/|^)
-    // - if dots possible and not allowed: (?:/|^)(?!\.)
-    //
-    // But it's better to have a simpler binding without a conditional, for
-    // performance, so probably better to return both start options.
-    //
-    // Then the caller just ignores the end if it's not the first pattern,
-    // and the start always gets applied.
-    //
-    // But that's always going to be $ if it's the ending pattern, or nothing,
-    // so the caller can just attach $ at the end of the pattern when building.
-    //
-    // So the todo is:
-    // - better detect what kind of start is needed
-    // - return both flavors of starting pattern
-    // - attach $ at the end of the pattern when creating the actual RegExp
-    //
-    // Ah, but wait, no, that all only applies to the root when the first pattern
-    // is not an extglob. If the first pattern IS an extglob, then we need all
-    // that dot prevention biz to live in the extglob portions, because eg
-    // +(*|.x*) can match .xy but not .yx.
-    //
-    // So, return the two flavors if it's #root and the first child is not an
-    // AST, otherwise leave it to the child AST to handle it, and there,
-    // use the (?:^|/) style of start binding.
-    //
-    // Even simplified further:
-    // - Since the start for a join is eg /(?!\.) and the start for a part
-    // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
-    // or start or whatever) and prepend ^ or / at the Regexp construction.
-    toRegExpSource(allowDot) {
-        const dot = allowDot ?? !!this.#options.dot;
-        if (this.#root === this)
-            this.#fillNegs();
-        if (!this.type) {
-            const noEmpty = this.isStart() && this.isEnd();
-            const src = this.#parts
-                .map(p => {
-                const [re, _, hasMagic, uflag] = typeof p === 'string'
-                    ? AST.#parseGlob(p, this.#hasMagic, noEmpty)
-                    : p.toRegExpSource(allowDot);
-                this.#hasMagic = this.#hasMagic || hasMagic;
-                this.#uflag = this.#uflag || uflag;
-                return re;
-            })
-                .join('');
-            let start = '';
-            if (this.isStart()) {
-                if (typeof this.#parts[0] === 'string') {
-                    // this is the string that will match the start of the pattern,
-                    // so we need to protect against dots and such.
-                    // '.' and '..' cannot match unless the pattern is that exactly,
-                    // even if it starts with . or dot:true is set.
-                    const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
-                    if (!dotTravAllowed) {
-                        const aps = addPatternStart;
-                        // check if we have a possibility of matching . or ..,
-                        // and prevent that.
-                        const needNoTrav = 
-                        // dots are allowed, and the pattern starts with [ or .
-                        (dot && aps.has(src.charAt(0))) ||
-                            // the pattern starts with \., and then [ or .
-                            (src.startsWith('\\.') && aps.has(src.charAt(2))) ||
-                            // the pattern starts with \.\., and then [ or .
-                            (src.startsWith('\\.\\.') && aps.has(src.charAt(4)));
-                        // no need to prevent dots if it can't match a dot, or if a
-                        // sub-pattern will be preventing it anyway.
-                        const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
-                        start = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : '';
-                    }
-                }
-            }
-            // append the "end of path portion" pattern to negation tails
-            let end = '';
-            if (this.isEnd() &&
-                this.#root.#filledNegs &&
-                this.#parent?.type === '!') {
-                end = '(?:$|\\/)';
-            }
-            const final = start + src + end;
-            return [
-                final,
-                unescape(src),
-                (this.#hasMagic = !!this.#hasMagic),
-                this.#uflag,
-            ];
-        }
-        // We need to calculate the body *twice* if it's a repeat pattern
-        // at the start, once in nodot mode, then again in dot mode, so a
-        // pattern like *(?) can match 'x.y'
-        const repeated = this.type === '*' || this.type === '+';
-        // some kind of extglob
-        const start = this.type === '!' ? '(?:(?!(?:' : '(?:';
-        let body = this.#partsToRegExp(dot);
-        if (this.isStart() && this.isEnd() && !body && this.type !== '!') {
-            // invalid extglob, has to at least be *something* present, if it's
-            // the entire path portion.
-            const s = this.toString();
-            this.#parts = [s];
-            this.type = null;
-            this.#hasMagic = undefined;
-            return [s, unescape(this.toString()), false, false];
-        }
-        // XXX abstract out this map method
-        let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot
-            ? ''
-            : this.#partsToRegExp(true);
-        if (bodyDotAllowed === body) {
-            bodyDotAllowed = '';
-        }
-        if (bodyDotAllowed) {
-            body = `(?:${body})(?:${bodyDotAllowed})*?`;
-        }
-        // an empty !() is exactly equivalent to a starNoEmpty
-        let final = '';
-        if (this.type === '!' && this.#emptyExt) {
-            final = (this.isStart() && !dot ? startNoDot : '') + starNoEmpty;
-        }
-        else {
-            const close = this.type === '!'
-                ? // !() must match something,but !(x) can match ''
-                    '))' +
-                        (this.isStart() && !dot && !allowDot ? startNoDot : '') +
-                        star$1 +
-                        ')'
-                : this.type === '@'
-                    ? ')'
-                    : this.type === '?'
-                        ? ')?'
-                        : this.type === '+' && bodyDotAllowed
-                            ? ')'
-                            : this.type === '*' && bodyDotAllowed
-                                ? `)?`
-                                : `)${this.type}`;
-            final = start + body + close;
-        }
-        return [
-            final,
-            unescape(body),
-            (this.#hasMagic = !!this.#hasMagic),
-            this.#uflag,
-        ];
-    }
-    #partsToRegExp(dot) {
-        return this.#parts
-            .map(p => {
-            // extglob ASTs should only contain parent ASTs
-            /* c8 ignore start */
-            if (typeof p === 'string') {
-                throw new Error('string type in extglob ast??');
-            }
-            /* c8 ignore stop */
-            // can ignore hasMagic, because extglobs are already always magic
-            const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
-            this.#uflag = this.#uflag || uflag;
-            return re;
-        })
-            .filter(p => !(this.isStart() && this.isEnd()) || !!p)
-            .join('|');
-    }
-    static #parseGlob(glob, hasMagic, noEmpty = false) {
-        let escaping = false;
-        let re = '';
-        let uflag = false;
-        for (let i = 0; i < glob.length; i++) {
-            const c = glob.charAt(i);
-            if (escaping) {
-                escaping = false;
-                re += (reSpecials.has(c) ? '\\' : '') + c;
-                continue;
-            }
-            if (c === '\\') {
-                if (i === glob.length - 1) {
-                    re += '\\\\';
-                }
-                else {
-                    escaping = true;
-                }
-                continue;
-            }
-            if (c === '[') {
-                const [src, needUflag, consumed, magic] = parseClass(glob, i);
-                if (consumed) {
-                    re += src;
-                    uflag = uflag || needUflag;
-                    i += consumed - 1;
-                    hasMagic = hasMagic || magic;
-                    continue;
-                }
-            }
-            if (c === '*') {
-                if (noEmpty && glob === '*')
-                    re += starNoEmpty;
-                else
-                    re += star$1;
-                hasMagic = true;
-                continue;
-            }
-            if (c === '?') {
-                re += qmark$1;
-                hasMagic = true;
-                continue;
-            }
-            re += regExpEscape$1(c);
-        }
-        return [re, unescape(glob), !!hasMagic, uflag];
-    }
-}
-
-/**
- * Escape all magic characters in a glob pattern.
- *
- * If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}
- * option is used, then characters are escaped by wrapping in `[]`, because
- * a magic character wrapped in a character class can only be satisfied by
- * that exact character.  In this mode, `\` is _not_ escaped, because it is
- * not interpreted as a magic character, but instead as a path separator.
- */
-const escape = (s, { windowsPathsNoEscape = false, } = {}) => {
-    // don't need to escape +@! because we escape the parens
-    // that make those magic, and escaping ! as [!] isn't valid,
-    // because [!]] is a valid glob class meaning not ']'.
-    return windowsPathsNoEscape
-        ? s.replace(/[?*()[\]]/g, '[$&]')
-        : s.replace(/[?*()[\]\\]/g, '\\$&');
+//#endregion
+//#region src/index.ts
+const defaultDelimiters = ["{{", "}}"];
+var ProstoRewrite = class {
+	options;
+	_mixedRewriter;
+	_textRewriter;
+	_htmlRewriter;
+	constructor(options) {
+		this.options = {
+			defaultMode: options?.defaultMode || "auto",
+			debug: options?.debug || false,
+			htmlPattern: __NODE_JS__ ? (options?.htmlPattern || ["*.{html,xhtml,xml,svg}"]).map((p) => new Minimatch(p, { matchBase: true })) : [],
+			textPattern: __NODE_JS__ ? (options?.textPattern || [
+				"*.{js,jsx,ts,tsx,txt,json,yml,yaml,md,ini}",
+				"Dockerfile",
+				"*config",
+				".gitignore"
+			]).map((p) => new Minimatch(p, { matchBase: true })) : [],
+			html: {
+				exprDelimiters: defaultDelimiters,
+				attrExpression: ":",
+				blockOperation: "v-",
+				directive: "!@",
+				voidTags: options?.html?.voidTags || htmlVoidTags,
+				textTags: options?.html?.textTags || htmlTextTags,
+				...options?.html
+			},
+			text: {
+				exprDelimiters: defaultDelimiters,
+				blockOperation: "=",
+				revealLine: ":",
+				directive: "!@",
+				...options?.text
+			}
+		};
+	}
+	get mixedRewriter() {
+		if (!this._mixedRewriter) {
+			const textNodes = getTextParser(this.options.text, true);
+			const htmlNodes = getHtmlParser(this.options.html, true);
+			textNodes.htmlDirectiveNode.recognize(...htmlNodes.rootNode.recognizes);
+			htmlNodes.textDirectiveNode.recognize(...textNodes.rootNode.recognizes);
+			this._mixedRewriter = {
+				text: getRewriter(textNodes.rootNode, this.options.debug),
+				html: getRewriter(htmlNodes.rootNode, this.options.debug)
+			};
+		}
+		return this._mixedRewriter;
+	}
+	get textRewriter() {
+		if (!this._textRewriter) this._textRewriter = getTextRewriter(this.options.text, this.options.debug);
+		return this._textRewriter;
+	}
+	get htmlRewriter() {
+		if (!this._htmlRewriter) this._htmlRewriter = getHtmlRewriter(this.options.html, this.options.debug);
+		return this._htmlRewriter;
+	}
+	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;
+		if (mode) {
+			this.debug("Parsing file in " + mode + " mode. " + __DYE_UNDERSCORE__ + __DYE_BOLD_OFF__ + opts.input);
+			output = this.mixedRewriter[mode].rewrite(file, context);
+		} else this.debug("File isn't recognized as text nor as html. " + __DYE_UNDERSCORE__ + __DYE_BOLD_OFF__ + opts.input);
+		if (opts.output) if (mode) {
+			await writeFile(opts.output, output);
+			this.debug("File has been rewritten in " + mode + " mode. " + __DYE_UNDERSCORE__ + __DYE_BOLD_OFF__ + opts.output);
+		} else {
+			await copyFile(opts.input, opts.output);
+			this.debug("File rewriting was skipped. File copied. " + __DYE_UNDERSCORE__ + __DYE_BOLD_OFF__ + opts.output);
+		}
+		return output;
+	}
+	async rewriteDir(opts, context) {
+		if (__BROWSER__) return;
+		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(s, { matchBase: true })) : null;
+		const exclude = opts.exclude && opts.exclude.length ? opts.exclude.map((s) => new Minimatch(s, { matchBase: true })) : null;
+		const rename = opts.renameFile || ((f) => f);
+		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 = rename(filePath.slice(dirPath.length + 1));
+			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);
+	}
 };
-
-const minimatch = (p, pattern, options = {}) => {
-    assertValidPattern(pattern);
-    // shortcut: comments match nothing.
-    if (!options.nocomment && pattern.charAt(0) === '#') {
-        return false;
-    }
-    return new Minimatch(pattern, options).match(p);
-};
-// Optimized checking for the most common glob patterns.
-const starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
-const starDotExtTest = (ext) => (f) => !f.startsWith('.') && f.endsWith(ext);
-const starDotExtTestDot = (ext) => (f) => f.endsWith(ext);
-const starDotExtTestNocase = (ext) => {
-    ext = ext.toLowerCase();
-    return (f) => !f.startsWith('.') && f.toLowerCase().endsWith(ext);
-};
-const starDotExtTestNocaseDot = (ext) => {
-    ext = ext.toLowerCase();
-    return (f) => f.toLowerCase().endsWith(ext);
-};
-const starDotStarRE = /^\*+\.\*+$/;
-const starDotStarTest = (f) => !f.startsWith('.') && f.includes('.');
-const starDotStarTestDot = (f) => f !== '.' && f !== '..' && f.includes('.');
-const dotStarRE = /^\.\*+$/;
-const dotStarTest = (f) => f !== '.' && f !== '..' && f.startsWith('.');
-const starRE = /^\*+$/;
-const starTest = (f) => f.length !== 0 && !f.startsWith('.');
-const starTestDot = (f) => f.length !== 0 && f !== '.' && f !== '..';
-const qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
-const qmarksTestNocase = ([$0, ext = '']) => {
-    const noext = qmarksTestNoExt([$0]);
-    if (!ext)
-        return noext;
-    ext = ext.toLowerCase();
-    return (f) => noext(f) && f.toLowerCase().endsWith(ext);
-};
-const qmarksTestNocaseDot = ([$0, ext = '']) => {
-    const noext = qmarksTestNoExtDot([$0]);
-    if (!ext)
-        return noext;
-    ext = ext.toLowerCase();
-    return (f) => noext(f) && f.toLowerCase().endsWith(ext);
-};
-const qmarksTestDot = ([$0, ext = '']) => {
-    const noext = qmarksTestNoExtDot([$0]);
-    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
-};
-const qmarksTest = ([$0, ext = '']) => {
-    const noext = qmarksTestNoExt([$0]);
-    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
-};
-const qmarksTestNoExt = ([$0]) => {
-    const len = $0.length;
-    return (f) => f.length === len && !f.startsWith('.');
-};
-const qmarksTestNoExtDot = ([$0]) => {
-    const len = $0.length;
-    return (f) => f.length === len && f !== '.' && f !== '..';
-};
-/* c8 ignore start */
-const defaultPlatform = (typeof process === 'object' && process
-    ? (typeof process.env === 'object' &&
-        process.env &&
-        process.env.__MINIMATCH_TESTING_PLATFORM__) ||
-        process.platform
-    : 'posix');
-const path = {
-    win32: { sep: '\\' },
-    posix: { sep: '/' },
-};
-/* c8 ignore stop */
-const sep = defaultPlatform === 'win32' ? path.win32.sep : path.posix.sep;
-minimatch.sep = sep;
-const GLOBSTAR = Symbol('globstar **');
-minimatch.GLOBSTAR = GLOBSTAR;
-// any single thing other than /
-// don't need to escape / when using new RegExp()
-const qmark = '[^/]';
-// * => any number of characters
-const star = qmark + '*?';
-// ** when dots are allowed.  Anything goes, except .. and .
-// not (^ or / followed by one or two dots followed by $ or /),
-// followed by anything, any number of times.
-const twoStarDot = '(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?';
-// not a ^ or / followed by a dot,
-// followed by anything, any number of times.
-const twoStarNoDot = '(?:(?!(?:\\/|^)\\.).)*?';
-const filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
-minimatch.filter = filter;
-const ext = (a, b = {}) => Object.assign({}, a, b);
-const defaults = (def) => {
-    if (!def || typeof def !== 'object' || !Object.keys(def).length) {
-        return minimatch;
-    }
-    const orig = minimatch;
-    const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
-    return Object.assign(m, {
-        Minimatch: class Minimatch extends orig.Minimatch {
-            constructor(pattern, options = {}) {
-                super(pattern, ext(def, options));
-            }
-            static defaults(options) {
-                return orig.defaults(ext(def, options)).Minimatch;
-            }
-        },
-        AST: class AST extends orig.AST {
-            /* c8 ignore start */
-            constructor(type, parent, options = {}) {
-                super(type, parent, ext(def, options));
-            }
-            /* c8 ignore stop */
-            static fromGlob(pattern, options = {}) {
-                return orig.AST.fromGlob(pattern, ext(def, options));
-            }
-        },
-        unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
-        escape: (s, options = {}) => orig.escape(s, ext(def, options)),
-        filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
-        defaults: (options) => orig.defaults(ext(def, options)),
-        makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
-        braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
-        match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
-        sep: orig.sep,
-        GLOBSTAR: GLOBSTAR,
-    });
-};
-minimatch.defaults = defaults;
-// Brace expansion:
-// a{b,c}d -> abd acd
-// a{b,}c -> abc ac
-// a{0..3}d -> a0d a1d a2d a3d
-// a{b,c{d,e}f}g -> abg acdfg acefg
-// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
-//
-// Invalid sets are not expanded.
-// a{2..}b -> a{2..}b
-// a{b}c -> a{b}c
-const braceExpand = (pattern, options = {}) => {
-    assertValidPattern(pattern);
-    // Thanks to Yeting Li <https://github.com/yetingli> for
-    // improving this regexp to avoid a ReDOS vulnerability.
-    if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
-        // shortcut. no need to expand.
-        return [pattern];
-    }
-    return expand$1(pattern);
-};
-minimatch.braceExpand = braceExpand;
-// parse a component of the expanded set.
-// At this point, no pattern may contain "/" in it
-// so we're going to return a 2d array, where each entry is the full
-// pattern, split on '/', and then turned into a regular expression.
-// A regexp is made at the end which joins each array with an
-// escaped /, and another full one which joins each regexp with |.
-//
-// Following the lead of Bash 4.1, note that "**" only has special meaning
-// when it is the *only* thing in a path portion.  Otherwise, any series
-// of * is equivalent to a single *.  Globstar behavior is enabled by
-// default, and can be disabled by setting options.noglobstar.
-const makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
-minimatch.makeRe = makeRe;
-const match = (list, pattern, options = {}) => {
-    const mm = new Minimatch(pattern, options);
-    list = list.filter(f => mm.match(f));
-    if (mm.options.nonull && !list.length) {
-        list.push(pattern);
-    }
-    return list;
-};
-minimatch.match = match;
-// replace stuff like \* with *
-const globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
-const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-class Minimatch {
-    options;
-    set;
-    pattern;
-    windowsPathsNoEscape;
-    nonegate;
-    negate;
-    comment;
-    empty;
-    preserveMultipleSlashes;
-    partial;
-    globSet;
-    globParts;
-    nocase;
-    isWindows;
-    platform;
-    windowsNoMagicRoot;
-    regexp;
-    constructor(pattern, options = {}) {
-        assertValidPattern(pattern);
-        options = options || {};
-        this.options = options;
-        this.pattern = pattern;
-        this.platform = options.platform || defaultPlatform;
-        this.isWindows = this.platform === 'win32';
-        this.windowsPathsNoEscape =
-            !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
-        if (this.windowsPathsNoEscape) {
-            this.pattern = this.pattern.replace(/\\/g, '/');
-        }
-        this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
-        this.regexp = null;
-        this.negate = false;
-        this.nonegate = !!options.nonegate;
-        this.comment = false;
-        this.empty = false;
-        this.partial = !!options.partial;
-        this.nocase = !!this.options.nocase;
-        this.windowsNoMagicRoot =
-            options.windowsNoMagicRoot !== undefined
-                ? options.windowsNoMagicRoot
-                : !!(this.isWindows && this.nocase);
-        this.globSet = [];
-        this.globParts = [];
-        this.set = [];
-        // make the set of regexps etc.
-        this.make();
-    }
-    hasMagic() {
-        if (this.options.magicalBraces && this.set.length > 1) {
-            return true;
-        }
-        for (const pattern of this.set) {
-            for (const part of pattern) {
-                if (typeof part !== 'string')
-                    return true;
-            }
-        }
-        return false;
-    }
-    debug(..._) { }
-    make() {
-        const pattern = this.pattern;
-        const options = this.options;
-        // empty patterns and comments match nothing.
-        if (!options.nocomment && pattern.charAt(0) === '#') {
-            this.comment = true;
-            return;
-        }
-        if (!pattern) {
-            this.empty = true;
-            return;
-        }
-        // step 1: figure out negation, etc.
-        this.parseNegate();
-        // step 2: expand braces
-        this.globSet = [...new Set(this.braceExpand())];
-        if (options.debug) {
-            this.debug = (...args) => console.error(...args);
-        }
-        this.debug(this.pattern, this.globSet);
-        // step 3: now we have a set, so turn each one into a series of
-        // path-portion matching patterns.
-        // These will be regexps, except in the case of "**", which is
-        // set to the GLOBSTAR object for globstar behavior,
-        // and will not contain any / characters
-        //
-        // First, we preprocess to make the glob pattern sets a bit simpler
-        // and deduped.  There are some perf-killing patterns that can cause
-        // problems with a glob walk, but we can simplify them down a bit.
-        const rawGlobParts = this.globSet.map(s => this.slashSplit(s));
-        this.globParts = this.preprocess(rawGlobParts);
-        this.debug(this.pattern, this.globParts);
-        // glob --> regexps
-        let set = this.globParts.map((s, _, __) => {
-            if (this.isWindows && this.windowsNoMagicRoot) {
-                // check if it's a drive or unc path.
-                const isUNC = s[0] === '' &&
-                    s[1] === '' &&
-                    (s[2] === '?' || !globMagic.test(s[2])) &&
-                    !globMagic.test(s[3]);
-                const isDrive = /^[a-z]:/i.test(s[0]);
-                if (isUNC) {
-                    return [...s.slice(0, 4), ...s.slice(4).map(ss => this.parse(ss))];
-                }
-                else if (isDrive) {
-                    return [s[0], ...s.slice(1).map(ss => this.parse(ss))];
-                }
-            }
-            return s.map(ss => this.parse(ss));
-        });
-        this.debug(this.pattern, set);
-        // filter out everything that didn't compile properly.
-        this.set = set.filter(s => s.indexOf(false) === -1);
-        // do not treat the ? in UNC paths as magic
-        if (this.isWindows) {
-            for (let i = 0; i < this.set.length; i++) {
-                const p = this.set[i];
-                if (p[0] === '' &&
-                    p[1] === '' &&
-                    this.globParts[i][2] === '?' &&
-                    typeof p[3] === 'string' &&
-                    /^[a-z]:$/i.test(p[3])) {
-                    p[2] = '?';
-                }
-            }
-        }
-        this.debug(this.pattern, this.set);
-    }
-    // various transforms to equivalent pattern sets that are
-    // faster to process in a filesystem walk.  The goal is to
-    // eliminate what we can, and push all ** patterns as far
-    // to the right as possible, even if it increases the number
-    // of patterns that we have to process.
-    preprocess(globParts) {
-        // if we're not in globstar mode, then turn all ** into *
-        if (this.options.noglobstar) {
-            for (let i = 0; i < globParts.length; i++) {
-                for (let j = 0; j < globParts[i].length; j++) {
-                    if (globParts[i][j] === '**') {
-                        globParts[i][j] = '*';
-                    }
-                }
-            }
-        }
-        const { optimizationLevel = 1 } = this.options;
-        if (optimizationLevel >= 2) {
-            // aggressive optimization for the purpose of fs walking
-            globParts = this.firstPhasePreProcess(globParts);
-            globParts = this.secondPhasePreProcess(globParts);
-        }
-        else if (optimizationLevel >= 1) {
-            // just basic optimizations to remove some .. parts
-            globParts = this.levelOneOptimize(globParts);
-        }
-        else {
-            globParts = this.adjascentGlobstarOptimize(globParts);
-        }
-        return globParts;
-    }
-    // just get rid of adjascent ** portions
-    adjascentGlobstarOptimize(globParts) {
-        return globParts.map(parts => {
-            let gs = -1;
-            while (-1 !== (gs = parts.indexOf('**', gs + 1))) {
-                let i = gs;
-                while (parts[i + 1] === '**') {
-                    i++;
-                }
-                if (i !== gs) {
-                    parts.splice(gs, i - gs);
-                }
-            }
-            return parts;
-        });
-    }
-    // get rid of adjascent ** and resolve .. portions
-    levelOneOptimize(globParts) {
-        return globParts.map(parts => {
-            parts = parts.reduce((set, part) => {
-                const prev = set[set.length - 1];
-                if (part === '**' && prev === '**') {
-                    return set;
-                }
-                if (part === '..') {
-                    if (prev && prev !== '..' && prev !== '.' && prev !== '**') {
-                        set.pop();
-                        return set;
-                    }
-                }
-                set.push(part);
-                return set;
-            }, []);
-            return parts.length === 0 ? [''] : parts;
-        });
-    }
-    levelTwoFileOptimize(parts) {
-        if (!Array.isArray(parts)) {
-            parts = this.slashSplit(parts);
-        }
-        let didSomething = false;
-        do {
-            didSomething = false;
-            // <pre>/<e>/<rest> -> <pre>/<rest>
-            if (!this.preserveMultipleSlashes) {
-                for (let i = 1; i < parts.length - 1; i++) {
-                    const p = parts[i];
-                    // don't squeeze out UNC patterns
-                    if (i === 1 && p === '' && parts[0] === '')
-                        continue;
-                    if (p === '.' || p === '') {
-                        didSomething = true;
-                        parts.splice(i, 1);
-                        i--;
-                    }
-                }
-                if (parts[0] === '.' &&
-                    parts.length === 2 &&
-                    (parts[1] === '.' || parts[1] === '')) {
-                    didSomething = true;
-                    parts.pop();
-                }
-            }
-            // <pre>/<p>/../<rest> -> <pre>/<rest>
-            let dd = 0;
-            while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
-                const p = parts[dd - 1];
-                if (p && p !== '.' && p !== '..' && p !== '**') {
-                    didSomething = true;
-                    parts.splice(dd - 1, 2);
-                    dd -= 2;
-                }
-            }
-        } while (didSomething);
-        return parts.length === 0 ? [''] : parts;
-    }
-    // First phase: single-pattern processing
-    // <pre> is 1 or more portions
-    // <rest> is 1 or more portions
-    // <p> is any portion other than ., .., '', or **
-    // <e> is . or ''
-    //
-    // **/.. is *brutal* for filesystem walking performance, because
-    // it effectively resets the recursive walk each time it occurs,
-    // and ** cannot be reduced out by a .. pattern part like a regexp
-    // or most strings (other than .., ., and '') can be.
-    //
-    // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
-    // <pre>/<e>/<rest> -> <pre>/<rest>
-    // <pre>/<p>/../<rest> -> <pre>/<rest>
-    // **/**/<rest> -> **/<rest>
-    //
-    // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
-    // this WOULD be allowed if ** did follow symlinks, or * didn't
-    firstPhasePreProcess(globParts) {
-        let didSomething = false;
-        do {
-            didSomething = false;
-            // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
-            for (let parts of globParts) {
-                let gs = -1;
-                while (-1 !== (gs = parts.indexOf('**', gs + 1))) {
-                    let gss = gs;
-                    while (parts[gss + 1] === '**') {
-                        // <pre>/**/**/<rest> -> <pre>/**/<rest>
-                        gss++;
-                    }
-                    // eg, if gs is 2 and gss is 4, that means we have 3 **
-                    // parts, and can remove 2 of them.
-                    if (gss > gs) {
-                        parts.splice(gs + 1, gss - gs);
-                    }
-                    let next = parts[gs + 1];
-                    const p = parts[gs + 2];
-                    const p2 = parts[gs + 3];
-                    if (next !== '..')
-                        continue;
-                    if (!p ||
-                        p === '.' ||
-                        p === '..' ||
-                        !p2 ||
-                        p2 === '.' ||
-                        p2 === '..') {
-                        continue;
-                    }
-                    didSomething = true;
-                    // edit parts in place, and push the new one
-                    parts.splice(gs, 1);
-                    const other = parts.slice(0);
-                    other[gs] = '**';
-                    globParts.push(other);
-                    gs--;
-                }
-                // <pre>/<e>/<rest> -> <pre>/<rest>
-                if (!this.preserveMultipleSlashes) {
-                    for (let i = 1; i < parts.length - 1; i++) {
-                        const p = parts[i];
-                        // don't squeeze out UNC patterns
-                        if (i === 1 && p === '' && parts[0] === '')
-                            continue;
-                        if (p === '.' || p === '') {
-                            didSomething = true;
-                            parts.splice(i, 1);
-                            i--;
-                        }
-                    }
-                    if (parts[0] === '.' &&
-                        parts.length === 2 &&
-                        (parts[1] === '.' || parts[1] === '')) {
-                        didSomething = true;
-                        parts.pop();
-                    }
-                }
-                // <pre>/<p>/../<rest> -> <pre>/<rest>
-                let dd = 0;
-                while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
-                    const p = parts[dd - 1];
-                    if (p && p !== '.' && p !== '..' && p !== '**') {
-                        didSomething = true;
-                        const needDot = dd === 1 && parts[dd + 1] === '**';
-                        const splin = needDot ? ['.'] : [];
-                        parts.splice(dd - 1, 2, ...splin);
-                        if (parts.length === 0)
-                            parts.push('');
-                        dd -= 2;
-                    }
-                }
-            }
-        } while (didSomething);
-        return globParts;
-    }
-    // second phase: multi-pattern dedupes
-    // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
-    // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
-    // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
-    //
-    // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
-    // ^-- not valid because ** doens't follow symlinks
-    secondPhasePreProcess(globParts) {
-        for (let i = 0; i < globParts.length - 1; i++) {
-            for (let j = i + 1; j < globParts.length; j++) {
-                const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
-                if (!matched)
-                    continue;
-                globParts[i] = matched;
-                globParts[j] = [];
-            }
-        }
-        return globParts.filter(gs => gs.length);
-    }
-    partsMatch(a, b, emptyGSMatch = false) {
-        let ai = 0;
-        let bi = 0;
-        let result = [];
-        let which = '';
-        while (ai < a.length && bi < b.length) {
-            if (a[ai] === b[bi]) {
-                result.push(which === 'b' ? b[bi] : a[ai]);
-                ai++;
-                bi++;
-            }
-            else if (emptyGSMatch && a[ai] === '**' && b[bi] === a[ai + 1]) {
-                result.push(a[ai]);
-                ai++;
-            }
-            else if (emptyGSMatch && b[bi] === '**' && a[ai] === b[bi + 1]) {
-                result.push(b[bi]);
-                bi++;
-            }
-            else if (a[ai] === '*' &&
-                b[bi] &&
-                (this.options.dot || !b[bi].startsWith('.')) &&
-                b[bi] !== '**') {
-                if (which === 'b')
-                    return false;
-                which = 'a';
-                result.push(a[ai]);
-                ai++;
-                bi++;
-            }
-            else if (b[bi] === '*' &&
-                a[ai] &&
-                (this.options.dot || !a[ai].startsWith('.')) &&
-                a[ai] !== '**') {
-                if (which === 'a')
-                    return false;
-                which = 'b';
-                result.push(b[bi]);
-                ai++;
-                bi++;
-            }
-            else {
-                return false;
-            }
-        }
-        // if we fall out of the loop, it means they two are identical
-        // as long as their lengths match
-        return a.length === b.length && result;
-    }
-    parseNegate() {
-        if (this.nonegate)
-            return;
-        const pattern = this.pattern;
-        let negate = false;
-        let negateOffset = 0;
-        for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {
-            negate = !negate;
-            negateOffset++;
-        }
-        if (negateOffset)
-            this.pattern = pattern.slice(negateOffset);
-        this.negate = negate;
-    }
-    // set partial to true to test if, for example,
-    // "/a/b" matches the start of "/*/b/*/d"
-    // Partial means, if you run out of file before you run
-    // out of pattern, then that's fine, as long as all
-    // the parts match.
-    matchOne(file, pattern, partial = false) {
-        const options = this.options;
-        // UNC paths like //?/X:/... can match X:/... and vice versa
-        // Drive letters in absolute drive or unc paths are always compared
-        // case-insensitively.
-        if (this.isWindows) {
-            const fileDrive = typeof file[0] === 'string' && /^[a-z]:$/i.test(file[0]);
-            const fileUNC = !fileDrive &&
-                file[0] === '' &&
-                file[1] === '' &&
-                file[2] === '?' &&
-                /^[a-z]:$/i.test(file[3]);
-            const patternDrive = typeof pattern[0] === 'string' && /^[a-z]:$/i.test(pattern[0]);
-            const patternUNC = !patternDrive &&
-                pattern[0] === '' &&
-                pattern[1] === '' &&
-                pattern[2] === '?' &&
-                typeof pattern[3] === 'string' &&
-                /^[a-z]:$/i.test(pattern[3]);
-            const fdi = fileUNC ? 3 : fileDrive ? 0 : undefined;
-            const pdi = patternUNC ? 3 : patternDrive ? 0 : undefined;
-            if (typeof fdi === 'number' && typeof pdi === 'number') {
-                const [fd, pd] = [file[fdi], pattern[pdi]];
-                if (fd.toLowerCase() === pd.toLowerCase()) {
-                    pattern[pdi] = fd;
-                    if (pdi > fdi) {
-                        pattern = pattern.slice(pdi);
-                    }
-                    else if (fdi > pdi) {
-                        file = file.slice(fdi);
-                    }
-                }
-            }
-        }
-        // resolve and reduce . and .. portions in the file as well.
-        // dont' need to do the second phase, because it's only one string[]
-        const { optimizationLevel = 1 } = this.options;
-        if (optimizationLevel >= 2) {
-            file = this.levelTwoFileOptimize(file);
-        }
-        this.debug('matchOne', this, { file, pattern });
-        this.debug('matchOne', file.length, pattern.length);
-        for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
-            this.debug('matchOne loop');
-            var p = pattern[pi];
-            var f = file[fi];
-            this.debug(pattern, p, f);
-            // should be impossible.
-            // some invalid regexp stuff in the set.
-            /* c8 ignore start */
-            if (p === false) {
-                return false;
-            }
-            /* c8 ignore stop */
-            if (p === GLOBSTAR) {
-                this.debug('GLOBSTAR', [pattern, p, f]);
-                // "**"
-                // a/**/b/**/c would match the following:
-                // a/b/x/y/z/c
-                // a/x/y/z/b/c
-                // a/b/x/b/x/c
-                // a/b/c
-                // To do this, take the rest of the pattern after
-                // the **, and see if it would match the file remainder.
-                // If so, return success.
-                // If not, the ** "swallows" a segment, and try again.
-                // This is recursively awful.
-                //
-                // a/**/b/**/c matching a/b/x/y/z/c
-                // - a matches a
-                // - doublestar
-                //   - matchOne(b/x/y/z/c, b/**/c)
-                //     - b matches b
-                //     - doublestar
-                //       - matchOne(x/y/z/c, c) -> no
-                //       - matchOne(y/z/c, c) -> no
-                //       - matchOne(z/c, c) -> no
-                //       - matchOne(c, c) yes, hit
-                var fr = fi;
-                var pr = pi + 1;
-                if (pr === pl) {
-                    this.debug('** at the end');
-                    // a ** at the end will just swallow the rest.
-                    // We have found a match.
-                    // however, it will not swallow /.x, unless
-                    // options.dot is set.
-                    // . and .. are *never* matched by **, for explosively
-                    // exponential reasons.
-                    for (; fi < fl; fi++) {
-                        if (file[fi] === '.' ||
-                            file[fi] === '..' ||
-                            (!options.dot && file[fi].charAt(0) === '.'))
-                            return false;
-                    }
-                    return true;
-                }
-                // ok, let's see if we can swallow whatever we can.
-                while (fr < fl) {
-                    var swallowee = file[fr];
-                    this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
-                    // XXX remove this slice.  Just pass the start index.
-                    if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-                        this.debug('globstar found match!', fr, fl, swallowee);
-                        // found a match.
-                        return true;
-                    }
-                    else {
-                        // can't swallow "." or ".." ever.
-                        // can only swallow ".foo" when explicitly asked.
-                        if (swallowee === '.' ||
-                            swallowee === '..' ||
-                            (!options.dot && swallowee.charAt(0) === '.')) {
-                            this.debug('dot detected!', file, fr, pattern, pr);
-                            break;
-                        }
-                        // ** swallows a segment, and continue.
-                        this.debug('globstar swallow a segment, and continue');
-                        fr++;
-                    }
-                }
-                // no match was found.
-                // However, in partial mode, we can't say this is necessarily over.
-                /* c8 ignore start */
-                if (partial) {
-                    // ran out of file
-                    this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
-                    if (fr === fl) {
-                        return true;
-                    }
-                }
-                /* c8 ignore stop */
-                return false;
-            }
-            // something other than **
-            // non-magic patterns just have to match exactly
-            // patterns with magic have been turned into regexps.
-            let hit;
-            if (typeof p === 'string') {
-                hit = f === p;
-                this.debug('string match', p, f, hit);
-            }
-            else {
-                hit = p.test(f);
-                this.debug('pattern match', p, f, hit);
-            }
-            if (!hit)
-                return false;
-        }
-        // Note: ending in / means that we'll get a final ""
-        // at the end of the pattern.  This can only match a
-        // corresponding "" at the end of the file.
-        // If the file ends in /, then it can only match a
-        // a pattern that ends in /, unless the pattern just
-        // doesn't have any more for it. But, a/b/ should *not*
-        // match "a/b/*", even though "" matches against the
-        // [^/]*? pattern, except in partial mode, where it might
-        // simply not be reached yet.
-        // However, a/b/ should still satisfy a/*
-        // now either we fell off the end of the pattern, or we're done.
-        if (fi === fl && pi === pl) {
-            // ran out of pattern and filename at the same time.
-            // an exact hit!
-            return true;
-        }
-        else if (fi === fl) {
-            // ran out of file, but still had pattern left.
-            // this is ok if we're doing the match as part of
-            // a glob fs traversal.
-            return partial;
-        }
-        else if (pi === pl) {
-            // ran out of pattern, still have file left.
-            // this is only acceptable if we're on the very last
-            // empty segment of a file with a trailing slash.
-            // a/* should match a/b/
-            return fi === fl - 1 && file[fi] === '';
-            /* c8 ignore start */
-        }
-        else {
-            // should be unreachable.
-            throw new Error('wtf?');
-        }
-        /* c8 ignore stop */
-    }
-    braceExpand() {
-        return braceExpand(this.pattern, this.options);
-    }
-    parse(pattern) {
-        assertValidPattern(pattern);
-        const options = this.options;
-        // shortcuts
-        if (pattern === '**')
-            return GLOBSTAR;
-        if (pattern === '')
-            return '';
-        // far and away, the most common glob pattern parts are
-        // *, *.*, and *.<ext>  Add a fast check method for those.
-        let m;
-        let fastTest = null;
-        if ((m = pattern.match(starRE))) {
-            fastTest = options.dot ? starTestDot : starTest;
-        }
-        else if ((m = pattern.match(starDotExtRE))) {
-            fastTest = (options.nocase
-                ? options.dot
-                    ? starDotExtTestNocaseDot
-                    : starDotExtTestNocase
-                : options.dot
-                    ? starDotExtTestDot
-                    : starDotExtTest)(m[1]);
-        }
-        else if ((m = pattern.match(qmarksRE))) {
-            fastTest = (options.nocase
-                ? options.dot
-                    ? qmarksTestNocaseDot
-                    : qmarksTestNocase
-                : options.dot
-                    ? qmarksTestDot
-                    : qmarksTest)(m);
-        }
-        else if ((m = pattern.match(starDotStarRE))) {
-            fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
-        }
-        else if ((m = pattern.match(dotStarRE))) {
-            fastTest = dotStarTest;
-        }
-        const re = AST.fromGlob(pattern, this.options).toMMPattern();
-        return fastTest ? Object.assign(re, { test: fastTest }) : re;
-    }
-    makeRe() {
-        if (this.regexp || this.regexp === false)
-            return this.regexp;
-        // at this point, this.set is a 2d array of partial
-        // pattern strings, or "**".
-        //
-        // It's better to use .match().  This function shouldn't
-        // be used, really, but it's pretty convenient sometimes,
-        // when you just want to work with a regex.
-        const set = this.set;
-        if (!set.length) {
-            this.regexp = false;
-            return this.regexp;
-        }
-        const options = this.options;
-        const twoStar = options.noglobstar
-            ? star
-            : options.dot
-                ? twoStarDot
-                : twoStarNoDot;
-        const flags = new Set(options.nocase ? ['i'] : []);
-        // regexpify non-globstar patterns
-        // if ** is only item, then we just do one twoStar
-        // if ** is first, and there are more, prepend (\/|twoStar\/)? to next
-        // if ** is last, append (\/twoStar|) to previous
-        // if ** is in the middle, append (\/|\/twoStar\/) to previous
-        // then filter out GLOBSTAR symbols
-        let re = set
-            .map(pattern => {
-            const pp = pattern.map(p => {
-                if (p instanceof RegExp) {
-                    for (const f of p.flags.split(''))
-                        flags.add(f);
-                }
-                return typeof p === 'string'
-                    ? regExpEscape(p)
-                    : p === GLOBSTAR
-                        ? GLOBSTAR
-                        : p._src;
-            });
-            pp.forEach((p, i) => {
-                const next = pp[i + 1];
-                const prev = pp[i - 1];
-                if (p !== GLOBSTAR || prev === GLOBSTAR) {
-                    return;
-                }
-                if (prev === undefined) {
-                    if (next !== undefined && next !== GLOBSTAR) {
-                        pp[i + 1] = '(?:\\/|' + twoStar + '\\/)?' + next;
-                    }
-                    else {
-                        pp[i] = twoStar;
-                    }
-                }
-                else if (next === undefined) {
-                    pp[i - 1] = prev + '(?:\\/|' + twoStar + ')?';
-                }
-                else if (next !== GLOBSTAR) {
-                    pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next;
-                    pp[i + 1] = GLOBSTAR;
-                }
-            });
-            return pp.filter(p => p !== GLOBSTAR).join('/');
-        })
-            .join('|');
-        // need to wrap in parens if we had more than one thing with |,
-        // otherwise only the first will be anchored to ^ and the last to $
-        const [open, close] = set.length > 1 ? ['(?:', ')'] : ['', ''];
-        // must match entire pattern
-        // ending in a * or ** will make it less strict.
-        re = '^' + open + re + close + '$';
-        // can match anything, as long as it's not this.
-        if (this.negate)
-            re = '^(?!' + re + ').+$';
-        try {
-            this.regexp = new RegExp(re, [...flags].join(''));
-            /* c8 ignore start */
-        }
-        catch (ex) {
-            // should be impossible
-            this.regexp = false;
-        }
-        /* c8 ignore stop */
-        return this.regexp;
-    }
-    slashSplit(p) {
-        // if p starts with // on windows, we preserve that
-        // so that UNC paths aren't broken.  Otherwise, any number of
-        // / characters are coalesced into one, unless
-        // preserveMultipleSlashes is set to true.
-        if (this.preserveMultipleSlashes) {
-            return p.split('/');
-        }
-        else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
-            // add an extra '' for the one we lose
-            return ['', ...p.split(/\/+/)];
-        }
-        else {
-            return p.split(/\/+/);
-        }
-    }
-    match(f, partial = this.partial) {
-        this.debug('match', f, this.pattern);
-        // short-circuit in the case of busted things.
-        // comments, etc.
-        if (this.comment) {
-            return false;
-        }
-        if (this.empty) {
-            return f === '';
-        }
-        if (f === '/' && partial) {
-            return true;
-        }
-        const options = this.options;
-        // windows: need to use /, not \
-        if (this.isWindows) {
-            f = f.split('\\').join('/');
-        }
-        // treat the test path as a set of pathparts.
-        const ff = this.slashSplit(f);
-        this.debug(this.pattern, 'split', ff);
-        // just ONE of the pattern sets in this.set needs to match
-        // in order for it to be valid.  If negating, then just one
-        // match means that we have failed.
-        // Either way, return on the first hit.
-        const set = this.set;
-        this.debug(this.pattern, 'set', set);
-        // Find the basename of the path by looking for the last non-empty segment
-        let filename = ff[ff.length - 1];
-        if (!filename) {
-            for (let i = ff.length - 2; !filename && i >= 0; i--) {
-                filename = ff[i];
-            }
-        }
-        for (let i = 0; i < set.length; i++) {
-            const pattern = set[i];
-            let file = ff;
-            if (options.matchBase && pattern.length === 1) {
-                file = [filename];
-            }
-            const hit = this.matchOne(file, pattern, partial);
-            if (hit) {
-                if (options.flipNegate) {
-                    return true;
-                }
-                return !this.negate;
-            }
-        }
-        // didn't get any hits.  this is success if it's a negative
-        // pattern, failure otherwise.
-        if (options.flipNegate) {
-            return false;
-        }
-        return this.negate;
-    }
-    static defaults(def) {
-        return minimatch.defaults(def).Minimatch;
-    }
-}
-/* c8 ignore stop */
-minimatch.AST = AST;
-minimatch.Minimatch = Minimatch;
-minimatch.escape = escape;
-minimatch.unescape = unescape;
-
-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: __NODE_JS__ ? ((options === null || options === void 0 ? void 0 : options.htmlPattern) || ['*.{html,xhtml,xml,svg}']).map(p => new Minimatch(p, { matchBase: true })) : [],
-            textPattern: __NODE_JS__ ? ((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(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) {
-        if (__BROWSER__)
-            return;
-        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(s, { matchBase: true })) : null;
-        const exclude = opts.exclude && opts.exclude.length ? opts.exclude.map(s => new Minimatch(s, { matchBase: true })) : null;
-        const rename = opts.renameFile || (f => f);
-        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 = rename(filePath.slice(dirPath.length + 1));
-            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);
-    }
-}
-
-export { ProstoRewrite, genSafeFunc, getRewriter, getStringExpressionRewriter, pushString, renderCode };
+//#endregion
+export { ProstoRewrite, genFunc, genSafeFunc, getRewriter, getStringExpressionRewriter, pushString, renderCode };