@fluffjs/cli 0.0.8 → 0.1.1

package/ExpressionTransformer.js

@@ -1,276 +1,604 @@
-import _generate from '@babel/generator';
 import { parse } from '@babel/parser';
-import _traverse from '@babel/traverse';
 import * as t from '@babel/types';
-const traverse = _traverse.default ?? _traverse;
-const generate = _generate.default ?? _generate;
-export function transformExpression(expr, options = {}) {
-    const { addThisPrefix: shouldAddThisPrefix = true, nullSafe = false, iteratorName, iteratorReplacement, localVars = [] } = options;
-    try {
-        const ast = parse(`(${expr})`, {
-            sourceType: 'module', plugins: ['typescript']
-        });
-        traverse(ast, {
-            Identifier(path) {
-                const { name } = path.node;
-                if (['true', 'false', 'null', 'undefined', 'this'].includes(name)) {
-                    return;
-                }
-                if (localVars.includes(name)) {
-                    return;
-                }
-                if (t.isMemberExpression(path.parent) && path.parent.property === path.node && !path.parent.computed) {
-                    return;
-                }
-                if (t.isOptionalMemberExpression(path.parent) && path.parent.property === path.node) {
-                    return;
-                }
-                if (iteratorName && name === iteratorName && iteratorReplacement) {
-                    const replacementAst = parse(`(${iteratorReplacement})`, { sourceType: 'module' });
-                    const [firstStmt] = replacementAst.program.body;
-                    if (!t.isExpressionStatement(firstStmt))
-                        return;
-                    const replacementExpr = firstStmt.expression;
-                    path.replaceWith(replacementExpr);
-                    return;
-                }
-                if (shouldAddThisPrefix) {
-                    path.replaceWith(t.memberExpression(t.thisExpression(), t.identifier(name)));
-                }
-            }
-        });
-        if (nullSafe) {
+import { generate, traverse } from './BabelHelpers.js';
+import { ErrorHelpers } from './ErrorHelpers.js';
+export class ExpressionTransformer {
+    static RESERVED_KEYWORDS = [
+        'true', 'false', 'null', 'undefined', 'this',
+        'void', 'typeof', 'delete', 'new', 'instanceof', 'in',
+        'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break', 'continue', 'return', 'throw',
+        'try', 'catch', 'finally', 'function', 'class', 'extends', 'super',
+        'import', 'export', 'default', 'const', 'let', 'var', 'async', 'await', 'yield',
+        'debugger', 'with',
+        '$event'
+    ];
+    static GLOBAL_OBJECTS = [
+        'Array', 'Object', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt',
+        'Math', 'Date', 'JSON', 'RegExp', 'Error', 'Map', 'Set', 'WeakMap', 'WeakSet',
+        'Promise', 'Proxy', 'Reflect', 'Intl',
+        'console', 'window', 'document', 'navigator', 'location', 'history',
+        'localStorage', 'sessionStorage', 'fetch', 'XMLHttpRequest',
+        'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'requestAnimationFrame',
+        'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'encodeURI', 'decodeURI',
+        'encodeURIComponent', 'decodeURIComponent', 'atob', 'btoa',
+        'Infinity', 'NaN', 'globalThis'
+    ];
+    static transformExpression(expr, options = {}) {
+        const { addThisPrefix: shouldAddThisPrefix = true, nullSafe = false, iteratorName, iteratorReplacement, localVars = [], localsObjectName, eventReplacementName, templateRefs = [] } = options;
+        try {
+            const ast = parse(`(${expr})`, {
+                sourceType: 'module', plugins: ['typescript']
+            });
             traverse(ast, {
-                MemberExpression: {
-                    exit(path) {
-                        const obj = path.node.object;
-                        const isThisMember = t.isMemberExpression(obj) && t.isThisExpression(obj.object);
-                        const isOptionalChain = t.isOptionalMemberExpression(obj);
-                        const isDeepChain = t.isMemberExpression(obj);
-                        if (!path.node.optional && (isThisMember || isOptionalChain || isDeepChain)) {
-                            const prop = path.node.property;
-                            if (t.isExpression(prop)) {
-                                const newNode = t.optionalMemberExpression(path.node.object, prop, path.node.computed, true);
-                                path.replaceWith(newNode);
+                Identifier(path) {
+                    const { name } = path.node;
+                    if (localsObjectName && name === localsObjectName) {
+                        return;
+                    }
+                    if (t.isMemberExpression(path.parent) && path.parent.property === path.node && !path.parent.computed) {
+                        return;
+                    }
+                    if (t.isOptionalMemberExpression(path.parent) && path.parent.property === path.node) {
+                        return;
+                    }
+                    if (t.isObjectProperty(path.parent) && path.parent.key === path.node && !path.parent.computed) {
+                        return;
+                    }
+                    if (name === '$event' && eventReplacementName) {
+                        path.replaceWith(t.identifier(eventReplacementName));
+                        return;
+                    }
+                    if (eventReplacementName && name === eventReplacementName) {
+                        return;
+                    }
+                    if (ExpressionTransformer.RESERVED_KEYWORDS.includes(name) || ExpressionTransformer.GLOBAL_OBJECTS.includes(name)) {
+                        return;
+                    }
+                    if (localVars.includes(name)) {
+                        if (localsObjectName) {
+                            path.replaceWith(t.memberExpression(t.identifier(localsObjectName), t.identifier(name)));
+                        }
+                        return;
+                    }
+                    if (templateRefs.includes(name)) {
+                        path.replaceWith(t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__getShadowRoot')), []), t.identifier('querySelector')), [t.stringLiteral(`[data-ref="${name}"]`)]));
+                        return;
+                    }
+                    if (t.isObjectProperty(path.parent) && path.parent.shorthand && path.parent.value === path.node) {
+                        const grandParent = path.parentPath?.parentPath?.node;
+                        if (grandParent && t.isObjectPattern(grandParent)) {
+                            return;
+                        }
+                    }
+                    const collectFunctionParams = (startPath) => {
+                        const params = new Set();
+                        let cur = startPath.parentPath;
+                        while (cur !== null) {
+                            if (t.isArrowFunctionExpression(cur.node) || t.isFunctionExpression(cur.node) || t.isFunctionDeclaration(cur.node)) {
+                                for (const param of cur.node.params) {
+                                    if (t.isIdentifier(param)) {
+                                        params.add(param.name);
+                                    }
+                                    else if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
+                                        params.add(param.left.name);
+                                    }
+                                    else if (t.isRestElement(param) && t.isIdentifier(param.argument)) {
+                                        params.add(param.argument.name);
+                                    }
+                                }
+                            }
+                            const next = cur.parentPath;
+                            if (next === null) {
+                                break;
                             }
+                            cur = next;
                         }
+                        return params;
+                    };
+                    if (collectFunctionParams(path)
+                        .has(name)) {
+                        return;
+                    }
+                    if (iteratorName && name === iteratorName && iteratorReplacement) {
+                        const replacementAst = parse(`(${iteratorReplacement})`, { sourceType: 'module' });
+                        const [firstStmt] = replacementAst.program.body;
+                        if (!t.isExpressionStatement(firstStmt))
+                            return;
+                        const replacementExpr = firstStmt.expression;
+                        path.replaceWith(replacementExpr);
+                        return;
+                    }
+                    if (shouldAddThisPrefix) {
+                        path.replaceWith(t.memberExpression(t.thisExpression(), t.identifier(name)));
                     }
                 }
             });
+            if (nullSafe) {
+                traverse(ast, {
+                    MemberExpression: {
+                        exit(path) {
+                            const obj = path.node.object;
+                            const isThisMember = t.isMemberExpression(obj) && t.isThisExpression(obj.object);
+                            const isOptionalChain = t.isOptionalMemberExpression(obj);
+                            const isDeepChain = t.isMemberExpression(obj);
+                            if (!path.node.optional && (isThisMember || isOptionalChain || isDeepChain)) {
+                                const prop = path.node.property;
+                                if (t.isExpression(prop)) {
+                                    const newNode = t.optionalMemberExpression(path.node.object, prop, path.node.computed, true);
+                                    path.replaceWith(newNode);
+                                }
+                            }
+                        }
+                    }
+                });
+            }
+            const output = generate(ast, { compact: true });
+            let { code } = output;
+            code = code.replace(/;+$/, '');
+            const isWrappedParens = (s) => {
+                if (!s.startsWith('(') || !s.endsWith(')'))
+                    return false;
+                let depth = 0;
+                for (let i = 0; i < s.length; i++) {
+                    if (s[i] === '(')
+                        depth++;
+                    else if (s[i] === ')')
+                        depth--;
+                    if (depth === 0 && i < s.length - 1)
+                        return false;
+                }
+                return depth === 0;
+            };
+            if (isWrappedParens(code)) {
+                code = code.slice(1, -1);
+            }
+            return code;
         }
-        const output = generate(ast, { compact: true });
-        let { code } = output;
-        if (code.startsWith('(') && code.endsWith(');')) {
-            code = code.slice(1, -2);
-        }
-        else if (code.startsWith('(') && code.endsWith(')')) {
-            code = code.slice(1, -1);
+        catch (e) {
+            const message = ErrorHelpers.getErrorMessage(e);
+            throw new Error(`Failed to parse expression "${expr}": ${message}`);
         }
-        code = code.replace(/;+$/, '');
-        return code;
     }
-    catch (e) {
-        const message = e instanceof Error ? e.message : String(e);
-        throw new Error(`Failed to parse expression "${expr}": ${message}`);
+    static addThisPrefix(expr) {
+        return ExpressionTransformer.transformExpression(expr, { addThisPrefix: true, nullSafe: false });
     }
-}
-export function addThisPrefix(expr) {
-    return transformExpression(expr, { addThisPrefix: true, nullSafe: false });
-}
-export function addThisPrefixSafe(expr) {
-    return transformExpression(expr, { addThisPrefix: true, nullSafe: true });
-}
-export function transformForExpression(expr, iteratorName, iteratorReplacement) {
-    return transformExpression(expr, {
-        addThisPrefix: true,
-        nullSafe: false,
-        iteratorName,
-        iteratorReplacement,
-        localVars: ['__items', '__idx', '__item']
-    });
-}
-export function transformForExpressionKeepIterator(expr, iteratorName) {
-    return transformExpression(expr, {
-        addThisPrefix: true, nullSafe: false, localVars: [iteratorName, '__items', '__idx', '__item', '__currentItems']
-    });
-}
-export function parsePipedExpression(expr) {
-    let remaining = expr.trim();
-    const pipes = [];
-    while (true) {
-        let pipeIdx = -1;
-        for (let i = remaining.length - 1; i >= 0; i--) {
-            if (remaining[i] === '|') {
-                if (remaining[i - 1] === '|' || remaining[i + 1] === '|')
-                    continue;
-                const left = remaining.slice(0, i)
-                    .trim();
-                if (!left)
-                    continue;
+    static addThisPrefixSafe(expr) {
+        return ExpressionTransformer.transformExpression(expr, { addThisPrefix: true, nullSafe: true });
+    }
+    static transformForExpression(expr, iteratorName, iteratorReplacement) {
+        return ExpressionTransformer.transformExpression(expr, {
+            addThisPrefix: true,
+            nullSafe: false,
+            iteratorName,
+            iteratorReplacement,
+            localVars: ['__items', '__idx', '__item']
+        });
+    }
+    static transformForExpressionKeepIterator(expr, iteratorName) {
+        return ExpressionTransformer.transformExpression(expr, {
+            addThisPrefix: true,
+            nullSafe: false,
+            localVars: [iteratorName, '__items', '__idx', '__item', '__currentItems']
+        });
+    }
+    static hasTokens(ast) {
+        return ast !== null && typeof ast === 'object' && 'tokens' in ast && Array.isArray(ast.tokens);
+    }
+    static hasLocIndex(e) {
+        if (e === null || typeof e !== 'object' || !('loc' in e))
+            return false;
+        const { loc } = e;
+        return loc !== null && typeof loc === 'object' && 'index' in loc && typeof loc.index === 'number';
+    }
+    static tokenizeExpression(code, startPos = 0) {
+        const substring = code.slice(startPos);
+        let tokens = [];
+        try {
+            const ast = parse(substring, {
+                sourceType: 'module',
+                tokens: true
+            });
+            if (ExpressionTransformer.hasTokens(ast)) {
+                ({ tokens } = ast);
+            }
+        }
+        catch (e) {
+            if (ExpressionTransformer.hasLocIndex(e)) {
+                const partialCode = substring.substring(0, e.loc.index);
                 try {
-                    parse(left, { sourceType: 'module' });
-                    pipeIdx = i;
-                    break;
+                    const partialAst = parse(partialCode, {
+                        sourceType: 'module',
+                        tokens: true
+                    });
+                    if (ExpressionTransformer.hasTokens(partialAst)) {
+                        ({ tokens } = partialAst);
+                    }
                 }
                 catch {
+                    return { index: startPos, tokenCount: 0, stopReason: 'end' };
                 }
             }
         }
-        if (pipeIdx === -1)
-            break;
-        const pipeExpr = remaining.slice(pipeIdx + 1)
-            .trim();
-        const colonParts = pipeExpr.split(':');
-        const pipeName = colonParts[0].trim();
-        const args = colonParts.slice(1)
-            .map(s => s.trim());
-        pipes.unshift({ name: pipeName, args });
-        remaining = remaining.slice(0, pipeIdx)
-            .trim();
-    }
-    return { expression: remaining, pipes };
-}
-export function transformInterpolation(expr, iteratorVar) {
-    const localVars = iteratorVar ? [iteratorVar] : [];
-    const { expression: baseExpr, pipes } = parsePipedExpression(expr);
-    if (pipes.length > 0) {
-        let result = transformExpression(baseExpr, { addThisPrefix: true, nullSafe: true, localVars });
-        for (const pipe of pipes) {
-            const argsStr = pipe.args.length > 0 ? ', ' + pipe.args.join(', ') : '';
-            result = `this.__pipe('${pipe.name}', ${result}${argsStr})`;
-        }
-        return `${result} ?? ''`;
-    }
-    const transformed = transformExpression(expr, { addThisPrefix: true, nullSafe: true, localVars });
-    return `${transformed} ?? ''`;
-}
-export function extractRootIdentifier(expr) {
-    try {
-        const ast = parse(expr, { sourceType: 'module' });
-        const [stmt] = ast.program.body;
-        if (!t.isExpressionStatement(stmt))
-            return null;
-        let node = stmt.expression;
-        while (true) {
-            if (t.isIdentifier(node)) {
-                return node.name;
+        let depth = 0;
+        let stopIndex = substring.length;
+        let stopReason = 'end';
+        let tokenCount = 0;
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (token.type.label === '(' || token.type.label === '[' || token.type.label === '{' || token.type.label === '${') {
+                depth++;
             }
-            else if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-                node = node.object;
+            if (token.type.label === ')' || token.type.label === ']' || token.type.label === '}') {
+                depth--;
             }
-            else if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
-                node = node.callee;
+            if (depth < 0) {
+                stopIndex = token.start;
+                stopReason = 'negative_depth';
+                tokenCount = i;
+                break;
             }
-            else if (t.isBinaryExpression(node) || t.isLogicalExpression(node)) {
-                node = node.left;
+            if (depth === 0 && (token.type.label === '|' || token.type.label === ';' || token.type.label === ':')) {
+                stopIndex = token.start;
+                stopReason = 'delimiter';
+                tokenCount = i;
+                break;
             }
-            else if (t.isUnaryExpression(node)) {
-                node = node.argument;
+            tokenCount = i + 1;
+        }
+        if (stopReason === 'end' && tokens.length > 0) {
+            stopIndex = tokens[tokens.length - 1].end;
+        }
+        return { index: startPos + stopIndex, tokenCount, stopReason };
+    }
+    static parseSecondaryExpression(input, startPos = 0) {
+        const substring = input.slice(startPos);
+        try {
+            parse(substring, { sourceType: 'module' });
+            return {
+                expression: substring.trim(),
+                endPos: input.length
+            };
+        }
+        catch (e) {
+            if (!(e instanceof Error) || !('pos' in e)) {
+                return null;
             }
-            else if (t.isConditionalExpression(node)) {
-                node = node.test;
+            const errorPos = typeof e.pos === 'number' ? e.pos : null;
+            if (errorPos === null || errorPos === 0) {
+                return null;
             }
-            else {
+            const candidate = substring.slice(0, errorPos)
+                .trim();
+            if (candidate.length === 0) {
+                return null;
+            }
+            try {
+                parse(candidate, { sourceType: 'module' });
+                return {
+                    expression: candidate,
+                    endPos: startPos + errorPos
+                };
+            }
+            catch {
                 return null;
             }
         }
     }
-    catch (e) {
-        const message = e instanceof Error ? e.message : String(e);
-        throw new Error(`Failed to parse expression "${expr}": ${message}`);
+    static parsePipeIdentifier(str, startPos) {
+        let pos = startPos;
+        while (pos < str.length && /\s/.test(str[pos])) {
+            pos++;
+        }
+        if (pos >= str.length)
+            return null;
+        const firstChar = str[pos];
+        if (!/[a-zA-Z_$]/.test(firstChar))
+            return null;
+        let name = firstChar;
+        pos++;
+        while (pos < str.length && /[a-zA-Z0-9_$]/.test(str[pos])) {
+            name += str[pos];
+            pos++;
+        }
+        return { name, endPos: pos };
     }
-}
-export function parseInterpolations(text) {
-    const results = [];
-    let searchStart = 0;
-    while (searchStart < text.length) {
-        const openIdx = text.indexOf('{{', searchStart);
-        if (openIdx === -1)
-            break;
-        let foundValid = false;
-        for (let closeIdx = openIdx + 3; closeIdx <= text.length; closeIdx++) {
-            if (text[closeIdx - 2] !== '}' || text[closeIdx - 1] !== '}')
-                continue;
-            const candidate = text.slice(openIdx + 2, closeIdx - 2)
-                .trim();
-            if (!candidate)
-                continue;
-            const { expression: baseExpr } = parsePipedExpression(candidate);
-            try {
-                parse(baseExpr, { sourceType: 'module' });
-                results.push({
-                    start: openIdx, end: closeIdx, expr: candidate
-                });
-                searchStart = closeIdx;
-                foundValid = true;
+    static parsePrimaryExpression(text, startPos) {
+        const offset = startPos ?? 0;
+        const pipes = [];
+        const tokenResult = ExpressionTransformer.tokenizeExpression(text, offset);
+        if (tokenResult.tokenCount === 0) {
+            return {
+                expression: text.slice(offset)
+                    .trim(), pipes: [], endPos: text.length
+            };
+        }
+        const baseCandidate = text.slice(offset, tokenResult.index)
+            .trim();
+        const baseResult = ExpressionTransformer.parseSecondaryExpression(baseCandidate);
+        if (!baseResult) {
+            return { expression: baseCandidate, pipes: [], endPos: tokenResult.index };
+        }
+        const baseExpression = baseResult.expression;
+        if (tokenResult.stopReason !== 'delimiter') {
+            return { expression: baseExpression, pipes: [], endPos: tokenResult.index };
+        }
+        const delimChar = text[tokenResult.index];
+        if (delimChar !== '|') {
+            return { expression: baseExpression, pipes: [], endPos: tokenResult.index };
+        }
+        let pos = tokenResult.index + 1;
+        while (pos < text.length) {
+            const pipeId = ExpressionTransformer.parsePipeIdentifier(text, pos);
+            if (!pipeId || pipeId.name.length === 0)
                 break;
+            const pipeName = pipeId.name;
+            const args = [];
+            pos = pipeId.endPos;
+            while (pos < text.length && /\s/.test(text[pos])) {
+                pos++;
             }
-            catch {
+            while (pos < text.length && text[pos] === ':') {
+                pos++;
+                while (pos < text.length && /\s/.test(text[pos])) {
+                    pos++;
+                }
+                const prefix = `_arg${args.length + 1}=`;
+                const argText = prefix + text.slice(pos);
+                const argTokenResult = ExpressionTransformer.tokenizeExpression(argText, 0);
+                const argEndPos = argTokenResult.index - prefix.length;
+                if (argTokenResult.tokenCount > 0) {
+                    const argCandidate = text.slice(pos, pos + argEndPos)
+                        .trim();
+                    const argParsed = ExpressionTransformer.parseSecondaryExpression(argCandidate);
+                    if (argParsed) {
+                        args.push(argParsed.expression);
+                    }
+                    else {
+                        args.push(argCandidate);
+                    }
+                    pos = pos + argEndPos;
+                    if (argTokenResult.stopReason === 'delimiter' && argText[argTokenResult.index] === '|') {
+                        break;
+                    }
+                }
+                else {
+                    break;
+                }
+            }
+            pipes.push({ name: pipeName, args });
+            while (pos < text.length && /\s/.test(text[pos])) {
+                pos++;
+            }
+            if (pos < text.length && text[pos] === '|') {
+                pos++;
+            }
+            else {
+                break;
             }
         }
-        if (!foundValid) {
-            searchStart = openIdx + 2;
-        }
+        return { expression: baseExpression, pipes, endPos: pos };
     }
-    return results;
-}
-export function transformPipedExpression(expr, addThisPrefixToExpr = true) {
-    const { expression, pipes } = parsePipedExpression(expr);
-    if (pipes.length === 0) {
-        return expression;
+    static transformInterpolation(expr, iteratorVar) {
+        const localVars = iteratorVar ? [iteratorVar] : [];
+        const { expression: baseExpr, pipes } = ExpressionTransformer.parsePrimaryExpression(expr);
+        if (pipes.length > 0) {
+            const resultStr = ExpressionTransformer.transformExpression(baseExpr, {
+                addThisPrefix: true,
+                nullSafe: true,
+                localVars
+            });
+            let resultExpr = ExpressionTransformer.parseExpressionToAst(resultStr);
+            for (const pipe of pipes) {
+                const transformedArgs = pipe.args.map(arg => ExpressionTransformer.parseExpressionToAst(ExpressionTransformer.transformExpression(arg, {
+                    addThisPrefix: true,
+                    nullSafe: true,
+                    localVars
+                })));
+                resultExpr = t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__pipe')), [t.stringLiteral(pipe.name), resultExpr, ...transformedArgs]);
+            }
+            const nullishExpr = t.logicalExpression('??', resultExpr, t.stringLiteral(''));
+            return generate(t.program([t.expressionStatement(nullishExpr)]), { compact: true })
+                .code
+                .replace(/;$/, '');
+        }
+        const transformed = ExpressionTransformer.transformExpression(expr, {
+            addThisPrefix: true,
+            nullSafe: true,
+            localVars
+        });
+        const transformedExpr = ExpressionTransformer.parseExpressionToAst(transformed);
+        const nullishExpr = t.logicalExpression('??', transformedExpr, t.stringLiteral(''));
+        return generate(t.program([t.expressionStatement(nullishExpr)]), { compact: true })
+            .code
+            .replace(/;$/, '');
     }
-    let result = addThisPrefixToExpr ? transformExpression(expression, {
-        addThisPrefix: true,
-        nullSafe: true
-    }) : expression;
-    for (const pipe of pipes) {
-        const argsStr = pipe.args.length > 0 ? ', ' + pipe.args.join(', ') : '';
-        result = `this.__pipe('${pipe.name}', ${result}${argsStr})`;
+    static parseExpressionToAst(expr) {
+        const ast = parse(`(${expr})`, { sourceType: 'module' });
+        const [stmt] = ast.program.body;
+        if (t.isExpressionStatement(stmt)) {
+            return stmt.expression;
+        }
+        return t.identifier('undefined');
     }
-    return result;
-}
-export function renameVariable(expr, oldName, newName) {
-    try {
-        const ast = parse(expr, { sourceType: 'module' });
-        traverse(ast, {
-            Identifier(path) {
-                if (path.node.name === oldName) {
-                    if (t.isMemberExpression(path.parent) && path.parent.property === path.node && !path.parent.computed) {
-                        return;
+    static extractRootIdentifier(expr) {
+        try {
+            const ast = parse(`(${expr})`, { sourceType: 'module' });
+            const [stmt] = ast.program.body;
+            if (!t.isExpressionStatement(stmt))
+                return null;
+            let node = stmt.expression;
+            while (true) {
+                if (t.isIdentifier(node)) {
+                    return node.name;
+                }
+                else if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+                    node = node.object;
+                }
+                else if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
+                    node = node.callee;
+                }
+                else if (t.isBinaryExpression(node) || t.isLogicalExpression(node)) {
+                    node = node.left;
+                }
+                else if (t.isUnaryExpression(node)) {
+                    node = node.argument;
+                }
+                else if (t.isConditionalExpression(node)) {
+                    node = node.test;
+                }
+                else if (t.isAwaitExpression(node)) {
+                    node = node.argument;
+                }
+                else if (t.isAssignmentExpression(node)) {
+                    node = node.left;
+                }
+                else if (t.isParenthesizedExpression(node)) {
+                    node = node.expression;
+                }
+                else if (t.isObjectExpression(node)) {
+                    let foundSpread = undefined;
+                    for (const prop of node.properties) {
+                        if (t.isSpreadElement(prop)) {
+                            foundSpread = prop;
+                            break;
+                        }
+                    }
+                    if (foundSpread) {
+                        node = foundSpread.argument;
+                    }
+                    else {
+                        return null;
                     }
-                    path.node.name = newName;
+                }
+                else {
+                    return null;
                 }
             }
-        });
-        let { code } = generate(ast, { compact: false });
-        if (code.endsWith(';'))
-            code = code.slice(0, -1);
-        return code;
+        }
+        catch (e) {
+            const message = ErrorHelpers.getErrorMessage(e);
+            throw new Error(`Failed to parse expression "${expr}": ${message}`);
+        }
     }
-    catch (e) {
-        const message = e instanceof Error ? e.message : String(e);
-        throw new Error(`Failed to parse expression "${expr}": ${message}`);
+    static parseInterpolations(text) {
+        const results = [];
+        let searchStart = 0;
+        while (searchStart < text.length) {
+            const openIdx = text.indexOf('{{', searchStart);
+            if (openIdx === -1)
+                break;
+            let foundValid = false;
+            for (let closeIdx = openIdx + 3; closeIdx <= text.length; closeIdx++) {
+                if (text[closeIdx - 2] !== '}' || text[closeIdx - 1] !== '}')
+                    continue;
+                const candidate = text.slice(openIdx + 2, closeIdx - 2)
+                    .trim();
+                if (!candidate)
+                    continue;
+                const { expression: baseExpr } = ExpressionTransformer.parsePrimaryExpression(candidate);
+                try {
+                    parse(`(${baseExpr})`, { sourceType: 'module' });
+                    results.push({
+                        start: openIdx, end: closeIdx, expr: candidate
+                    });
+                    searchStart = closeIdx;
+                    foundValid = true;
+                    break;
+                }
+                catch {
+                }
+            }
+            if (!foundValid) {
+                searchStart = openIdx + 2;
+            }
+        }
+        return results;
     }
-}
-export function expressionUsesVariable(expr, varName) {
-    try {
-        const ast = parse(expr, { sourceType: 'module' });
-        let found = false;
-        traverse(ast, {
-            Identifier(path) {
-                if (path.node.name === varName) {
-                    if (t.isMemberExpression(path.parent) && path.parent.property === path.node && !path.parent.computed) {
-                        return;
+    static transformPipedExpression(expr, addThisPrefixToExpr = true) {
+        const { expression, pipes } = ExpressionTransformer.parsePrimaryExpression(expr);
+        if (pipes.length === 0) {
+            return expression;
+        }
+        const resultStr = addThisPrefixToExpr ? ExpressionTransformer.transformExpression(expression, {
+            addThisPrefix: true,
+            nullSafe: true
+        }) : expression;
+        let resultExpr = ExpressionTransformer.parseExpressionToAst(resultStr);
+        for (const pipe of pipes) {
+            const transformedArgs = addThisPrefixToExpr
+                ? pipe.args.map(arg => ExpressionTransformer.parseExpressionToAst(ExpressionTransformer.transformExpression(arg, {
+                    addThisPrefix: true,
+                    nullSafe: true
+                })))
+                : pipe.args.map(arg => ExpressionTransformer.parseExpressionToAst(arg));
+            resultExpr = t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__pipe')), [t.stringLiteral(pipe.name), resultExpr, ...transformedArgs]);
+        }
+        return generate(t.program([t.expressionStatement(resultExpr)]), { compact: true })
+            .code
+            .replace(/;$/, '');
+    }
+    static renameVariable(expr, oldName, newName) {
+        try {
+            const ast = parse(expr, { sourceType: 'module' });
+            traverse(ast, {
+                Identifier(path) {
+                    if (path.node.name === oldName) {
+                        if (t.isMemberExpression(path.parent) && path.parent.property === path.node && !path.parent.computed) {
+                            return;
+                        }
+                        path.node.name = newName;
                     }
-                    found = true;
-                    path.stop();
                 }
-            }
-        });
-        return found;
+            });
+            let { code } = generate(ast, { compact: false });
+            if (code.endsWith(';'))
+                code = code.slice(0, -1);
+            return code;
+        }
+        catch (e) {
+            const message = ErrorHelpers.getErrorMessage(e);
+            throw new Error(`Failed to parse expression "${expr}": ${message}`);
+        }
     }
-    catch (e) {
-        const message = e instanceof Error ? e.message : String(e);
-        throw new Error(`Failed to parse expression "${expr}": ${message}`);
+    static expressionUsesVariable(expr, varName) {
+        try {
+            const { expression: baseExpr } = ExpressionTransformer.parsePrimaryExpression(expr);
+            const ast = parse(`(${baseExpr})`, { sourceType: 'module' });
+            let found = false;
+            traverse(ast, {
+                Identifier(path) {
+                    if (path.node.name === varName) {
+                        if (t.isMemberExpression(path.parent) && path.parent.property === path.node && !path.parent.computed) {
+                            return;
+                        }
+                        found = true;
+                        path.stop();
+                    }
+                }
+            });
+            return found;
+        }
+        catch (e) {
+            const message = ErrorHelpers.getErrorMessage(e);
+            throw new Error(`Failed to parse expression "${expr}": ${message}`);
+        }
+    }
+    static replaceThisExpression(expr, replacement) {
+        try {
+            const ast = parse(expr, { sourceType: 'module' });
+            traverse(ast, {
+                ThisExpression(path) {
+                    path.replaceWith(t.identifier(replacement));
+                }
+            });
+            let { code } = generate(ast, { compact: false });
+            if (code.endsWith(';'))
+                code = code.slice(0, -1);
+            return code;
+        }
+        catch (e) {
+            const message = ErrorHelpers.getErrorMessage(e);
+            throw new Error(`Failed to parse expression "${expr}": ${message}`);
+        }
     }
 }