@lwc/template-compiler 2.7.2 → 2.9.0

package/dist/types/parser/parser.d.ts

@@ -1,28 +1,59 @@
-import * as parse5 from 'parse5';
 import { CompilerDiagnostic, LWCErrorInfo } from '@lwc/errors';
-import { IRElement, LWCDirectiveRenderMode, IRBaseAttribute, IRNode } from '../shared/types';
 import { ResolvedConfig } from '../config';
+import { Root, SourceLocation, ParentNode, BaseNode, LWCDirectiveRenderMode } from '../shared/types';
+interface ParentWrapper {
+    parent: ParentNode | null;
+    current: ParentNode;
+}
 export default class ParserCtx {
     private readonly source;
     readonly config: ResolvedConfig;
     readonly warnings: CompilerDiagnostic[];
     readonly seenIds: Set<string>;
     readonly seenSlots: Set<string>;
-    readonly parentStack: IRElement[];
+    /**
+     * Scopes keep track of the hierarchy of ParentNodes as the parser traverses the parse5 AST.
+     * Each scope is represented by an array where each node in the array correspond to either
+     * a ForEach, ForOf, If, Element, Component, or Slot.
+     *
+     * Currently, each scope has a hierarchy of ForBlock > IfBlock > Element | Component | Slot.
+     * Note: Not all scopes will have all three, but when they do, they will appear in this order.
+     * We do not keep track of template nodes.
+     *
+     * Each scope corresponds to the original parse5.Element node.
+     */
+    private readonly scopes;
+    renderMode: LWCDirectiveRenderMode;
+    preserveComments: boolean;
     constructor(source: String, config: ResolvedConfig);
     getSource(start: number, end: number): string;
-    ancestors(element?: IRElement): Generator<{
-        current: IRElement;
-        index: number;
-    }, void, unknown>;
-    findAncestor(args: {
-        element?: IRElement;
-        predicate: (elm: IRElement) => unknown;
-        traversalCond?: (nodes: {
-            current: IRElement;
-            parent: IRElement | null;
-        }) => unknown;
-    }): IRElement | null;
+    setRootDirective(root: Root): void;
+    /**
+     * This method flattens the scopes into a single array for traversal.
+     */
+    ancestors(element?: ParentNode): IterableIterator<ParentWrapper>;
+    /**
+     * This method returns an iterator over ancestor nodes, starting at the parent and ending at the root node.
+     *
+     * Note: There are instances when we want to terminate the traversal early, such as searching for a ForBlock parent.
+     *
+     * @param {ParentNode} startNode - Starting node to begin search, defaults to the tail of the current scope.
+     * @param {function} predicate - This callback is called once for each ancestor until it finds one where predicate returns true.
+     * @param {function} traversalCond - This callback is called after predicate and will terminate the traversal if it returns false.
+     * traversalCond is ignored if no value is provided.
+     */
+    findAncestor<A extends ParentNode>(predicate: (node: ParentNode) => node is A, traversalCond?: (nodes: ParentWrapper) => unknown, startNode?: ParentNode): A | null;
+    /**
+     * This method searchs the current scope and returns the value that satisfies the predicate.
+     *
+     * @param {function} predicate - This callback is called once for each sibling in the current scope
+     * until it finds one where predicate returns true.
+     */
+    findSibling<A extends ParentNode>(predicate: (node: ParentNode) => node is A): A | null;
+    beginScope(): void;
+    endScope(): void;
+    addNodeCurrentScope(node: ParentNode): void;
+    private currentScope;
     /**
      * This method recovers from diagnostic errors that are encountered when fn is invoked.
      * All other errors are considered compiler errors and can not be recovered from.
@@ -30,34 +61,32 @@ export default class ParserCtx {
      * @param fn - method to be invoked.
      */
     withErrorRecovery<T>(fn: () => T): T | undefined;
-    withErrorWrapping<T>(fn: () => T, errorInfo: LWCErrorInfo, location: parse5.Location, msgFormatter?: (error: any) => string): T;
-    throwOnError(errorInfo: LWCErrorInfo, error: any, location?: parse5.Location): never;
+    withErrorWrapping<T>(fn: () => T, errorInfo: LWCErrorInfo, location: SourceLocation, msgFormatter?: (error: any) => string): T;
+    throwOnError(errorInfo: LWCErrorInfo, error: any, location?: SourceLocation): never;
     /**
-     * This method throws a diagnostic error with the IRNode's location.
+     * This method throws a diagnostic error with the node's location.
      */
-    throwOnIRNode(errorInfo: LWCErrorInfo, irNode: IRNode | IRBaseAttribute, messageArgs?: any[]): never;
+    throwOnNode(errorInfo: LWCErrorInfo, node: BaseNode, messageArgs?: any[]): never;
     /**
      * This method throws a diagnostic error with location information.
      */
-    throwAtLocation(errorInfo: LWCErrorInfo, location: parse5.Location, messageArgs?: any[]): never;
+    throwAtLocation(errorInfo: LWCErrorInfo, location: SourceLocation, messageArgs?: any[]): never;
     /**
      * This method throws a diagnostic error and will immediately exit the current routine.
      */
-    throw(errorInfo: LWCErrorInfo, messageArgs?: any[], location?: parse5.Location): never;
+    throw(errorInfo: LWCErrorInfo, messageArgs?: any[], location?: SourceLocation): never;
     /**
-     * This method logs a diagnostic warning with the IRNode's location.
+     * This method logs a diagnostic warning with the node's location.
      */
-    warnOnIRNode(errorInfo: LWCErrorInfo, irNode: IRNode | IRBaseAttribute, messageArgs?: any[]): void;
+    warnOnNode(errorInfo: LWCErrorInfo, node: BaseNode, messageArgs?: any[]): void;
     /**
      * This method logs a diagnostic warning with location information.
      */
-    warnAtLocation(errorInfo: LWCErrorInfo, location: parse5.Location, messageArgs?: any[]): void;
+    warnAtLocation(errorInfo: LWCErrorInfo, location: SourceLocation, messageArgs?: any[]): void;
     /**
      * This method logs a diagnostic warning and will continue execution of the current routine.
      */
-    warn(errorInfo: LWCErrorInfo, messageArgs?: any[], location?: parse5.Location): void;
+    warn(errorInfo: LWCErrorInfo, messageArgs?: any[], location?: SourceLocation): void;
     private addDiagnostic;
-    getRoot(element: IRElement): IRElement;
-    getRenderMode(element: IRElement): LWCDirectiveRenderMode;
-    getPreserveComments(element: IRElement): boolean;
 }
