@dcloudio/uni-app-uts 3.0.0-3080720230630001

package/dist/plugins/uvue/compiler/transforms/transformExpression.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyExpression = exports.processExpression = exports.transformExpression = void 0;
+const shared_1 = require("@vue/shared");
+const parser_1 = require("@babel/parser");
+const compiler_core_1 = require("@vue/compiler-core");
+const errors_1 = require("../errors");
+const GLOBALS_WHITE_LISTED = `Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,
+    decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,
+    Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console`;
+const isGloballyWhitelisted = /*#__PURE__*/ (0, shared_1.makeMap)(GLOBALS_WHITE_LISTED);
+const isLiteralWhitelisted = /*#__PURE__*/ (0, shared_1.makeMap)('true,false,null,this');
+const transformExpression = (node, context) => {
+    if (node.type === 5 /* NodeTypes.INTERPOLATION */) {
+        node.content = processExpression(node.content, context);
+    }
+    else if (node.type === 1 /* NodeTypes.ELEMENT */) {
+        // handle directives on element
+        for (let i = 0; i < node.props.length; i++) {
+            const dir = node.props[i];
+            // do not process for v-on & v-for since they are special handled
+            if (dir.type === 7 /* NodeTypes.DIRECTIVE */ && dir.name !== 'for') {
+                const exp = dir.exp;
+                const arg = dir.arg;
+                // do not process exp if this is v-on:arg - we need special handling
+                // for wrapping inline statements.
+                if (exp &&
+                    exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ &&
+                    !(dir.name === 'on' && arg)) {
+                    dir.exp = processExpression(exp, context, 
+                    // slot args must be processed as function params
+                    dir.name === 'slot');
+                }
+                if (arg && arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && !arg.isStatic) {
+                    dir.arg = processExpression(arg, context);
+                }
+            }
+        }
+    }
+};
+exports.transformExpression = transformExpression;
+// Important: since this function uses Node.js only dependencies, it should
+// always be used with a leading !__BROWSER__ check so that it can be
+// tree-shaken from the browser build.
+function processExpression(node, context, 
+// some expressions like v-slot props & v-for aliases should be parsed as
+// function params
+asParams = false, 
+// v-on handler values may contain multiple statements
+asRawStatements = false, localVars = Object.create(context.identifiers)) {
+    if (!context.prefixIdentifiers || !node.content.trim()) {
+        return node;
+    }
+    const { bindingMetadata } = context;
+    const rewriteIdentifier = (raw, parent, id) => {
+        const type = (0, shared_1.hasOwn)(bindingMetadata, raw) && bindingMetadata[raw];
+        if (type && type.startsWith('setup')) {
+            // setup bindings in non-inline mode
+            return `$setup.${raw}`;
+        }
+        else if (type === "props-aliased" /* BindingTypes.PROPS_ALIASED */) {
+            return `$props['${bindingMetadata.__propsAliases[raw]}']`;
+        }
+        else if (type) {
+            return `$${type}.${raw}`;
+        }
+        // fallback to ctx
+        return `_ctx.${raw}`;
+    };
+    // fast path if expression is a simple identifier.
+    const rawExp = node.content;
+    // bail constant on parens (function invocation) and dot (member access)
+    const bailConstant = rawExp.indexOf(`(`) > -1 || rawExp.indexOf('.') > 0;
+    if ((0, compiler_core_1.isSimpleIdentifier)(rawExp)) {
+        const isScopeVarReference = context.identifiers[rawExp];
+        const isAllowedGlobal = isGloballyWhitelisted(rawExp);
+        const isLiteral = isLiteralWhitelisted(rawExp);
+        if (!asParams && !isScopeVarReference && !isAllowedGlobal && !isLiteral) {
+            // const bindings exposed from setup can be skipped for patching but
+            // cannot be hoisted to module scope
+            if (bindingMetadata[node.content] === "setup-const" /* BindingTypes.SETUP_CONST */) {
+                node.constType = 1 /* ConstantTypes.CAN_SKIP_PATCH */;
+            }
+            node.content = rewriteIdentifier(rawExp);
+        }
+        else if (!isScopeVarReference) {
+            if (isLiteral) {
+                node.constType = 3 /* ConstantTypes.CAN_STRINGIFY */;
+            }
+            else {
+                node.constType = 2 /* ConstantTypes.CAN_HOIST */;
+            }
+        }
+        return node;
+    }
+    let ast;
+    // exp needs to be parsed differently:
+    // 1. Multiple inline statements (v-on, with presence of `;`): parse as raw
+    //    exp, but make sure to pad with spaces for consistent ranges
+    // 2. Expressions: wrap with parens (for e.g. object expressions)
+    // 3. Function arguments (v-for, v-slot): place in a function argument position
+    const source = asRawStatements
+        ? ` ${rawExp} `
+        : `(${rawExp})${asParams ? `=>{}` : ``}`;
+    try {
+        ast = (0, parser_1.parse)(source, {
+        // plugins: context.expressionPlugins
+        }).program;
+    }
+    catch (e) {
+        context.onError((0, errors_1.createCompilerError)(45 /* ErrorCodes.X_INVALID_EXPRESSION */, node.loc, undefined, e.message));
+        return node;
+    }
+    const ids = [];
+    const parentStack = [];
+    const knownIds = Object.create(context.identifiers);
+    (0, compiler_core_1.walkIdentifiers)(ast, (node, parent, _, isReferenced, isLocal) => {
+        if ((0, compiler_core_1.isStaticPropertyKey)(node, parent)) {
+            return;
+        }
+        const needPrefix = isReferenced && canPrefix(node);
+        if (needPrefix && !isLocal) {
+            if ((0, compiler_core_1.isStaticProperty)(parent) && parent.shorthand) {
+                // property shorthand like { foo }, we need to add the key since
+                // we rewrite the value
+                ;
+                node.prefix = `${node.name}: `;
+            }
+            node.name = rewriteIdentifier(node.name, parent, node);
+            ids.push(node);
+        }
+        else {
+            // The identifier is considered constant unless it's pointing to a
+            // local scope variable (a v-for alias, or a v-slot prop)
+            if (!(needPrefix && isLocal) && !bailConstant) {
+                ;
+                node.isConstant = true;
+            }
+            // also generate sub-expressions for other identifiers for better
+            // source map support. (except for property keys which are static)
+            ids.push(node);
+        }
+    }, true, // invoke on ALL identifiers
+    parentStack, knownIds);
+    // We break up the compound expression into an array of strings and sub
+    // expressions (for identifiers that have been prefixed). In codegen, if
+    // an ExpressionNode has the `.children` property, it will be used instead of
+    // `.content`.
+    const children = [];
+    ids.sort((a, b) => a.start - b.start);
+    ids.forEach((id, i) => {
+        // range is offset by -1 due to the wrapping parens when parsed
+        const start = id.start - 1;
+        const end = id.end - 1;
+        const last = ids[i - 1];
+        const leadingText = rawExp.slice(last ? last.end - 1 : 0, start);
+        if (leadingText.length || id.prefix) {
+            children.push(leadingText + (id.prefix || ``));
+        }
+        const source = rawExp.slice(start, end);
+        children.push((0, compiler_core_1.createSimpleExpression)(id.name, false, {
+            source,
+            start: (0, compiler_core_1.advancePositionWithClone)(node.loc.start, source, start),
+            end: (0, compiler_core_1.advancePositionWithClone)(node.loc.start, source, end),
+        }, id.isConstant ? 3 /* ConstantTypes.CAN_STRINGIFY */ : 0 /* ConstantTypes.NOT_CONSTANT */));
+        if (i === ids.length - 1 && end < rawExp.length) {
+            children.push(rawExp.slice(end));
+        }
+    });
+    let ret;
+    if (children.length) {
+        ret = (0, compiler_core_1.createCompoundExpression)(children, node.loc);
+    }
+    else {
+        ret = node;
+        ret.constType = bailConstant
+            ? 0 /* ConstantTypes.NOT_CONSTANT */
+            : 3 /* ConstantTypes.CAN_STRINGIFY */;
+    }
+    ret.identifiers = Object.keys(knownIds);
+    return ret;
+}
+exports.processExpression = processExpression;
+function canPrefix(id) {
+    // skip whitelisted globals
+    if (isGloballyWhitelisted(id.name)) {
+        return false;
+    }
+    // special case for webpack compilation
+    if (id.name === 'require') {
+        return false;
+    }
+    return true;
+}
+function stringifyExpression(exp) {
+    if ((0, shared_1.isString)(exp)) {
+        return exp;
+    }
+    else if (exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {
+        return exp.content;
+    }
+    else {
+        return exp.children
+            .map(stringifyExpression)
+            .join('');
+    }
+}
+exports.stringifyExpression = stringifyExpression;

package/dist/plugins/uvue/compiler/transforms/transformInterpolation.d.ts

@@ -0,0 +1,4 @@
+import { NodeTransform } from '../transform';
+import { TextNode, InterpolationNode, TemplateChildNode } from '@vue/compiler-core';
+export declare function isText(node: TemplateChildNode): node is TextNode | InterpolationNode;
+export declare const transformInterpolation: NodeTransform;

package/dist/plugins/uvue/compiler/transforms/transformInterpolation.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformInterpolation = exports.isText = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+// import { CREATE_TEXT } from '../runtimeHelpers'
+function isText(node) {
+    return node.type === 5 /* NodeTypes.INTERPOLATION */ || node.type === 2 /* NodeTypes.TEXT */;
+}
+exports.isText = isText;
+// Merge adjacent text nodes and expressions into a single expression
+// e.g. <div>abc {{ d }} {{ e }}</div> should have a single expression node as child.
+const transformInterpolation = (node, context) => {
+    if (node.type === 0 /* NodeTypes.ROOT */ ||
+        node.type === 1 /* NodeTypes.ELEMENT */ ||
+        node.type === 11 /* NodeTypes.FOR */ ||
+        node.type === 10 /* NodeTypes.IF_BRANCH */) {
+        // perform the transform on node exit so that all expressions have already
+        // been processed.
+        return () => {
+            const children = node.children;
+            let currentContainer = undefined;
+            // let hasText = false
+            for (let i = 0; i < children.length; i++) {
+                const child = children[i];
+                if (isText(child)) {
+                    // hasText = true
+                    for (let j = i + 1; j < children.length; j++) {
+                        const next = children[j];
+                        if (isText(next)) {
+                            if (!currentContainer) {
+                                currentContainer = children[i] = (0, compiler_core_1.createCompoundExpression)([child], child.loc);
+                            }
+                            // merge adjacent text node into current
+                            currentContainer.children.push(` + `, next);
+                            children.splice(j, 1);
+                            j--;
+                        }
+                        else {
+                            currentContainer = undefined;
+                            break;
+                        }
+                    }
+                }
+            }
+            // if (
+            //   !hasText ||
+            //   // if this is a plain element with a single text child, leave it
+            //   // as-is since the runtime has dedicated fast path for this by directly
+            //   // setting textContent of the element.
+            //   // for component root it's always normalized anyway.
+            //   (children.length === 1 &&
+            //     (node.type === NodeTypes.ROOT ||
+            //       (node.type === NodeTypes.ELEMENT &&
+            //         node.tagType === ElementTypes.ELEMENT &&
+            //         // #3756
+            //         // custom directives can potentially add DOM elements arbitrarily,
+            //         // we need to avoid setting textContent of the element at runtime
+            //         // to avoid accidentally overwriting the DOM elements added
+            //         // by the user through custom directives.
+            //         !node.props.find(
+            //           p =>
+            //             p.type === NodeTypes.DIRECTIVE &&
+            //             !context.directiveTransforms[p.name]
+            //         ) &&
+            //         // in compat mode, <template> tags with no special directives
+            //         // will be rendered as a fragment so its children must be
+            //         // converted into vnodes.
+            //         (node.tag !== 'template'))))
+            // ) {
+            //   return
+            // }
+            // pre-convert text nodes into createTextVNode(text) calls to avoid
+            // runtime normalization.
+            // for (let i = 0; i < children.length; i++) {
+            //   const child = children[i]
+            //   if (isText(child) || child.type === NodeTypes.COMPOUND_EXPRESSION) {
+            //     const callArgs: CallExpression['arguments'] = []
+            //     // createTextVNode defaults to single whitespace, so if it is a
+            //     // single space the code could be an empty call to save bytes.
+            //     if (child.type !== NodeTypes.TEXT || child.content !== ' ') {
+            //       callArgs.push(child)
+            //     }
+            //     // mark dynamic text with flag so it gets patched inside a block
+            //     if (
+            //       !context.ssr &&
+            //       getConstantType(child, context) === ConstantTypes.NOT_CONSTANT
+            //     ) {
+            //       callArgs.push(
+            //         PatchFlags.TEXT +
+            //           (__DEV__ ? ` /* ${PatchFlagNames[PatchFlags.TEXT]} */` : ``)
+            //       )
+            //     }
+            //     children[i] = {
+            //       type: NodeTypes.TEXT_CALL,
+            //       content: child,
+            //       loc: child.loc,
+            //       codegenNode: createCallExpression(
+            //         context.helper(CREATE_TEXT),
+            //         callArgs
+            //       )
+            //     }
+            //   }
+            // }
+        };
+    }
+};
+exports.transformInterpolation = transformInterpolation;

package/dist/plugins/uvue/compiler/transforms/transformSlotOutlet.d.ts

@@ -0,0 +1,10 @@
+import { NodeTransform, TransformContext } from '../transform';
+import { ExpressionNode, SlotOutletNode } from '@vue/compiler-core';
+import { PropsExpression } from '@vue/compiler-core';
+export declare const transformSlotOutlet: NodeTransform;
+interface SlotOutletProcessResult {
+    slotName: string | ExpressionNode;
+    slotProps: PropsExpression | undefined;
+}
+export declare function processSlotOutlet(node: SlotOutletNode, context: TransformContext): SlotOutletProcessResult;
+export {};

package/dist/plugins/uvue/compiler/transforms/transformSlotOutlet.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSlotOutlet = exports.transformSlotOutlet = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const compiler_core_2 = require("@vue/compiler-core");
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const shared_1 = require("@vue/shared");
+const transformSlotOutlet = (node, context) => {
+    if ((0, compiler_core_2.isSlotOutlet)(node)) {
+        const { children, loc } = node;
+        const { slotName, slotProps } = processSlotOutlet(node, context);
+        const slotArgs = [
+            context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
+            slotName,
+            '{}',
+            'undefined',
+            'true',
+        ];
+        let expectedLen = 2;
+        if (slotProps) {
+            slotArgs[2] = slotProps;
+            expectedLen = 3;
+        }
+        if (children.length) {
+            slotArgs[3] = (0, compiler_core_1.createFunctionExpression)([], children, false, false, loc);
+            expectedLen = 4;
+        }
+        if (context.scopeId && !context.slotted) {
+            expectedLen = 5;
+        }
+        slotArgs.splice(expectedLen) // remove unused arguments
+        ;
+        node.codegenNode = (0, compiler_core_1.createCallExpression)(context.helper(runtimeHelpers_1.RENDER_SLOT), slotArgs, loc);
+    }
+};
+exports.transformSlotOutlet = transformSlotOutlet;
+function processSlotOutlet(node, context) {
+    let slotName = `"default"`;
+    let slotProps = undefined;
+    const nonNameProps = [];
+    for (let i = 0; i < node.props.length; i++) {
+        const p = node.props[i];
+        if (p.type === 6 /* NodeTypes.ATTRIBUTE */) {
+            if (p.value) {
+                if (p.name === 'name') {
+                    slotName = JSON.stringify(p.value.content);
+                }
+                else {
+                    p.name = (0, shared_1.camelize)(p.name);
+                    nonNameProps.push(p);
+                }
+            }
+        }
+        else {
+            if (p.name === 'bind' && (0, compiler_core_2.isStaticArgOf)(p.arg, 'name')) {
+                if (p.exp)
+                    slotName = p.exp;
+            }
+            else {
+                if (p.name === 'bind' && p.arg && (0, compiler_core_2.isStaticExp)(p.arg)) {
+                    p.arg.content = (0, shared_1.camelize)(p.arg.content);
+                }
+                nonNameProps.push(p);
+            }
+        }
+    }
+    if (nonNameProps.length > 0) {
+        const { props, directives } = (0, compiler_core_1.buildProps)(node, context, nonNameProps, false, false);
+        slotProps = props;
+        if (directives.length) {
+            context.onError((0, compiler_core_1.createCompilerError)(36 /* ErrorCodes.X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET */, directives[0].loc));
+        }
+    }
+    return {
+        slotName,
+        slotProps,
+    };
+}
+exports.processSlotOutlet = processSlotOutlet;

package/dist/plugins/uvue/compiler/transforms/transformText.d.ts

@@ -0,0 +1,2 @@
+import { NodeTransform } from '../transform';
+export declare const transformText: NodeTransform;

package/dist/plugins/uvue/compiler/transforms/transformText.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformText = void 0;
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+function isTextNode({ tag }) {
+    return tag === 'text' || tag === 'u-text' || tag === 'button';
+}
+function isTextElement(node) {
+    return node.type === 1 /* NodeTypes.ELEMENT */ && node.tag === 'text';
+}
+function isText(node) {
+    const { type } = node;
+    return (type === 2 /* NodeTypes.TEXT */ ||
+        type === 12 /* NodeTypes.TEXT_CALL */ ||
+        type === 5 /* NodeTypes.INTERPOLATION */ ||
+        type === 8 /* NodeTypes.COMPOUND_EXPRESSION */);
+}
+const transformText = (node, _) => {
+    if (!(0, uni_cli_shared_1.isElementNode)(node)) {
+        return;
+    }
+    if (isTextNode(node)) {
+        return;
+    }
+    const { children } = node;
+    if (!children.length) {
+        return;
+    }
+    for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (isTextElement(child)) {
+            parseText(child);
+        }
+        let currentContainer = undefined;
+        if (isText(child)) {
+            if (!currentContainer) {
+                currentContainer = children[i] = createText(node, child);
+            }
+            for (let j = i + 1; j < children.length; j++) {
+                const next = children[j];
+                if (isText(next)) {
+                    // 合并相邻的文本节点
+                    currentContainer.children.push(next);
+                    children.splice(j, 1);
+                    j--;
+                }
+                else {
+                    currentContainer = undefined;
+                    break;
+                }
+            }
+        }
+    }
+};
+exports.transformText = transformText;
+/*
+  1. 转换 \\n 为 \n
+  2. u-text 下仅支持 slot 及 文本节点
+*/
+function parseText(node) {
+    if (node.children.length) {
+        let firstTextChild;
+        for (let i = 0; i < node.children.length; i++) {
+            const child = node.children[i];
+            if (isText(child) && typeof child.content === 'string') {
+                if (!firstTextChild) {
+                    firstTextChild = child;
+                    firstTextChild.content = firstTextChild.content.replace(/\\n/g, '\n');
+                }
+                else {
+                    ;
+                    firstTextChild.content += child.content.replace(/\\n/g, '\n');
+                    node.children.splice(i, 1);
+                    i--;
+                }
+            }
+            else if (child.type === 3) {
+                node.children.splice(i, 1);
+                i--;
+            }
+            else {
+                firstTextChild = null;
+            }
+        }
+    }
+}
+function createText(parent, node) {
+    return {
+        tag: 'text',
+        type: 1 /* NodeTypes.ELEMENT */,
+        tagType: 0 /* ElementTypes.ELEMENT */,
+        props: [],
+        isSelfClosing: false,
+        children: [node],
+        codegenNode: undefined,
+        ns: parent.ns,
+        loc: node.loc,
+    };
+}

