@dcloudio/uni-mp-compiler 0.0.1-nvue3.3030820220125001

package/dist/transforms/transformComponent.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewritePropsBinding = exports.isPropsBinding = exports.rewriteBinding = exports.transformComponent = void 0;
+const shared_1 = require("@vue/shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const transform_1 = require("../transform");
+const utils_1 = require("./utils");
+const codegen_1 = require("../codegen");
+const types_1 = require("@babel/types");
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const ast_1 = require("../ast");
+const vIf_1 = require("./vIf");
+const transformComponent = (node, context) => {
+    if (!(0, uni_cli_shared_1.isUserComponent)(node, context)) {
+        return;
+    }
+    addComponentType(node, context);
+    addVueId(node, context);
+    processBooleanAttr(node);
+    return function postTransformComponent() {
+        context.vueIds.pop();
+    };
+};
+exports.transformComponent = transformComponent;
+function addComponentType(node, context) {
+    if (!context.isMiniProgramComponent(node.tag)) {
+        return;
+    }
+    node.props.push((0, uni_cli_shared_1.createAttributeNode)(utils_1.ATTR_COM_TYPE, 'm'));
+}
+function addVueId(node, context) {
+    let { hashId, scopes, currentScope, currentVueId } = context;
+    if (!hashId) {
+        return;
+    }
+    let vueId = hashId + '-' + scopes.vueId++;
+    const indexs = [];
+    while (currentScope) {
+        if ((0, transform_1.isVForScope)(currentScope)) {
+            indexs.push(`+'-'+${currentScope.indexAlias}`);
+        }
+        currentScope = currentScope.parent;
+    }
+    const inFor = !!indexs.length;
+    if (inFor) {
+        vueId = `'${vueId}'` + indexs.reverse().join('');
+    }
+    context.vueIds.push(vueId);
+    let value = vueId;
+    if (currentVueId) {
+        const isParentDynamic = currentVueId.includes('+');
+        const isCurrentDynamic = vueId.includes('+');
+        if (isParentDynamic || isCurrentDynamic) {
+            value = `(${vueId})+','+(${isParentDynamic ? currentVueId : `'${currentVueId}'`})`;
+        }
+        else {
+            value = vueId + ',' + currentVueId;
+        }
+    }
+    if (value.includes('+')) {
+        return node.props.push((0, uni_cli_shared_1.createBindDirectiveNode)(utils_1.ATTR_VUE_ID, value));
+    }
+    return node.props.push((0, uni_cli_shared_1.createAttributeNode)(utils_1.ATTR_VUE_ID, value));
+}
+/**
+ * <uni-collapse accordion/> => <uni-collapse :accordion="true"/>
+ * 否则部分平台(快手)可能获取到的 accordion 是空字符串
+ * @param param0
+ */
+function processBooleanAttr({ props }) {
+    props.forEach((prop, index) => {
+        if (prop.type === 6 /* ATTRIBUTE */ &&
+            typeof prop.value === 'undefined') {
+            props.splice(index, 1, (0, uni_cli_shared_1.createBindDirectiveNode)(prop.name, 'true'));
+        }
+    });
+}
+const builtInProps = [
+    'id',
+    'class',
+    'style',
+    utils_1.ATTR_VUE_ID,
+    utils_1.ATTR_VUE_PROPS,
+    utils_1.ATTR_VUE_SLOTS,
+    utils_1.ATTR_VUE_REF,
+    utils_1.ATTR_VUE_REF_IN_FOR,
+    utils_1.ATTR_COM_TYPE,
+    'eO',
+    'e-o',
+    'onVI',
+    'ref',
+    'slot',
+    'key',
+    'is',
+];
+function isComponentProp(name) {
+    if (builtInProps.includes(name)) {
+        return false;
+    }
+    if (name.startsWith('data-')) {
+        return false;
+    }
+    return true;
+}
+/**
+ * 重写组件 props 绑定
+ * @param node
+ * @param context
+ */
+function rewriteBinding({ tag, props }, context) {
+    var _a;
+    const isMiniProgramComponent = context.isMiniProgramComponent(tag);
+    const createObjectProperty = isMiniProgramComponent
+        ? (name, value) => (0, types_1.objectProperty)((0, types_1.identifier)((0, shared_1.camelize)(name)), value)
+        : (name, value) => {
+            const computed = !(0, compiler_core_1.isSimpleIdentifier)(name);
+            return (0, types_1.objectProperty)(computed ? (0, types_1.stringLiteral)(name) : (0, types_1.identifier)(name), value, computed);
+        };
+    const properties = [];
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        if (prop.type === 6 /* ATTRIBUTE */) {
+            const { name } = prop;
+            if (!isComponentProp(name)) {
+                continue;
+            }
+            properties.push(createObjectProperty(name, (0, types_1.stringLiteral)(((_a = prop.value) === null || _a === void 0 ? void 0 : _a.content) || '')));
+        }
+        else if (prop.type === 7 /* DIRECTIVE */) {
+            if (prop.name !== 'bind') {
+                continue;
+            }
+            const { arg, exp } = prop;
+            if (!arg || !exp) {
+                continue;
+            }
+            if ((0, compiler_core_1.isStaticExp)(arg)) {
+                if (!isComponentProp(arg.content)) {
+                    continue;
+                }
+                // :name="name"
+                const valueExpr = (0, ast_1.parseExpr)((0, codegen_1.genExpr)(exp), context, exp);
+                if (!valueExpr) {
+                    continue;
+                }
+                properties.push(createObjectProperty(arg.content, valueExpr));
+            }
+            else {
+                // :[dynamic]="dynamic"
+                const leftExpr = (0, ast_1.parseExpr)((0, codegen_1.genExpr)(arg), context, exp);
+                if (!leftExpr) {
+                    continue;
+                }
+                const valueExpr = (0, ast_1.parseExpr)((0, codegen_1.genExpr)(exp), context, exp);
+                if (!valueExpr) {
+                    continue;
+                }
+                properties.push((0, types_1.objectProperty)((0, types_1.logicalExpression)('||', leftExpr, (0, types_1.stringLiteral)('')), valueExpr, true));
+            }
+        }
+        props.splice(i, 1);
+        i--;
+    }
+    if (properties.length) {
+        props.push((0, uni_cli_shared_1.createBindDirectiveNode)(utils_1.ATTR_VUE_PROPS, (0, codegen_1.genBabelExpr)((0, types_1.objectExpression)(properties))));
+    }
+}
+exports.rewriteBinding = rewriteBinding;
+function isPropsBinding({ arg }) {
+    return (arg &&
+        arg.type === 4 /* SIMPLE_EXPRESSION */ &&
+        arg.content === utils_1.ATTR_VUE_PROPS);
+}
+exports.isPropsBinding = isPropsBinding;
+function rewritePropsBinding(dir, node, context) {
+    dir.exp = (0, compiler_core_1.createSimpleExpression)((0, codegen_1.genBabelExpr)((0, utils_1.rewirteWithHelper)(runtimeHelpers_1.RENDER_PROPS, (0, ast_1.parseExpr)(dir.exp, context), dir.loc, context)) + ((0, vIf_1.isIfElementNode)(node) && node.vIf.name === 'else' ? `||''` : ''));
+}
+exports.rewritePropsBinding = rewritePropsBinding;