+export {};

package/dist/types/shared/ast.d.ts

@@ -0,0 +1,45 @@
+import * as parse5 from 'parse5';
+import { Literal, SourceLocation, Element, Component, Expression, Comment, Text, ForEach, ForBlock, Slot, Identifier, Root, EventListener, KeyDirective, DynamicDirective, DomDirective, PreserveCommentsDirective, RenderModeDirective, Attribute, Property, ParentNode, BaseNode, ForOf, LWCDirectiveRenderMode, If, ElementSourceLocation, InnerHTMLDirective, Directive, BaseElement, LWCDirectiveDomMode } from './types';
+export declare function root(parse5ElmLocation: parse5.ElementLocation): Root;
+export declare function element(parse5Elm: parse5.Element, parse5ElmLocation: parse5.ElementLocation): Element;
+export declare function component(parse5Elm: parse5.Element, parse5ElmLocation: parse5.ElementLocation): Component;
+export declare function slot(slotName: string, parse5ElmLocation: parse5.ElementLocation): Slot;
+export declare function text(value: Literal | Expression, parse5Location: parse5.Location): Text;
+export declare function comment(value: string, parse5Location: parse5.Location): Comment;
+export declare function elementSourceLocation(parse5ElmLocation: parse5.ElementLocation): ElementSourceLocation;
+export declare function sourceLocation(location: parse5.Location): SourceLocation;
+export declare function literal<T extends string | boolean>(value: T): Literal<T>;
+export declare function forEach(expression: Expression, elementLocation: SourceLocation, directiveLocation: SourceLocation, item: Identifier, index?: Identifier): ForEach;
+export declare function forOf(expression: Expression, iterator: Identifier, elementLocation: SourceLocation, directiveLocation: SourceLocation): ForOf;
+export declare function ifNode(modifier: string, condition: Expression, elementLocation: SourceLocation, directiveLocation: SourceLocation): If;
+export declare function eventListener(name: string, handler: Expression, location: SourceLocation): EventListener;
+export declare function keyDirective(value: Expression, location: SourceLocation): KeyDirective;
+export declare function dynamicDirective(value: Expression, location: SourceLocation): DynamicDirective;
+export declare function domDirective(lwcDomAttr: LWCDirectiveDomMode, location: SourceLocation): DomDirective;
+export declare function innerHTMLDirective(value: Expression | Literal<string>, location: SourceLocation): InnerHTMLDirective;
+export declare function preserveCommentsDirective(preserveComments: boolean, location: SourceLocation): PreserveCommentsDirective;
+export declare function renderModeDirective(renderMode: LWCDirectiveRenderMode, location: SourceLocation): RenderModeDirective;
+export declare function attribute(name: string, value: Expression | Literal, location: SourceLocation): Attribute;
+export declare function property(name: string, attributeName: string, value: Expression | Literal, location: SourceLocation): Property;
+export declare function isElement(node: BaseNode): node is Element;
+export declare function isRoot(node: BaseNode): node is Root;
+export declare function isComponent(node: BaseNode): node is Component;
+export declare function isSlot(node: BaseNode): node is Slot;
+export declare function isBaseElement(node: BaseNode): node is BaseElement;
+export declare function isText(node: BaseNode): node is Text;
+export declare function isComment(node: BaseNode): node is Comment;
+export declare function isExpression(node: Expression | Literal): node is Expression;
+export declare function isStringLiteral(node: Expression | Literal): node is Literal<string>;
+export declare function isBooleanLiteral(node: Expression | Literal): node is Literal<boolean>;
+export declare function isForOf(node: BaseNode): node is ForOf;
+export declare function isForEach(node: BaseNode): node is ForEach;
+export declare function isForBlock(node: BaseNode): node is ForBlock;
+export declare function isIf(node: BaseNode): node is If;
+export declare function isParentNode(node: BaseNode): node is ParentNode;
+export declare function isDynamicDirective(directive: Directive): directive is DynamicDirective;
+export declare function isDomDirective(directive: Directive): directive is DomDirective;
+export declare function isInnerHTMLDirective(directive: Directive): directive is InnerHTMLDirective;
+export declare function isKeyDirective(directive: Directive): directive is KeyDirective;
+export declare function isRenderModeDirective(directive: Directive): directive is RenderModeDirective;
+export declare function isPreserveCommentsDirective(directive: Directive): directive is PreserveCommentsDirective;
+export declare function isProperty(node: BaseNode): node is Property;