package/dist/plugins/uvue/compiler/transforms/vBind.d.ts

@@ -0,0 +1,2 @@
+import { DirectiveTransform } from '../transform';
+export declare const transformBind: DirectiveTransform;

package/dist/plugins/uvue/compiler/transforms/vBind.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformBind = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const errors_1 = require("../errors");
+const shared_1 = require("@vue/shared");
+const compiler_core_2 = require("@vue/compiler-core");
+const utils_1 = require("../utils");
+// v-bind without arg is handled directly in ./transformElements.ts due to it affecting
+// codegen for the entire props object. This transform here is only for v-bind
+// *with* args.
+const transformBind = (dir, _node, context) => {
+    const { exp, modifiers, loc } = dir;
+    const arg = dir.arg;
+    if (arg.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */) {
+        arg.children.unshift(`(`);
+        arg.children.push(`) || ""`);
+    }
+    else if (!arg.isStatic) {
+        arg.content = `${arg.content} !== null ? ${arg.content} : ""`;
+    }
+    // .sync is replaced by v-model:arg
+    if (modifiers.includes('camel')) {
+        if (arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {
+            if (arg.isStatic) {
+                arg.content = (0, shared_1.camelize)(arg.content);
+            }
+            else {
+                arg.content = `${context.helperString(compiler_core_2.CAMELIZE)}(${arg.content})`;
+            }
+        }
+        else {
+            arg.children.unshift(`${context.helperString(compiler_core_2.CAMELIZE)}(`);
+            arg.children.push(`)`);
+        }
+    }
+    if (!false) {
+        if (modifiers.includes('prop')) {
+            injectPrefix(arg, '.');
+        }
+        if (modifiers.includes('attr')) {
+            injectPrefix(arg, '^');
+        }
+    }
+    if (!exp ||
+        (exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && !exp.content.trim())) {
+        context.onError((0, errors_1.createCompilerError)(34 /* ErrorCodes.X_V_BIND_NO_EXPRESSION */, loc));
+        return {
+            props: [(0, compiler_core_1.createObjectProperty)(arg, (0, compiler_core_1.createSimpleExpression)('', true, loc))],
+        };
+    }
+    if (exp.content && utils_1.objectExp.test(exp.content)) {
+        ;
+        exp.content = (0, utils_1.object2Map)(exp);
+    }
+    else if (exp.children) {
+        ;
+        exp.children.forEach((child, index) => {
+            if (typeof child === 'string' && utils_1.objectExp.test(child)) {
+                ;
+                exp.children[index] = (0, utils_1.object2Map)(child);
+            }
+        });
+    }
+    return {
+        props: [(0, compiler_core_1.createObjectProperty)(arg, exp)],
+    };
+};
+exports.transformBind = transformBind;
+const injectPrefix = (arg, prefix) => {
+    if (arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {
+        if (arg.isStatic) {
+            arg.content = prefix + arg.content;
+        }
+        else {
+            arg.content = `\`${prefix}\${${arg.content}}\``;
+        }
+    }
+    else {
+        arg.children.unshift(`'${prefix}' + (`);
+        arg.children.push(`)`);
+    }
+};

package/dist/plugins/uvue/compiler/transforms/vFor.d.ts

@@ -0,0 +1,12 @@
+import { ExpressionNode, SimpleExpressionNode, ElementNode, DirectiveNode, ForNode } from '@vue/compiler-core';
+import { TransformContext } from '../transform';
+export declare const transformFor: import("../transform").NodeTransform;
+export declare function processFor(node: ElementNode, dir: DirectiveNode, context: TransformContext, processCodegen?: (forNode: ForNode) => (() => void) | undefined): (() => void) | undefined;
+export interface ForParseResult {
+    source: ExpressionNode;
+    value: ExpressionNode | undefined;
+    key: ExpressionNode | undefined;
+    index: ExpressionNode | undefined;
+}
+export declare function parseForExpression(input: SimpleExpressionNode, context: TransformContext): ForParseResult | undefined;
+export declare function createForLoopParams({ value, key, index }: ForParseResult, memoArgs?: ExpressionNode[]): ExpressionNode[];