package/dist/transforms/transformElement.d.ts

@@ -0,0 +1,9 @@
+import { ElementNode, TemplateLiteral, Property } from '@vue/compiler-core';
+import { NodeTransform, TransformContext } from '../transform';
+export interface DirectiveTransformResult {
+    props: Property[];
+    needRuntime?: boolean | symbol;
+    ssrTagParts?: TemplateLiteral['elements'];
+}
+export declare const transformElement: NodeTransform;
+export declare function processProps(node: ElementNode, context: TransformContext, props?: ElementNode['props']): void;

package/dist/transforms/transformElement.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processProps = exports.transformElement = void 0;
+const shared_1 = require("@vue/shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const uni_shared_1 = require("@dcloudio/uni-shared");
+const errors_1 = require("../errors");
+const vModel_1 = require("./vModel");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const transformElement = (node, context) => {
+    return function postTransformElement() {
+        node = context.currentNode;
+        if (!(node.type === 1 /* ELEMENT */ &&
+            (node.tagType === 0 /* ELEMENT */ ||
+                node.tagType === 1 /* COMPONENT */))) {
+            return;
+        }
+        if (node.tagType === 1 /* COMPONENT */) {
+            processComponent(node, context);
+        }
+        if (context.scopeId) {
+            addScopeId(node, context.scopeId);
+        }
+        const { props } = node;
+        if (props.length > 0) {
+            processProps(node, context);
+        }
+    };
+};
+exports.transformElement = transformElement;
+function addScopeId(node, scopeId) {
+    return (0, uni_cli_shared_1.addStaticClass)(node, scopeId);
+}
+function processComponent(node, context) {
+    const { tag } = node;
+    if (context.bindingComponents[tag]) {
+        return;
+    }
+    // 1. dynamic component
+    if ((0, uni_shared_1.isComponentTag)(tag)) {
+        return context.onError((0, errors_1.createMPCompilerError)(8 /* X_DYNAMIC_COMPONENT_NOT_SUPPORTED */, node.loc));
+    }
+    if ((0, compiler_core_1.findDir)(node, 'is')) {
+        return context.onError((0, errors_1.createMPCompilerError)(6 /* X_V_IS_NOT_SUPPORTED */, node.loc));
+    }
+    // TODO not supported
+    // const isProp = findProp(node, 'is')
+    // if (isProp) {
+    // }
+    // 2. built-in components (Teleport, Transition, KeepAlive, Suspense...)
+    const builtIn = (0, compiler_core_1.isCoreComponent)(tag) || context.isBuiltInComponent(tag);
+    if (builtIn) {
+        return context.onError((0, errors_1.createMPCompilerError)(7 /* X_NOT_SUPPORTED */, node.loc, tag));
+    }
+    // 3. user component (from setup bindings)
+    const fromSetup = resolveSetupReference(tag, context);
+    if (fromSetup) {
+        return (context.bindingComponents[tag] = {
+            name: fromSetup,
+            type: "setup" /* SETUP */,
+        });
+    }
+    const dotIndex = tag.indexOf('.');
+    if (dotIndex > 0) {
+        return context.onError((0, errors_1.createMPCompilerError)(7 /* X_NOT_SUPPORTED */, node.loc, tag));
+    }
+    // 4. Self referencing component (inferred from filename)
+    if (context.selfName && (0, shared_1.capitalize)((0, shared_1.camelize)(tag)) === context.selfName) {
+        return (context.bindingComponents[tag] = {
+            name: (0, compiler_core_1.toValidAssetId)(tag, `component`),
+            type: "self" /* SELF */,
+        });
+    }
+    // 5. user component (resolve)
+    context.bindingComponents[tag] = {
+        name: (0, compiler_core_1.toValidAssetId)(tag, `component`),
+        type: "unknown" /* UNKNOWN */,
+    };
+    context.helper(compiler_core_1.RESOLVE_COMPONENT);
+}
+function resolveSetupReference(name, context) {
+    const bindings = context.bindingMetadata;
+    if (!bindings || bindings.__isScriptSetup === false) {
+        return;
+    }
+    const camelName = (0, shared_1.camelize)(name);
+    const PascalName = (0, shared_1.capitalize)(camelName);
+    const checkType = (type) => {
+        if (bindings[name] === type) {
+            return name;
+        }
+        if (bindings[camelName] === type) {
+            return camelName;
+        }
+        if (bindings[PascalName] === type) {
+            return PascalName;
+        }
+    };
+    const fromConst = checkType("setup-const" /* SETUP_CONST */);
+    if (fromConst) {
+        return context.inline
+            ? // in inline mode, const setup bindings (e.g. imports) can be used as-is
+                fromConst
+            : `$setup[${JSON.stringify(fromConst)}]`;
+    }
+    const fromMaybeRef = checkType("setup-let" /* SETUP_LET */) ||
+        checkType("setup-ref" /* SETUP_REF */) ||
+        checkType("setup-maybe-ref" /* SETUP_MAYBE_REF */);
+    if (fromMaybeRef) {
+        return context.inline
+            ? // setup scope bindings that may be refs need to be unrefed
+                `${context.helperString(compiler_core_1.UNREF)}(${fromMaybeRef})`
+            : `$setup[${JSON.stringify(fromMaybeRef)}]`;
+    }
+}
+function processProps(node, context, props = node.props) {
+    const { tag } = node;
+    const isComponent = node.tagType === 1 /* COMPONENT */;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        if (prop.type === 7 /* DIRECTIVE */) {
+            // directives
+            const { name, arg, loc } = prop;
+            const isVBind = name === 'bind';
+            const isVOn = name === 'on';
+            // skip v-slot - it is handled by its dedicated transform.
+            if (name === 'slot') {
+                if (!isComponent) {
+                    context.onError((0, compiler_core_1.createCompilerError)(40 /* X_V_SLOT_MISPLACED */, loc));
+                }
+                continue;
+            }
+            // skip v-once/v-memo - they are handled by dedicated transforms.
+            if (name === 'once' || name === 'memo') {
+                continue;
+            }
+            // skip v-is and :is on <component>
+            if (name === 'is' ||
+                (isVBind && (0, compiler_core_1.isStaticArgOf)(arg, 'is') && (0, uni_shared_1.isComponentTag)(tag))) {
+                continue;
+            }
+            if (isVBind || isVOn) {
+                // v-on=""
+                // v-bind=""
+                if (!arg) {
+                    context.onError((0, errors_1.createMPCompilerError)(isVBind
+                        ? 2 /* X_V_BIND_NO_ARGUMENT */
+                        : 0 /* X_V_ON_NO_ARGUMENT */, loc));
+                    continue;
+                }
+                // v-on:[a]=""
+                // v-on:[a.b]=""
+                // v-bind:[a]=""
+                // v-bind:[a.b]=""
+                if (!(arg.type === 4 /* SIMPLE_EXPRESSION */ && arg.isStatic)) {
+                    context.onError((0, errors_1.createMPCompilerError)(isVBind
+                        ? 3 /* X_V_BIND_DYNAMIC_ARGUMENT */
+                        : 1 /* X_V_ON_DYNAMIC_EVENT */, loc));
+                    continue;
+                }
+            }
+            const directiveTransform = context.directiveTransforms[name];
+            if (name !== 'model' && directiveTransform) {
+                const { props } = directiveTransform(prop, node, context);
+                if (props.length) {
+                    prop.exp = props[0].value;
+                }
+            }
+        }
+    }
+    const transformVModel = (context.directiveTransforms.model ||
+        vModel_1.transformModel);
+    processVModel(node, transformVModel, context);
+}
+exports.processProps = processProps;
+function processVModel(node, transformVModel, context) {
+    const { props } = node;
+    const dirs = [];
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        if (prop.type === 7 /* DIRECTIVE */ && prop.name === 'model') {
+            dirs.push(...transformVModel(prop, node, context)
+                .props);
+            props.splice(i, 1);
+            i--;
+        }
+    }
+    if (dirs.length) {
+        props.push(...dirs);
+    }
+}