package/dist/types/shared/estree.d.ts

@@ -2,6 +2,8 @@ import type * as t from 'estree';
 export declare function isIdentifier(node: t.BaseNode): node is t.Identifier;
 export declare function isMemberExpression(node: t.BaseNode): node is t.MemberExpression;
 export declare function isArrayExpression(node: t.BaseNode): node is t.ArrayExpression;
+export declare function isObjectExpression(node: t.BaseNode): node is t.ObjectExpression;
+export declare function isProperty(node: t.BaseNode): node is t.Property;
 export declare function identifier(name: string, config?: Partial<t.Identifier>): t.Identifier;
 export declare function isLiteral(node: t.BaseNode): node is t.Literal;
 export declare function memberExpression(object: t.MemberExpression['object'], property: t.MemberExpression['property'], config?: Partial<t.MemberExpression>): t.MemberExpression;
@@ -52,8 +54,6 @@ export declare type BlockStatement = t.BlockStatement;
 export declare type ReturnStatement = t.ReturnStatement;
 export declare type VariableDeclarator = t.VariableDeclarator;
 export declare type VariableDeclaration = t.VariableDeclaration;
-export declare type TemplateLiteral = t.TemplateLiteral;
-export declare type TemplateElement = t.TemplateElement;
 export declare type ImportDeclaration = t.ImportDeclaration;
 export declare type ImportDefaultSpecifier = t.ImportDefaultSpecifier;
 export declare type ImportSpecifier = t.ImportSpecifier;

package/dist/types/shared/parse5.d.ts

@@ -3,4 +3,3 @@ export declare function isElementNode(node: parse5.Node): node is parse5.Element
 export declare function isCommentNode(node: parse5.Node): node is parse5.CommentNode;
 export declare function isTextNode(node: parse5.Node): node is parse5.TextNode;
 export declare function getTemplateContent(templateElement: parse5.Element): parse5.DocumentFragment | undefined;
-export declare function createEmptyElementLocation(): parse5.ElementLocation;

package/dist/types/shared/types.d.ts

@@ -1,36 +1,12 @@
-import * as parse5 from 'parse5';
 import { CompilerDiagnostic } from '@lwc/errors';
-export declare type TemplateIdentifier = {
-    type: 'Identifier';
-    name: string;
-};
-export declare type TemplateExpression = {
-    type: 'MemberExpression';
-    object: TemplateExpression;
-    property: TemplateExpression;
-    computed: boolean;
-    optional: boolean;
-} | {
-    type: 'Literal';
-    value: string | number | boolean | null;
-} | TemplateIdentifier;
 export declare type TemplateCompileResult = {
     code: string;
     warnings: CompilerDiagnostic[];
 };
 export declare type TemplateParseResult = {
-    root?: IRElement | undefined;
+    root?: Root;
     warnings: CompilerDiagnostic[];
 };
-export interface ForEach {
-    expression: TemplateExpression;
-    item: TemplateIdentifier;
-    index?: TemplateIdentifier;
-}
-export interface ForIterator {
-    expression: TemplateExpression;
-    iterator: TemplateIdentifier;
-}
 export declare enum LWCDirectiveDomMode {
     manual = "manual"
 }
@@ -38,74 +14,141 @@ export declare enum LWCDirectiveRenderMode {
     shadow = "shadow",
     light = "light"
 }