package/dist/transforms/transformExpression.d.ts

@@ -0,0 +1,5 @@
+import { ExpressionNode, SimpleExpressionNode } from '@vue/compiler-core';
+import { NodeTransform, TransformContext } from '../transform';
+export declare const transformExpression: NodeTransform;
+export declare function processExpression(node: SimpleExpressionNode, context: TransformContext, asParams?: boolean, asRawStatements?: boolean, localVars?: Record<string, number>): ExpressionNode;
+export declare function isBuiltInIdentifier(id: string | ExpressionNode): boolean;

package/dist/transforms/transformExpression.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBuiltInIdentifier = exports.processExpression = exports.transformExpression = void 0;
+const shared_1 = require("@vue/shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const parser_1 = require("@babel/parser");
+const isLiteralWhitelisted = /*#__PURE__*/ (0, shared_1.makeMap)('true,false,null,this');
+const transformExpression = (node, context) => {
+    if (node.type === 5 /* INTERPOLATION */) {
+        node.content = processExpression(node.content, context);
+    }
+    else if (node.type === 1 /* 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 /* 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 /* 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 /* SIMPLE_EXPRESSION */ && !arg.isStatic) {
+                    dir.arg = processExpression(arg, context);
+                }
+            }
+        }
+    }
+};
+exports.transformExpression = transformExpression;
+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 (!node.content.trim()) {
+        return node;
+    }
+    const { inline, bindingMetadata } = context;
+    const rewriteIdentifier = (raw, parent, id) => {
+        const type = (0, shared_1.hasOwn)(bindingMetadata, raw) && bindingMetadata[raw];
+        if (inline) {
+            // x = y
+            const isAssignmentLVal = parent && parent.type === 'AssignmentExpression' && parent.left === id;
+            // x++
+            const isUpdateArg = parent && parent.type === 'UpdateExpression' && parent.argument === id;
+            // ({ x } = y)
+            const isDestructureAssignment = parent && (0, compiler_core_1.isInDestructureAssignment)(parent, parentStack);
+            if (type === "setup-const" /* SETUP_CONST */ || localVars[raw]) {
+                return raw;
+            }
+            else if (type === "setup-ref" /* SETUP_REF */) {
+                return `${raw}.value`;
+            }
+            else if (type === "setup-maybe-ref" /* SETUP_MAYBE_REF */) {
+                // const binding that may or may not be ref
+                // if it's not a ref, then assignments don't make sense -
+                // so we ignore the non-ref assignment case and generate code
+                // that assumes the value to be a ref for more efficiency
+                return isAssignmentLVal || isUpdateArg || isDestructureAssignment
+                    ? `${raw}.value`
+                    : `${context.helperString(compiler_core_1.UNREF)}(${raw})`;
+            }
+            else if (type === "setup-let" /* SETUP_LET */) {
+                if (isAssignmentLVal) {
+                    // let binding.
+                    // this is a bit more tricky as we need to cover the case where
+                    // let is a local non-ref value, and we need to replicate the
+                    // right hand side value.
+                    // x = y --> isRef(x) ? x.value = y : x = y
+                    const { right: rVal, operator } = parent;
+                    const rExp = rawExp.slice(rVal.start - 1, rVal.end - 1);
+                    const rExpString = stringifyExpression(processExpression((0, compiler_core_1.createSimpleExpression)(rExp, false), context, false, false, knownIds));
+                    return `${context.helperString(compiler_core_1.IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore\n` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`;
+                }
+                else if (isUpdateArg) {
+                    // make id replace parent in the code range so the raw update operator
+                    // is removed
+                    id.start = parent.start;
+                    id.end = parent.end;
+                    const { prefix: isPrefix, operator } = parent;
+                    const prefix = isPrefix ? operator : ``;
+                    const postfix = isPrefix ? `` : operator;
+                    // let binding.
+                    // x++ --> isRef(a) ? a.value++ : a++
+                    return `${context.helperString(compiler_core_1.IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore\n` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`;
+                }
+                else if (isDestructureAssignment) {
+                    // TODO
+                    // let binding in a destructure assignment - it's very tricky to
+                    // handle both possible cases here without altering the original
+                    // structure of the code, so we just assume it's not a ref here
+                    // for now
+                    return raw;
+                }
+                else {
+                    return `${context.helperString(compiler_core_1.UNREF)}(${raw})`;
+                }
+            }
+            else if (type === "props" /* PROPS */) {
+                // use __props which is generated by compileScript so in ts mode
+                // it gets correct type
+                return `__props.${raw}`;
+            }
+        }
+        else {
+            if (type && type.startsWith('setup')) {
+                // setup bindings in non-inline mode
+                return `$setup.${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 = (0, shared_1.isGloballyWhitelisted)(rawExp);
+        const isLiteral = isLiteralWhitelisted(rawExp);
+        const isFilter = context.filters.includes(rawExp);
+        const isBuiltIn = isBuiltInIdentifier(rawExp);
+        if (!asParams &&
+            !isScopeVarReference &&
+            !isAllowedGlobal &&
+            !isLiteral &&
+            !isFilter &&
+            !isBuiltIn) {
+            // const bindings exposed from setup can be skipped for patching but
+            // cannot be hoisted to module scope
+            if (bindingMetadata[node.content] === "setup-const" /* SETUP_CONST */) {
+                node.constType = 1 /* CAN_SKIP_PATCH */;
+            }
+            node.content = rewriteIdentifier(rawExp);
+        }
+        else if (!isScopeVarReference) {
+            if (isLiteral) {
+                node.constType = 3 /* CAN_STRINGIFY */;
+            }
+            else {
+                node.constType = 2 /* 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, compiler_core_1.createCompilerError)(44 /* X_INVALID_EXPRESSION */, node.loc, undefined, '\n' + source + '\n' + e.message));
+        return node;
+    }
+    const ids = [];
+    const parentStack = [];
+    const knownIds = Object.create(context.identifiers);
+    context.filters.forEach((name) => {
+        knownIds[name] = 1;
+    });
+    (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 /* CAN_STRINGIFY */ : 0 /* 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 /* NOT_CONSTANT */
+            : 3 /* CAN_STRINGIFY */;
+    }
+    ret.identifiers = Object.keys(knownIds);
+    return ret;
+}
+exports.processExpression = processExpression;
+function canPrefix(id) {
+    // skip whitelisted globals
+    if ((0, shared_1.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 /* SIMPLE_EXPRESSION */) {
+        return exp.content;
+    }
+    else {
+        return exp.children
+            .map(stringifyExpression)
+            .join('');
+    }
+}
+const builtInIdentifiers = ['__l'];
+function isBuiltInIdentifier(id) {
+    if (!(0, shared_1.isString)(id)) {
+        if (id.type !== 4 /* SIMPLE_EXPRESSION */) {
+            return false;
+        }
+        id = id.content;
+    }
+    return builtInIdentifiers.includes(id);
+}
+exports.isBuiltInIdentifier = isBuiltInIdentifier;

package/dist/transforms/transformIdentifier.d.ts

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