-export interface LWCDirectiveDynamic {
-    prop: string;
+export interface BaseNode {
+    type: string;
+    location: SourceLocation;
 }
-export interface LWCDirectives {
-    dom?: LWCDirectiveDomMode;
-    dynamic?: TemplateExpression;
-    renderMode?: LWCDirectiveRenderMode;
-    preserveComments?: IRBooleanAttribute;
-    innerHTML?: TemplateExpression | string;
+export interface SourceLocation {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+    start: number;
+    end: number;
 }
-export interface IRBaseNode<N extends parse5.Node> {
-    type: string;
-    location: parse5.Location;
-    __original?: N;
-}
-export interface IRElement extends IRBaseNode<parse5.Element> {
-    type: 'element';
-    tag: string;
-    namespace: string;
-    children: IRNode[];
-    location: parse5.ElementLocation;
-    component?: string;
-    on?: {
-        [name: string]: TemplateExpression;
-    };
-    attrs?: {
-        [name: string]: IRAttribute;
-    };
-    props?: {
-        [name: string]: IRAttribute;
-    };
-    if?: TemplateExpression;
-    ifModifier?: string;
-    forEach?: ForEach;
-    forOf?: ForIterator;
-    forKey?: TemplateExpression;
-    lwc?: LWCDirectives;
-    slotName?: string;
-}
-export interface IRText extends IRBaseNode<parse5.TextNode> {
-    type: 'text';
-    value: string | TemplateExpression;
-}
-export interface IRComment extends IRBaseNode<parse5.CommentNode> {
-    type: 'comment';
-    value: string;
+export interface ElementSourceLocation extends SourceLocation {
+    startTag: SourceLocation;
+    endTag?: SourceLocation;
+}
+export interface Literal<Value = string | boolean> {
+    type: 'Literal';
+    value: Value;
+}
+export interface Identifier extends BaseNode {
+    type: 'Identifier';
+    name: string;
+}
+export interface MemberExpression extends BaseNode {
+    type: 'MemberExpression';
+    object: Expression;
+    property: Identifier;
+}
+export declare type Expression = Identifier | MemberExpression;
+export interface Attribute extends BaseNode {
+    type: 'Attribute';
+    name: string;
+    value: Literal | Expression;
 }
-export declare type IRNode = IRComment | IRElement | IRText;
-export declare enum IRAttributeType {
-    Expression = 0,
-    String = 1,
-    Boolean = 2
+export interface Property extends BaseNode {
+    type: 'Property';
+    name: string;
+    attributeName: string;
+    value: Literal | Expression;
+}
+export interface EventListener extends BaseNode {
+    type: 'EventListener';
+    name: string;
+    handler: Expression;
 }
-export interface IRBaseAttribute {
+export interface Directive extends BaseNode {
+    type: 'Directive';
     name: string;
-    location: parse5.Location;
-    type: IRAttributeType;
+    value: Expression | Literal;
+}
+export interface KeyDirective extends Directive {
+    name: 'Key';
+    value: Expression;
+}
+export interface DynamicDirective extends Directive {
+    name: 'Dynamic';
+    value: Expression;
 }
-export interface IRExpressionAttribute extends IRBaseAttribute {
-    type: IRAttributeType.Expression;
-    value: TemplateExpression;
+export interface DomDirective extends Directive {
+    name: 'Dom';
+    value: Literal<'manual'>;
 }
-export interface IRStringAttribute extends IRBaseAttribute {
-    type: IRAttributeType.String;
+export interface InnerHTMLDirective extends Directive {
+    name: `InnerHTML`;
+    value: Expression | Literal<string>;
+}
+export interface RenderModeDirective extends Directive {
+    name: 'RenderMode';
+    value: Literal<LWCDirectiveRenderMode>;
+}
+export interface PreserveCommentsDirective extends Directive {
+    name: 'PreserveComments';
+    value: Literal<boolean>;
+}
+export declare type ElementDirective = KeyDirective | DynamicDirective | DomDirective | InnerHTMLDirective;
+export declare type RootDirective = RenderModeDirective | PreserveCommentsDirective;
+export interface Text extends BaseNode {
+    type: 'Text';
+    value: Literal | Expression;
+}
+export interface Comment extends BaseNode {
+    type: 'Comment';
     value: string;
 }
-export interface IRBooleanAttribute extends IRBaseAttribute {
-    type: IRAttributeType.Boolean;
-    value: true;
+export interface BaseParentNode extends BaseNode {
+    children: ChildNode[];
+}
+export interface AbstractBaseElement extends BaseParentNode {
+    name: string;
+    location: ElementSourceLocation;
+    properties: Property[];
+    attributes: Attribute[];
+    listeners: EventListener[];
+    directives: ElementDirective[];
+    namespace?: string;
+}
+export interface Element extends AbstractBaseElement {
+    type: 'Element';
+}
+export interface Component extends AbstractBaseElement {
+    type: 'Component';
+}
+export interface Slot extends AbstractBaseElement {
+    type: 'Slot';
+    /** Specifies slot element name. An empty string value maps to the default slot.  */
+    slotName: string;
+}
+export declare type BaseElement = Element | Component | Slot;
+export interface Root extends BaseParentNode {
+    type: 'Root';
+    location: ElementSourceLocation;
+    directives: RootDirective[];
+}
+interface DirectiveParentNode extends BaseParentNode {
+    directiveLocation: SourceLocation;
+}
+export interface If extends DirectiveParentNode {
+    type: 'If';
+    modifier: string;
+    condition: Expression;
+}
+export interface ForEach extends DirectiveParentNode {
+    type: 'ForEach';
+    expression: Expression;
+    item: Identifier;
+    index?: Identifier;
+}
+export interface ForOf extends DirectiveParentNode {
+    type: 'ForOf';
+    expression: Expression;
+    iterator: Identifier;
 }
-export declare type IRAttribute = IRStringAttribute | IRExpressionAttribute | IRBooleanAttribute;
+export declare type ForBlock = ForEach | ForOf;
+export declare type ParentNode = Root | ForBlock | If | BaseElement;
+export declare type ChildNode = ForBlock | If | BaseElement | Comment | Text;
+export declare type Node = Root | ForBlock | If | BaseElement | Comment | Text;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lwc/template-compiler",
-    "version": "2.7.2",
+    "version": "2.9.0",
     "description": "Template compiler package",
     "homepage": "https://lwc.dev/",
     "repository": {
@@ -25,8 +25,8 @@
     },
     "//": "Currently can't upgrade estree-walker to v3.0.0 because it dropped CommonJS support: https://git.io/JXguS",
     "dependencies": {
-        "@lwc/errors": "2.7.2",
-        "@lwc/shared": "2.7.2",
+        "@lwc/errors": "2.9.0",
+        "@lwc/shared": "2.9.0",
         "acorn": "~8.7.0",
         "astring": "~1.8.1",
         "estree-walker": "~2.0.2",
@@ -39,5 +39,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "f668a3ad36bbebbaa33a5863408a45bf4185d218"
+    "gitHead": "94040389ab8fc717b8753e503f659489480a327d"
 }

package/LICENSE

@@ -1,10 +0,0 @@
-MIT LICENSE
-
-Copyright (c) 2018, Salesforce.com, Inc.
-All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/commonjs/codegen/scope.js

@@ -1,61 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bindExpression = void 0;
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-const estree_walker_1 = require("estree-walker");
-const t = __importStar(require("../shared/estree"));
-const constants_1 = require("../shared/constants");
-const ir_1 = require("../shared/ir");
-/**
- * Bind the passed expression to the component instance. It applies the following transformation to the expression:
- * - {value} --> {$cmp.value}
- * - {value[index]} --> {$cmp.value[$cmp.index]}
- */
-function bindExpression(expression, irNode, parentStack) {
-    if (t.isIdentifier(expression)) {
-        if ((0, ir_1.isComponentProp)(expression, irNode, parentStack)) {
-            return t.memberExpression(t.identifier(constants_1.TEMPLATE_PARAMS.INSTANCE), expression);
-        }
-        else {
-            return expression;
-        }
-    }
-    (0, estree_walker_1.walk)(expression, {
-        leave(node, parent) {
-            if (parent !== null &&
-                t.isIdentifier(node) &&
-                t.isMemberExpression(parent) &&
-                parent.object === node &&
-                (0, ir_1.isComponentProp)(node, irNode, parentStack)) {
-                this.replace(t.memberExpression(t.identifier(constants_1.TEMPLATE_PARAMS.INSTANCE), node));
-            }
-        },
-    });
-    return expression;
-}
-exports.bindExpression = bindExpression;
-//# sourceMappingURL=scope.js.map

package/dist/commonjs/codegen/scope.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope.js","sourceRoot":"","sources":["../../../src/codegen/scope.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;GAKG;AACH,iDAAqC;AAErC,oDAAsC;AACtC,mDAAsD;AACtD,qCAA+C;AAG/C;;;;GAIG;AACH,SAAgB,cAAc,CAC1B,UAA8B,EAC9B,MAAc,EACd,WAAqB;IAErB,IAAI,CAAC,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE;QAC5B,IAAI,IAAA,oBAAe,EAAC,UAAU,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE;YAClD,OAAO,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,UAAU,CAAC,2BAAe,CAAC,QAAQ,CAAC,EAAE,UAAU,CAAC,CAAC;SACjF;aAAM;YACH,OAAO,UAAU,CAAC;SACrB;KACJ;IAED,IAAA,oBAAI,EAAC,UAAU,EAAE;QACb,KAAK,CAAC,IAAI,EAAE,MAAM;YACd,IACI,MAAM,KAAK,IAAI;gBACf,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC;gBACpB,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAC;gBAC5B,MAAM,CAAC,MAAM,KAAK,IAAI;gBACtB,IAAA,oBAAe,EAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAC5C;gBACE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,UAAU,CAAC,2BAAe,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;aAClF;QACL,CAAC;KACJ,CAAC,CAAC;IAEH,OAAO,UAAU,CAAC;AACtB,CAAC;AA5BD,wCA4BC"}

package/dist/commonjs/shared/ir.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isComponentProp = exports.isIRBooleanAttribute = exports.isIRStringAttribute = exports.isIRExpressionAttribute = exports.isSlot = exports.isTemplate = exports.isCustomElement = exports.isCommentNode = exports.isTextNode = exports.isElement = exports.createComment = exports.createText = exports.createElement = void 0;
-const types_1 = require("./types");
-function createElement(original, location) {
-    return {
-        type: 'element',
-        tag: original.tagName,
-        namespace: original.namespaceURI,
-        children: [],
-        location,
-        __original: original,
-    };
-}
-exports.createElement = createElement;
-function createText(value, location) {
-    return {
-        type: 'text',
-        value,
-        location,
-    };
-}
-exports.createText = createText;
-function createComment(value, location) {
-    return {
-        type: 'comment',
-        value,
-        location,
-    };
-}
-exports.createComment = createComment;
-function isElement(node) {
-    return node.type === 'element';
-}
-exports.isElement = isElement;
-function isTextNode(node) {
-    return node.type === 'text';
-}
-exports.isTextNode = isTextNode;
-function isCommentNode(node) {
-    return node.type === 'comment';
-}
-exports.isCommentNode = isCommentNode;
-function isCustomElement(node) {
-    return isElement(node) && node.component !== undefined;
-}
-exports.isCustomElement = isCustomElement;
-function isTemplate(element) {
-    return element.tag === 'template';
-}
-exports.isTemplate = isTemplate;
-function isSlot(element) {
-    return element.tag === 'slot';
-}
-exports.isSlot = isSlot;
-function isIRExpressionAttribute(attribute) {
-    return attribute.type === types_1.IRAttributeType.Expression;
-}
-exports.isIRExpressionAttribute = isIRExpressionAttribute;
-function isIRStringAttribute(attribute) {
-    return attribute.type === types_1.IRAttributeType.String;
-}
-exports.isIRStringAttribute = isIRStringAttribute;
-function isIRBooleanAttribute(attribute) {
-    return attribute.type === types_1.IRAttributeType.Boolean;
-}
-exports.isIRBooleanAttribute = isIRBooleanAttribute;
-function isComponentProp(identifier, root, parentStack) {
-    var _a;
-    const { name } = identifier;
-    let current = root;
-    // Walking up the AST and checking for each node to find if the identifer name is identical to
-    // an iteration variable.
-    for (let i = parentStack.length; i >= 0; i--) {
-        if (isElement(current)) {
-            const { forEach, forOf } = current;
-            if ((forEach === null || forEach === void 0 ? void 0 : forEach.item.name) === name ||
-                ((_a = forEach === null || forEach === void 0 ? void 0 : forEach.index) === null || _a === void 0 ? void 0 : _a.name) === name ||
-                (forOf === null || forOf === void 0 ? void 0 : forOf.iterator.name) === name) {
-                return false;
-            }
-        }
-        current = parentStack[i - 1];
-    }
-    // The identifier is bound to a component property if no match is found after reaching to AST
-    // root.
-    return true;
-}
-exports.isComponentProp = isComponentProp;
-//# sourceMappingURL=ir.js.map

package/dist/commonjs/shared/ir.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ir.js","sourceRoot":"","sources":["../../../src/shared/ir.ts"],"names":[],"mappings":"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"}

package/dist/types/codegen/scope.d.ts

@@ -1,8 +0,0 @@
-import * as t from '../shared/estree';
-import { IRNode, TemplateExpression } from '../shared/types';
-/**
- * Bind the passed expression to the component instance. It applies the following transformation to the expression:
- * - {value} --> {$cmp.value}
- * - {value[index]} --> {$cmp.value[$cmp.index]}
- */
-export declare function bindExpression(expression: TemplateExpression, irNode: IRNode, parentStack: IRNode[]): t.Expression;