@angular/core 19.2.1 → 20.0.0-next.1

package/schematics/bundles/{checker-89987c98.js → checker-af521da6.js}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.2.1
+ * @license Angular v20.0.0-next.1
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -921,6 +921,7 @@ var BinaryOperator;
     BinaryOperator[BinaryOperator["Bigger"] = 15] = "Bigger";
     BinaryOperator[BinaryOperator["BiggerEquals"] = 16] = "BiggerEquals";
     BinaryOperator[BinaryOperator["NullishCoalesce"] = 17] = "NullishCoalesce";
+    BinaryOperator[BinaryOperator["Exponentiation"] = 18] = "Exponentiation";
 })(BinaryOperator || (BinaryOperator = {}));
 function nullSafeIsEquivalent(base, other) {
     if (base == null || other == null) {
@@ -992,14 +993,17 @@ class Expression {
     modulo(rhs, sourceSpan) {
         return new BinaryOperatorExpr(BinaryOperator.Modulo, this, rhs, null, sourceSpan);
     }
+    power(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Exponentiation, this, rhs, null, sourceSpan);
+    }
     and(rhs, sourceSpan) {
         return new BinaryOperatorExpr(BinaryOperator.And, this, rhs, null, sourceSpan);
     }
-    bitwiseOr(rhs, sourceSpan, parens = true) {
-        return new BinaryOperatorExpr(BinaryOperator.BitwiseOr, this, rhs, null, sourceSpan, parens);
+    bitwiseOr(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.BitwiseOr, this, rhs, null, sourceSpan);
     }
-    bitwiseAnd(rhs, sourceSpan, parens = true) {
-        return new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan, parens);
+    bitwiseAnd(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan);
     }
     or(rhs, sourceSpan) {
         return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs, null, sourceSpan);
@@ -1069,6 +1073,25 @@ class TypeofExpr extends Expression {
         return new TypeofExpr(this.expr.clone());
     }
 }
+class VoidExpr extends Expression {
+    expr;
+    constructor(expr, type, sourceSpan) {
+        super(type, sourceSpan);
+        this.expr = expr;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitVoidExpr(this, context);
+    }
+    isEquivalent(e) {
+        return e instanceof VoidExpr && e.expr.isEquivalent(this.expr);
+    }
+    isConstant() {
+        return this.expr.isConstant();
+    }
+    clone() {
+        return new VoidExpr(this.expr.clone());
+    }
+}
 class WrappedNodeExpr extends Expression {
     node;
     constructor(node, type, sourceSpan) {
@@ -1653,16 +1676,34 @@ class UnaryOperatorExpr extends Expression {
         return new UnaryOperatorExpr(this.operator, this.expr.clone(), this.type, this.sourceSpan, this.parens);
     }
 }
+class ParenthesizedExpr extends Expression {
+    expr;
+    constructor(expr, type, sourceSpan) {
+        super(type, sourceSpan);
+        this.expr = expr;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitParenthesizedExpr(this, context);
+    }
+    isEquivalent(e) {
+        // TODO: should this ignore paren depth? i.e. is `(1)` equivalent to `1`?
+        return e instanceof ParenthesizedExpr && e.expr.isEquivalent(this.expr);
+    }
+    isConstant() {
+        return this.expr.isConstant();
+    }
+    clone() {
+        return new ParenthesizedExpr(this.expr.clone());
+    }
+}
 class BinaryOperatorExpr extends Expression {
     operator;
     rhs;
-    parens;
     lhs;
-    constructor(operator, lhs, rhs, type, sourceSpan, parens = true) {
+    constructor(operator, lhs, rhs, type, sourceSpan) {
         super(type || lhs.type, sourceSpan);
         this.operator = operator;
         this.rhs = rhs;
-        this.parens = parens;
         this.lhs = lhs;
     }
     isEquivalent(e) {
@@ -1678,7 +1719,7 @@ class BinaryOperatorExpr extends Expression {
         return visitor.visitBinaryOperatorExpr(this, context);
     }
     clone() {
-        return new BinaryOperatorExpr(this.operator, this.lhs.clone(), this.rhs.clone(), this.type, this.sourceSpan, this.parens);
+        return new BinaryOperatorExpr(this.operator, this.lhs.clone(), this.rhs.clone(), this.type, this.sourceSpan);
     }
 }
 class ReadPropExpr extends Expression {
@@ -1963,9 +2004,6 @@ class RecursiveAstVisitor$1 {
     visitWrappedNodeExpr(ast, context) {
         return ast;
     }
-    visitTypeofExpr(ast, context) {
-        return this.visitExpression(ast, context);
-    }
     visitReadVarExpr(ast, context) {
         return this.visitExpression(ast, context);
     }
@@ -2043,6 +2081,14 @@ class RecursiveAstVisitor$1 {
         ast.expr.visitExpression(this, context);
         return this.visitExpression(ast, context);
     }
+    visitTypeofExpr(ast, context) {
+        ast.expr.visitExpression(this, context);
+        return this.visitExpression(ast, context);
+    }
+    visitVoidExpr(ast, context) {
+        ast.expr.visitExpression(this, context);
+        return this.visitExpression(ast, context);
+    }
     visitBinaryOperatorExpr(ast, context) {
         ast.lhs.visitExpression(this, context);
         ast.rhs.visitExpression(this, context);
@@ -2077,6 +2123,10 @@ class RecursiveAstVisitor$1 {
     visitTemplateLiteralElementExpr(ast, context) {
         return this.visitExpression(ast, context);
     }
+    visitParenthesizedExpr(ast, context) {
+        ast.expr.visitExpression(this, context);
+        return this.visitExpression(ast, context);
+    }
     visitAllExpressions(exprs, context) {
         exprs.forEach((expr) => expr.visitExpression(this, context));
     }
@@ -3371,6 +3421,7 @@ class EmitterVisitorContext {
 }
 class AbstractEmitterVisitor {
     _escapeDollarInStrings;
+    lastIfCondition = null;
     constructor(_escapeDollarInStrings) {
         this._escapeDollarInStrings = _escapeDollarInStrings;
     }
@@ -3410,7 +3461,9 @@ class AbstractEmitterVisitor {
     visitIfStmt(stmt, ctx) {
         this.printLeadingComments(stmt, ctx);
         ctx.print(stmt, `if (`);
+        this.lastIfCondition = stmt.condition; // We can skip redundant parentheses for the condition.
         stmt.condition.visitExpression(this, ctx);
+        this.lastIfCondition = null;
         ctx.print(stmt, `) {`);
         const hasElseCase = stmt.falseCase != null && stmt.falseCase.length > 0;
         if (stmt.trueCase.length <= 1 && !hasElseCase) {
@@ -3516,6 +3569,10 @@ class AbstractEmitterVisitor {
         ctx.print(expr, 'typeof ');
         expr.expr.visitExpression(this, ctx);
     }
+    visitVoidExpr(expr, ctx) {
+        ctx.print(expr, 'void ');
+        expr.expr.visitExpression(this, ctx);
+    }
     visitReadVarExpr(ast, ctx) {
         ctx.print(ast, ast.name);
         return null;
@@ -3579,11 +3636,12 @@ class AbstractEmitterVisitor {
             default:
                 throw new Error(`Unknown operator ${ast.operator}`);
         }
-        if (ast.parens)
+        const parens = ast !== this.lastIfCondition;
+        if (parens)
             ctx.print(ast, `(`);
         ctx.print(ast, opStr);
         ast.expr.visitExpression(this, ctx);
-        if (ast.parens)
+        if (parens)
             ctx.print(ast, `)`);
         return null;
     }
@@ -3629,6 +3687,9 @@ class AbstractEmitterVisitor {
             case BinaryOperator.Modulo:
                 opStr = '%';
                 break;
+            case BinaryOperator.Exponentiation:
+                opStr = '**';
+                break;
             case BinaryOperator.Lower:
                 opStr = '<';
                 break;
@@ -3647,12 +3708,13 @@ class AbstractEmitterVisitor {
             default:
                 throw new Error(`Unknown operator ${ast.operator}`);
         }
-        if (ast.parens)
+        const parens = ast !== this.lastIfCondition;
+        if (parens)
             ctx.print(ast, `(`);
         ast.lhs.visitExpression(this, ctx);
         ctx.print(ast, ` ${opStr} `);
         ast.rhs.visitExpression(this, ctx);
-        if (ast.parens)
+        if (parens)
             ctx.print(ast, `)`);
         return null;
     }
@@ -3690,6 +3752,12 @@ class AbstractEmitterVisitor {
         ctx.print(ast, ')');
         return null;
     }
+    visitParenthesizedExpr(ast, ctx) {
+        // We parenthesize everything regardless of an explicit ParenthesizedExpr, so we can just visit
+        // the inner expression.
+        // TODO: Do we *need* to parenthesize everything?
+        ast.expr.visitExpression(this, ctx);
+    }
     visitAllExpressions(expressions, ctx, separator) {
         this.visitAllObjects((expr) => expr.visitExpression(this, ctx), expressions, ctx, separator);
     }
@@ -3776,7 +3844,7 @@ function guardedExpression(guard, expr) {
     const guardNotDefined = new BinaryOperatorExpr(BinaryOperator.Identical, new TypeofExpr(guardExpr), literal$1('undefined'));
     const guardUndefinedOrTrue = new BinaryOperatorExpr(BinaryOperator.Or, guardNotDefined, guardExpr, 
     /* type */ undefined, 
-    /* sourceSpan */ undefined, true);
+    /* sourceSpan */ undefined);
     return new BinaryOperatorExpr(BinaryOperator.And, guardUndefinedOrTrue, expr);
 }
 function wrapReference(value) {
@@ -4321,6 +4389,16 @@ class TypeofExpression extends AST {
         return visitor.visitTypeofExpression(this, context);
     }
 }
+class VoidExpression extends AST {
+    expression;
+    constructor(span, sourceSpan, expression) {
+        super(span, sourceSpan);
+        this.expression = expression;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitVoidExpression(this, context);
+    }
+}
 class NonNullAssert extends AST {
     expression;
     constructor(span, sourceSpan, expression) {
@@ -4359,6 +4437,18 @@ class SafeCall extends AST {
         return visitor.visitSafeCall(this, context);
     }
 }
+class TaggedTemplateLiteral extends AST {
+    tag;
+    template;
+    constructor(span, sourceSpan, tag, template) {
+        super(span, sourceSpan);
+        this.tag = tag;
+        this.template = template;
+    }
+    visit(visitor, context) {
+        return visitor.visitTaggedTemplateLiteral(this, context);
+    }
+}
 class TemplateLiteral extends AST {
     elements;
     expressions;
@@ -4503,6 +4593,9 @@ class RecursiveAstVisitor {
     visitTypeofExpression(ast, context) {
         this.visit(ast.expression, context);
     }
+    visitVoidExpression(ast, context) {
+        this.visit(ast.expression, context);
+    }
     visitNonNullAssert(ast, context) {
         this.visit(ast.expression, context);
     }
@@ -4540,6 +4633,10 @@ class RecursiveAstVisitor {
         }
     }
     visitTemplateLiteralElement(ast, context) { }
+    visitTaggedTemplateLiteral(ast, context) {
+        this.visit(ast.tag, context);
+        this.visit(ast.template, context);
+    }
     // This is not part of the AstVisitor interface, just a helper method
     visitAll(asts, context) {
         for (const ast of asts) {
@@ -10246,6 +10343,9 @@ function transformExpressionsInExpression(expr, transform, flags) {
     else if (expr instanceof TypeofExpr) {
         expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
     }
+    else if (expr instanceof VoidExpr) {
+        expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
+    }
     else if (expr instanceof WriteVarExpr) {
         expr.value = transformExpressionsInExpression(expr.value, transform, flags);
     }
@@ -10277,6 +10377,9 @@ function transformExpressionsInExpression(expr, transform, flags) {
             expr.expressions[i] = transformExpressionsInExpression(expr.expressions[i], transform, flags);
         }
     }
+    else if (expr instanceof ParenthesizedExpr) {
+        expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
+    }
     else if (expr instanceof ReadVarExpr ||
         expr instanceof ExternalExpr ||
         expr instanceof LiteralExpr) ;
@@ -11349,6 +11452,33 @@ function assignI18nSlotDependencies(job) {
     }
 }
 
+/**
+ * Locates all of the elements defined in a creation block and outputs an op
+ * that will expose their definition location in the DOM.
+ */
+function attachSourceLocations(job) {
+    if (!job.enableDebugLocations || job.relativeTemplatePath === null) {
+        return;
+    }
+    for (const unit of job.units) {
+        const locations = [];
+        for (const op of unit.create) {
+            if (op.kind === OpKind.ElementStart || op.kind === OpKind.Element) {
+                const start = op.startSourceSpan.start;
+                locations.push({
+                    targetSlot: op.handle,
+                    offset: start.offset,
+                    line: start.line,
+                    column: start.col,
+                });
+            }
+        }
+        if (locations.length > 0) {
+            unit.create.push(createSourceLocationOp(job.relativeTemplatePath, locations));
+        }
+    }
+}
+
 /**
  * Gets a map of all elements in the given view by their xref id.
  */
@@ -11749,6 +11879,7 @@ const BINARY_OPERATORS$3 = new Map([
     ['<=', BinaryOperator.LowerEquals],
     ['-', BinaryOperator.Minus],
     ['%', BinaryOperator.Modulo],
+    ['**', BinaryOperator.Exponentiation],
     ['*', BinaryOperator.Multiply],
     ['!=', BinaryOperator.NotEquals],
     ['!==', BinaryOperator.NotIdentical],
@@ -12038,29 +12169,6 @@ function convertI18nBindings(job) {
     }
 }
 
-/**
- * Resolve the dependency function of a deferred block.
- */
-function resolveDeferDepsFns(job) {
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.Defer) {
-                if (op.resolverFn !== null) {
-                    continue;
-                }
-                if (op.ownResolverFn !== null) {
-                    if (op.handle.slot === null) {
-                        throw new Error('AssertionError: slot must be assigned before extracting defer deps functions');
-                    }
-                    const fullPathName = unit.fnName?.replace('_Template', '');
-                    op.resolverFn = job.pool.getSharedFunctionReference(op.ownResolverFn, `${fullPathName}_Defer_${op.handle.slot}_DepsFn`, 
-                    /* Don't use unique names for TDB compatibility */ false);
-                }
-            }
-        }
-    }
-}
-
 /**
  * Create one helper context op per i18n block (including generate descending blocks).
  *
@@ -12803,6 +12911,27 @@ function generateAdvance(job) {
     }
 }
 
+/**
+ * Replaces the `storeLet` ops with variables that can be
+ * used to reference the value within the same view.
+ */
+function generateLocalLetReferences(job) {
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            if (op.kind !== OpKind.StoreLet) {
+                continue;
+            }
+            const variable = {
+                kind: SemanticVariableKind.Identifier,
+                name: null,
+                identifier: op.declaredName,
+                local: true,
+            };
+            OpList.replace(op, createVariableOp(job.allocateXrefId(), variable, new StoreLetExpr(op.target, op.value, op.sourceSpan), VariableFlags.None));
+        }
+    }
+}
+
 /**
  * Locate projection slots, populate the each component's `ngContentSelectors` literal field,
  * populate `project` arguments, and generate the required `projectionDef` instruction for the job's
@@ -17447,6 +17576,7 @@ const KEYWORDS = [
     'else',
     'this',
     'typeof',
+    'void',
 ];
 class Lexer {
     tokenize(text) {
@@ -17511,6 +17641,9 @@ class Token {
     isKeywordTypeof() {
         return this.type === TokenType.Keyword && this.strValue === 'typeof';
     }
+    isKeywordVoid() {
+        return this.type === TokenType.Keyword && this.strValue === 'void';
+    }
     isError() {
         return this.type === TokenType.Error;
     }
@@ -17655,11 +17788,12 @@ class _Scanner {
                 return this.scanPrivateIdentifier();
             case $PLUS:
             case $MINUS:
-            case $STAR:
             case $SLASH:
             case $PERCENT:
             case $CARET:
                 return this.scanOperator(start, String.fromCharCode(peek));
+            case $STAR:
+                return this.scanComplexOperator(start, '*', $STAR, '*');
             case $QUESTION:
                 return this.scanQuestion(start);
             case $LT:
@@ -18227,6 +18361,7 @@ class _ParseAST {
     parseFlags;
     errors;
     offset;
+    lastUnary = null;
     rparensExpected = 0;
     rbracketsExpected = 0;
     rbracesExpected = 0;
@@ -18593,7 +18728,7 @@ class _ParseAST {
     parseMultiplicative() {
         // '*', '%', '/'
         const start = this.inputIndex;
-        let result = this.parsePrefix();
+        let result = this.parseExponentiation();
         while (this.next.type == TokenType.Operator) {
             const operator = this.next.strValue;
             switch (operator) {
@@ -18601,7 +18736,7 @@ class _ParseAST {
                 case '%':
                 case '/':
                     this.advance();
-                    let right = this.parsePrefix();
+                    const right = this.parseExponentiation();
                     result = new Binary(this.span(start), this.sourceSpan(start), operator, result, right);
                     continue;
             }
@@ -18609,6 +18744,23 @@ class _ParseAST {
         }
         return result;
     }
+    parseExponentiation() {
+        // '**'
+        const start = this.inputIndex;
+        let result = this.parsePrefix();
+        while (this.next.type == TokenType.Operator && this.next.strValue === '**') {
+            // This aligns with Javascript semantics which require any unary operator preceeding the
+            // exponentiation operation to be explicitly grouped as either applying to the base or result
+            // of the exponentiation operation.
+            if (result === this.lastUnary) {
+                this.error('Unary operator used immediately before exponentiation expression. Parenthesis must be used to disambiguate operator precedence');
+            }
+            this.advance();
+            const right = this.parseExponentiation();
+            result = new Binary(this.span(start), this.sourceSpan(start), '**', result, right);
+        }
+        return result;
+    }
     parsePrefix() {
         if (this.next.type == TokenType.Operator) {
             const start = this.inputIndex;
@@ -18618,22 +18770,28 @@ class _ParseAST {
                 case '+':
                     this.advance();
                     result = this.parsePrefix();
-                    return Unary.createPlus(this.span(start), this.sourceSpan(start), result);
+                    return (this.lastUnary = Unary.createPlus(this.span(start), this.sourceSpan(start), result));
                 case '-':
                     this.advance();
                     result = this.parsePrefix();
-                    return Unary.createMinus(this.span(start), this.sourceSpan(start), result);
+                    return (this.lastUnary = Unary.createMinus(this.span(start), this.sourceSpan(start), result));
                 case '!':
                     this.advance();
                     result = this.parsePrefix();
-                    return new PrefixNot(this.span(start), this.sourceSpan(start), result);
+                    return (this.lastUnary = new PrefixNot(this.span(start), this.sourceSpan(start), result));
             }
         }
         else if (this.next.isKeywordTypeof()) {
             this.advance();
             const start = this.inputIndex;
             let result = this.parsePrefix();
-            return new TypeofExpression(this.span(start), this.sourceSpan(start), result);
+            return (this.lastUnary = new TypeofExpression(this.span(start), this.sourceSpan(start), result));
+        }
+        else if (this.next.isKeywordVoid()) {
+            this.advance();
+            const start = this.inputIndex;
+            let result = this.parsePrefix();
+            return (this.lastUnary = new VoidExpression(this.span(start), this.sourceSpan(start), result));
         }
         return this.parseCallChain();
     }
@@ -18663,6 +18821,12 @@ class _ParseAST {
             else if (this.consumeOptionalOperator('!')) {
                 result = new NonNullAssert(this.span(start), this.sourceSpan(start), result);
             }
+            else if (this.next.isTemplateLiteralEnd()) {
+                result = this.parseNoInterpolationTaggedTemplateLiteral(result, start);
+            }
+            else if (this.next.isTemplateLiteralPart()) {
+                result = this.parseTaggedTemplateLiteral(result, start);
+            }
             else {
                 return result;
             }
@@ -18674,6 +18838,7 @@ class _ParseAST {
             this.rparensExpected++;
             const result = this.parsePipe();
             this.rparensExpected--;
+            this.lastUnary = null;
             this.expectCharacter($RPAREN);
             return result;
         }
@@ -18716,7 +18881,7 @@ class _ParseAST {
             return new LiteralPrimitive(this.span(start), this.sourceSpan(start), value);
         }
         else if (this.next.isTemplateLiteralEnd()) {
-            return this.parseNoInterpolationTemplateLiteral(start);
+            return this.parseNoInterpolationTemplateLiteral();
         }
         else if (this.next.isTemplateLiteralPart()) {
             return this.parseTemplateLiteral();
@@ -19046,17 +19211,25 @@ class _ParseAST {
         const sourceSpan = new AbsoluteSourceSpan(spanStart, this.currentAbsoluteOffset);
         return new VariableBinding(sourceSpan, key, value);
     }
-    parseNoInterpolationTemplateLiteral(start) {
+    parseNoInterpolationTaggedTemplateLiteral(tag, start) {
+        const template = this.parseNoInterpolationTemplateLiteral();
+        return new TaggedTemplateLiteral(this.span(start), this.sourceSpan(start), tag, template);
+    }
+    parseNoInterpolationTemplateLiteral() {
         const text = this.next.strValue;
         this.advance();
-        const span = this.span(start);
-        const sourceSpan = this.sourceSpan(start);
+        const span = this.span(this.inputIndex);
+        const sourceSpan = this.sourceSpan(this.inputIndex);
         return new TemplateLiteral(span, sourceSpan, [new TemplateLiteralElement(span, sourceSpan, text)], []);
     }
+    parseTaggedTemplateLiteral(tag, start) {
+        const template = this.parseTemplateLiteral();
+        return new TaggedTemplateLiteral(this.span(start), this.sourceSpan(start), tag, template);
+    }
     parseTemplateLiteral() {
-        const start = this.inputIndex;
         const elements = [];
         const expressions = [];
+        const start = this.inputIndex;
         while (this.next !== EOF) {
             const token = this.next;
             if (token.isTemplateLiteralPart() || token.isTemplateLiteralEnd()) {
@@ -19297,6 +19470,9 @@ class SerializeExpressionVisitor {
     visitTypeofExpression(ast, context) {
         return `typeof ${ast.expression.visit(this, context)}`;
     }
+    visitVoidExpression(ast, context) {
+        return `void ${ast.expression.visit(this, context)}`;
+    }
     visitASTWithSource(ast, context) {
         return ast.ast.visit(this, context);
     }
@@ -19314,6 +19490,9 @@ class SerializeExpressionVisitor {
     visitTemplateLiteralElement(ast, context) {
         return ast.text;
     }
+    visitTaggedTemplateLiteral(ast, context) {
+        return ast.tag.visit(this, context) + ast.template.visit(this, context);
+    }
 }
 /** Zips the two input arrays into a single array of pairs of elements at the same index. */
 function zip(left, right) {
@@ -21863,30 +22042,6 @@ function disableBindings$1(job) {
     }
 }
 
-/**
- * Nullish coalescing expressions such as `a ?? b` have different semantics in Angular templates as
- * compared to JavaScript. In particular, they default to `null` instead of `undefined`. Therefore,
- * we replace them with ternary expressions, assigning temporaries as needed to avoid re-evaluating
- * the same sub-expression multiple times.
- */
-function generateNullishCoalesceExpressions(job) {
-    for (const unit of job.units) {
-        for (const op of unit.ops()) {
-            transformExpressionsInOp(op, (expr) => {
-                if (!(expr instanceof BinaryOperatorExpr) ||
-                    expr.operator !== BinaryOperator.NullishCoalesce) {
-                    return expr;
-                }
-                const assignment = new AssignTemporaryExpr(expr.lhs.clone(), job.allocateXrefId());
-                const read = new ReadTemporaryExpr(assignment.xref);
-                // TODO: When not in compatibility mode for TemplateDefinitionBuilder, we can just emit
-                // `t != null` instead of including an undefined check as well.
-                return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.And, new BinaryOperatorExpr(BinaryOperator.NotIdentical, assignment, NULL_EXPR), new BinaryOperatorExpr(BinaryOperator.NotIdentical, read, new LiteralExpr(undefined))), read.clone(), expr.rhs);
-            }, VisitorContextFlag.None);
-        }
-    }
-}
-
 function kindTest(kind) {
     return (op) => op.kind === kind;
 }
@@ -23405,6 +23560,33 @@ function removeI18nContexts(job) {
     }
 }
 
+/**
+ * It's not allowed to access a `@let` declaration before it has been defined. This is enforced
+ * already via template type checking, however it can trip some of the assertions in the pipeline.
+ * E.g. the naming phase can fail because we resolved the variable here, but the variable doesn't
+ * exist anymore because the optimization phase removed it since it's invalid. To avoid surfacing
+ * confusing errors to users in the case where template type checking isn't running (e.g. in JIT
+ * mode) this phase detects illegal forward references and replaces them with `undefined`.
+ * Eventually users will see the proper error from the template type checker.
+ */
+function removeIllegalLetReferences(job) {
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            if (op.kind !== OpKind.Variable ||
+                op.variable.kind !== SemanticVariableKind.Identifier ||
+                !(op.initializer instanceof StoreLetExpr)) {
+                continue;
+            }
+            const name = op.variable.identifier;
+            let current = op;
+            while (current && current.kind !== OpKind.ListEnd) {
+                transformExpressionsInOp(current, (expr) => expr instanceof LexicalReadExpr && expr.name === name ? literal$1(undefined) : expr, VisitorContextFlag.None);
+                current = current.prev;
+            }
+        }
+    }
+}
+
 /**
  * i18nAttributes ops will be generated for each i18n attribute. However, not all i18n attribues
  * will contain dynamic content, and so some of these i18nAttributes ops may be unnecessary.
@@ -23430,6 +23612,57 @@ function removeUnusedI18nAttributesOps(job) {
     }
 }
 
+// TODO: create AST for parentheses when parsing, then we can remove the unnecessary ones instead of
+// adding them out of thin air. This should simplify the parsing and give us valid spans for the
+// parentheses.
+/**
+ * In some cases we need to add parentheses to expressions for them to be considered valid
+ * JavaScript. This phase adds parentheses to cover such cases. Currently these cases are:
+ *
+ * 1. Unary operators in the base of an exponentiation expression. For example, `-2 ** 3` is not
+ *    valid JavaScript, but `(-2) ** 3` is.
+ * 2. When mixing nullish coalescing (`??`) and logical and/or operators (`&&`, `||`), we need to
+ *    add parentheses. For example, `a ?? b && c` is not valid JavaScript, but `a ?? (b && c)` is.
+ * 3. Safe property access that has been down-leveled into a ternary expression needs parentheses
+ *    when used with nullish coalescing.
+ */
+function requiredParentheses(job) {
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            transformExpressionsInOp(op, (expr) => {
+                if (expr instanceof BinaryOperatorExpr) {
+                    switch (expr.operator) {
+                        case BinaryOperator.Exponentiation:
+                            parenthesizeExponentiation(expr);
+                            break;
+                        case BinaryOperator.NullishCoalesce:
+                            parenthesizeNullishCoalescing(expr);
+                            break;
+                    }
+                }
+                return expr;
+            }, VisitorContextFlag.None);
+        }
+    }
+}
+function parenthesizeExponentiation(expr) {
+    if (expr.lhs instanceof UnaryOperatorExpr) {
+        expr.lhs = new ParenthesizedExpr(expr.lhs);
+    }
+}
+function parenthesizeNullishCoalescing(expr) {
+    if (isLogicalAndOr(expr.lhs) || expr.lhs instanceof ConditionalExpr) {
+        expr.lhs = new ParenthesizedExpr(expr.lhs);
+    }
+    if (isLogicalAndOr(expr.rhs) || expr.rhs instanceof ConditionalExpr) {
+        expr.rhs = new ParenthesizedExpr(expr.rhs);
+    }
+}
+function isLogicalAndOr(expr) {
+    return (expr instanceof BinaryOperatorExpr &&
+        (expr.operator === BinaryOperator.And || expr.operator === BinaryOperator.Or));
+}
+
 /**
  * Resolves `ir.ContextExpr` expressions (which represent embedded view or component contexts) to
  * either the `ctx` parameter to component functions (for the current view context) or to variables
@@ -23486,6 +23719,29 @@ function processLexicalScope$1(view, ops) {
     }
 }
 
+/**
+ * Resolve the dependency function of a deferred block.
+ */
+function resolveDeferDepsFns(job) {
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.Defer) {
+                if (op.resolverFn !== null) {
+                    continue;
+                }
+                if (op.ownResolverFn !== null) {
+                    if (op.handle.slot === null) {
+                        throw new Error('AssertionError: slot must be assigned before extracting defer deps functions');
+                    }
+                    const fullPathName = unit.fnName?.replace('_Template', '');
+                    op.resolverFn = job.pool.getSharedFunctionReference(op.ownResolverFn, `${fullPathName}_Defer_${op.handle.slot}_DepsFn`, 
+                    /* Don't use unique names for TDB compatibility */ false);
+                }
+            }
+        }
+    }
+}
+
 /**
  * Any variable inside a listener with the name `$event` will be transformed into a output lexical
  * read immediately, and does not participate in any of the normal logic for handling variables.
@@ -24062,39 +24318,6 @@ function getOnlySecurityContext(securityContext) {
     return securityContext;
 }
 
-/**
- * Transforms a `TwoWayBindingSet` expression into an expression that either
- * sets a value through the `twoWayBindingSet` instruction or falls back to setting
- * the value directly. E.g. the expression `TwoWayBindingSet(target, value)` becomes:
- * `ng.twoWayBindingSet(target, value) || (target = value)`.
- */
-function transformTwoWayBindingSet(job) {
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.TwoWayListener) {
-                transformExpressionsInOp(op, (expr) => {
-                    if (!(expr instanceof TwoWayBindingSetExpr)) {
-                        return expr;
-                    }
-                    const { target, value } = expr;
-                    if (target instanceof ReadPropExpr || target instanceof ReadKeyExpr) {
-                        return twoWayBindingSet(target, value).or(target.set(value));
-                    }
-                    // ASSUMPTION: here we're assuming that `ReadVariableExpr` will be a reference
-                    // to a local template variable. This appears to be the case at the time of writing.
-                    // If the expression is targeting a variable read, we only emit the `twoWayBindingSet`
-                    // since the fallback would be attempting to write into a constant. Invalid usages will be
-                    // flagged during template type checking.
-                    if (target instanceof ReadVariableExpr) {
-                        return twoWayBindingSet(target, value);
-                    }
-                    throw new Error(`Unsupported expression in two-way action binding.`);
-                }, VisitorContextFlag.InChildOperation);
-            }
-        }
-    }
-}
-
 /**
  * When inside of a listener, we may need access to one or more enclosing views. Therefore, each
  * view should save the current view, and each listener must have the ability to restore the
@@ -24204,6 +24427,40 @@ function allocateSlots(job) {
     }
 }
 
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * Removes any `storeLet` calls that aren't referenced outside of the current view.
+ */
+function optimizeStoreLet(job) {
+    const letUsedExternally = new Set();
+    // Since `@let` declarations can be referenced in child views, both in
+    // the creation block (via listeners) and in the update block, we have
+    // to look through all the ops to find the references.
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            visitExpressionsInOp(op, (expr) => {
+                if (expr instanceof ContextLetReferenceExpr) {
+                    letUsedExternally.add(expr.target);
+                }
+            });
+        }
+    }
+    // TODO(crisbeto): potentially remove the unused calls completely, pending discussion.
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            transformExpressionsInOp(op, (expression) => expression instanceof StoreLetExpr && !letUsedExternally.has(expression.target)
+                ? expression.value
+                : expression, VisitorContextFlag.None);
+        }
+    }
+}
+
 /**
  * Transforms special-case bindings with 'style' or 'class' in their names. Must run before the
  * main binding specialization pass.
@@ -24431,6 +24688,39 @@ function generateTrackVariables(job) {
     }
 }
 
+/**
+ * Transforms a `TwoWayBindingSet` expression into an expression that either
+ * sets a value through the `twoWayBindingSet` instruction or falls back to setting
+ * the value directly. E.g. the expression `TwoWayBindingSet(target, value)` becomes:
+ * `ng.twoWayBindingSet(target, value) || (target = value)`.
+ */
+function transformTwoWayBindingSet(job) {
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.TwoWayListener) {
+                transformExpressionsInOp(op, (expr) => {
+                    if (!(expr instanceof TwoWayBindingSetExpr)) {
+                        return expr;
+                    }
+                    const { target, value } = expr;
+                    if (target instanceof ReadPropExpr || target instanceof ReadKeyExpr) {
+                        return twoWayBindingSet(target, value).or(target.set(value));
+                    }
+                    // ASSUMPTION: here we're assuming that `ReadVariableExpr` will be a reference
+                    // to a local template variable. This appears to be the case at the time of writing.
+                    // If the expression is targeting a variable read, we only emit the `twoWayBindingSet`
+                    // since the fallback would be attempting to write into a constant. Invalid usages will be
+                    // flagged during template type checking.
+                    if (target instanceof ReadVariableExpr) {
+                        return twoWayBindingSet(target, value);
+                    }
+                    throw new Error(`Unsupported expression in two-way action binding.`);
+                }, VisitorContextFlag.InChildOperation);
+            }
+        }
+    }
+}
+
 /**
  * Counts the number of variable slots used within each view, and stores that on the view itself, as
  * well as propagates it to the `ir.TemplateOp` for embedded views.
@@ -25030,115 +25320,6 @@ function wrapI18nIcus(job) {
     }
 }
 
-/*!
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
-/**
- * Removes any `storeLet` calls that aren't referenced outside of the current view.
- */
-function optimizeStoreLet(job) {
-    const letUsedExternally = new Set();
-    // Since `@let` declarations can be referenced in child views, both in
-    // the creation block (via listeners) and in the update block, we have
-    // to look through all the ops to find the references.
-    for (const unit of job.units) {
-        for (const op of unit.ops()) {
-            visitExpressionsInOp(op, (expr) => {
-                if (expr instanceof ContextLetReferenceExpr) {
-                    letUsedExternally.add(expr.target);
-                }
-            });
-        }
-    }
-    // TODO(crisbeto): potentially remove the unused calls completely, pending discussion.
-    for (const unit of job.units) {
-        for (const op of unit.update) {
-            transformExpressionsInOp(op, (expression) => expression instanceof StoreLetExpr && !letUsedExternally.has(expression.target)
-                ? expression.value
-                : expression, VisitorContextFlag.None);
-        }
-    }
-}
-
-/**
- * It's not allowed to access a `@let` declaration before it has been defined. This is enforced
- * already via template type checking, however it can trip some of the assertions in the pipeline.
- * E.g. the naming phase can fail because we resolved the variable here, but the variable doesn't
- * exist anymore because the optimization phase removed it since it's invalid. To avoid surfacing
- * confusing errors to users in the case where template type checking isn't running (e.g. in JIT
- * mode) this phase detects illegal forward references and replaces them with `undefined`.
- * Eventually users will see the proper error from the template type checker.
- */
-function removeIllegalLetReferences(job) {
-    for (const unit of job.units) {
-        for (const op of unit.update) {
-            if (op.kind !== OpKind.Variable ||
-                op.variable.kind !== SemanticVariableKind.Identifier ||
-                !(op.initializer instanceof StoreLetExpr)) {
-                continue;
-            }
-            const name = op.variable.identifier;
-            let current = op;
-            while (current && current.kind !== OpKind.ListEnd) {
-                transformExpressionsInOp(current, (expr) => expr instanceof LexicalReadExpr && expr.name === name ? literal$1(undefined) : expr, VisitorContextFlag.None);
-                current = current.prev;
-            }
-        }
-    }
-}
-
-/**
- * Replaces the `storeLet` ops with variables that can be
- * used to reference the value within the same view.
- */
-function generateLocalLetReferences(job) {
-    for (const unit of job.units) {
-        for (const op of unit.update) {
-            if (op.kind !== OpKind.StoreLet) {
-                continue;
-            }
-            const variable = {
-                kind: SemanticVariableKind.Identifier,
-                name: null,
-                identifier: op.declaredName,
-                local: true,
-            };
-            OpList.replace(op, createVariableOp(job.allocateXrefId(), variable, new StoreLetExpr(op.target, op.value, op.sourceSpan), VariableFlags.None));
-        }
-    }
-}
-
-/**
- * Locates all of the elements defined in a creation block and outputs an op
- * that will expose their definition location in the DOM.
- */
-function attachSourceLocations(job) {
-    if (!job.enableDebugLocations || job.relativeTemplatePath === null) {
-        return;
-    }
-    for (const unit of job.units) {
-        const locations = [];
-        for (const op of unit.create) {
-            if (op.kind === OpKind.ElementStart || op.kind === OpKind.Element) {
-                const start = op.startSourceSpan.start;
-                locations.push({
-                    targetSlot: op.handle,
-                    offset: start.offset,
-                    line: start.line,
-                    column: start.col,
-                });
-            }
-        }
-        if (locations.length > 0) {
-            unit.create.push(createSourceLocationOp(job.relativeTemplatePath, locations));
-        }
-    }
-}
-
 /**
  *
  * @license
@@ -25187,8 +25368,8 @@ const phases = [
     { kind: CompilationJobKind.Both, fn: resolveContexts },
     { kind: CompilationJobKind.Both, fn: resolveSanitizers },
     { kind: CompilationJobKind.Tmpl, fn: liftLocalRefs },
-    { kind: CompilationJobKind.Both, fn: generateNullishCoalesceExpressions },
     { kind: CompilationJobKind.Both, fn: expandSafeReads },
+    { kind: CompilationJobKind.Both, fn: requiredParentheses },
     { kind: CompilationJobKind.Both, fn: generateTemporaryVariables },
     { kind: CompilationJobKind.Both, fn: optimizeVariables },
     { kind: CompilationJobKind.Both, fn: optimizeStoreLet },
@@ -25978,15 +26159,24 @@ function convertAst(ast, job, baseSourceSpan) {
     else if (ast instanceof TypeofExpression) {
         return typeofExpr(convertAst(ast.expression, job, baseSourceSpan));
     }
+    else if (ast instanceof VoidExpression) {
+        return new VoidExpr(convertAst(ast.expression, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
+    }
     else if (ast instanceof TemplateLiteral) {
-        return new TemplateLiteralExpr(ast.elements.map((el) => {
-            return new TemplateLiteralElementExpr(el.text, convertSourceSpan(el.span, baseSourceSpan));
-        }), ast.expressions.map((expr) => convertAst(expr, job, baseSourceSpan)), convertSourceSpan(ast.span, baseSourceSpan));
+        return convertTemplateLiteral(ast, job, baseSourceSpan);
+    }
+    else if (ast instanceof TaggedTemplateLiteral) {
+        return new TaggedTemplateLiteralExpr(convertAst(ast.tag, job, baseSourceSpan), convertTemplateLiteral(ast.template, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
     }
     else {
         throw new Error(`Unhandled expression type "${ast.constructor.name}" in file "${baseSourceSpan?.start.file.url}"`);
     }
 }
+function convertTemplateLiteral(ast, job, baseSourceSpan) {
+    return new TemplateLiteralExpr(ast.elements.map((el) => {
+        return new TemplateLiteralElementExpr(el.text, convertSourceSpan(el.span, baseSourceSpan));
+    }), ast.expressions.map((expr) => convertAst(expr, job, baseSourceSpan)), convertSourceSpan(ast.span, baseSourceSpan));
+}
 function convertAstWithInterpolation(job, value, i18nMeta, sourceSpan) {
     let expression;
     if (value instanceof Interpolation$1) {
@@ -26378,7 +26568,7 @@ function getTemplateSourceLocationsEnabled() {
 
 //  if (rf & flags) { .. }
 function renderFlagCheckIfStmt(flags, statements) {
-    return ifStmt(variable(RENDER_FLAGS).bitwiseAnd(literal$1(flags), null, false), statements);
+    return ifStmt(variable(RENDER_FLAGS).bitwiseAnd(literal$1(flags), null), statements);
 }
 /**
  * Translates query flags into `TQueryFlags` type in
@@ -30717,13 +30907,6 @@ function publishFacade(global) {
     ng.ɵcompilerFacade = new CompilerFacadeImpl();
 }
 
-/**
- * @module
- * @description
- * Entry point for all public APIs of the compiler package.
- */
-new Version('19.2.1');
-
 const _I18N_ATTR = 'i18n';
 const _I18N_ATTR_PREFIX = 'i18n-';
 const _I18N_COMMENT_PREFIX_REGEXP = /^i18n:?/;
@@ -31200,6 +31383,13 @@ var FactoryTarget;
     FactoryTarget[FactoryTarget["NgModule"] = 4] = "NgModule";
 })(FactoryTarget || (FactoryTarget = {}));
 
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the compiler package.
+ */
+new Version('20.0.0-next.1');
+
 //////////////////////////////////////
 // This file only reexports content of the `src` folder. Keep it that way.
 // This function call has a global side effects and publishes the compiler into global namespace for
@@ -32130,7 +32320,7 @@ class NodeJSPathManipulation {
 // G3-ESM-MARKER: G3 uses CommonJS, but externally everything in ESM.
 // CommonJS/ESM interop for determining the current file name and containing dir.
 const isCommonJS = typeof __filename !== 'undefined';
-const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || new URL('checker-89987c98.js', document.baseURI).href));
+const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || new URL('checker-af521da6.js', document.baseURI).href));
 const currentFileName = isCommonJS ? __filename : url.fileURLToPath(currentFileUrl);
 /**
  * A wrapper around the Node.js file-system that supports readonly operations and path manipulation.
@@ -36632,6 +36822,7 @@ const BINARY_OPERATORS$1 = new Map([
     [BinaryOperator.Or, '||'],
     [BinaryOperator.Plus, '+'],
     [BinaryOperator.NullishCoalesce, '??'],
+    [BinaryOperator.Exponentiation, '**'],
 ]);
 class ExpressionTranslatorVisitor {
     factory;
@@ -36876,12 +37067,18 @@ class ExpressionTranslatorVisitor {
     visitTypeofExpr(ast, context) {
         return this.factory.createTypeOfExpression(ast.expr.visitExpression(this, context));
     }
+    visitVoidExpr(ast, context) {
+        return this.factory.createVoidExpression(ast.expr.visitExpression(this, context));
+    }
     visitUnaryOperatorExpr(ast, context) {
         if (!UNARY_OPERATORS$1.has(ast.operator)) {
             throw new Error(`Unknown unary operator: ${UnaryOperator[ast.operator]}`);
         }
         return this.factory.createUnaryExpression(UNARY_OPERATORS$1.get(ast.operator), ast.expr.visitExpression(this, context));
     }
+    visitParenthesizedExpr(ast, context) {
+        return this.factory.createParenthesizedExpression(ast.expr.visitExpression(this, context));
+    }
     visitStatements(statements, context) {
         return statements
             .map((stmt) => stmt.visitStatement(this, context))
@@ -37292,6 +37489,12 @@ class TypeTranslatorVisitor {
         }
         return ts__default["default"].factory.createTypeQueryNode(typeNode.typeName);
     }
+    visitVoidExpr(ast, context) {
+        throw new Error('Method not implemented.');
+    }
+    visitParenthesizedExpr(ast, context) {
+        throw new Error('Method not implemented.');
+    }
     translateType(type, context) {
         const typeNode = type.visitType(this, context);
         if (!ts__default["default"].isTypeNode(typeNode)) {
@@ -37363,6 +37566,7 @@ const BINARY_OPERATORS = {
     '-': ts__default["default"].SyntaxKind.MinusToken,
     '%': ts__default["default"].SyntaxKind.PercentToken,
     '*': ts__default["default"].SyntaxKind.AsteriskToken,
+    '**': ts__default["default"].SyntaxKind.AsteriskAsteriskToken,
     '!=': ts__default["default"].SyntaxKind.ExclamationEqualsToken,
     '!==': ts__default["default"].SyntaxKind.ExclamationEqualsEqualsToken,
     '||': ts__default["default"].SyntaxKind.BarBarToken,
@@ -37502,6 +37706,7 @@ class TypeScriptAstFactory {
     }
     createThrowStatement = ts__default["default"].factory.createThrowStatement;
     createTypeOfExpression = ts__default["default"].factory.createTypeOfExpression;
+    createVoidExpression = ts__default["default"].factory.createVoidExpression;
     createUnaryExpression(operator, operand) {
         return ts__default["default"].factory.createPrefixUnaryExpression(UNARY_OPERATORS[operator], operand);
     }
@@ -41233,6 +41438,7 @@ const BINARY_OPS = new Map([
     ['==', ts__default["default"].SyntaxKind.EqualsEqualsToken],
     ['===', ts__default["default"].SyntaxKind.EqualsEqualsEqualsToken],
     ['*', ts__default["default"].SyntaxKind.AsteriskToken],
+    ['**', ts__default["default"].SyntaxKind.AsteriskAsteriskToken],
     ['/', ts__default["default"].SyntaxKind.SlashToken],
     ['%', ts__default["default"].SyntaxKind.PercentToken],
     ['!=', ts__default["default"].SyntaxKind.ExclamationEqualsToken],
@@ -41411,6 +41617,12 @@ class AstTranslator {
         addParseSpanInfo(node, ast.sourceSpan);
         return node;
     }
+    visitVoidExpression(ast) {
+        const expression = wrapForDiagnostics(this.translate(ast.expression));
+        const node = ts__default["default"].factory.createVoidExpression(expression);
+        addParseSpanInfo(node, ast.sourceSpan);
+        return node;
+    }
     visitPropertyRead(ast) {
         // This is a normal property read - convert the receiver to an expression and emit the correct
         // TypeScript expression to read the property.
@@ -41562,6 +41774,9 @@ class AstTranslator {
     visitTemplateLiteralElement(ast, context) {
         throw new Error('Method not implemented');
     }
+    visitTaggedTemplateLiteral(ast) {
+        return ts__default["default"].factory.createTaggedTemplateExpression(this.translate(ast.tag), undefined, this.visitTemplateLiteral(ast.template));
+    }
     convertToSafeCall(ast, expr, args) {
         if (this.config.strictSafeNavigationTypes) {
             // "a?.method(...)" becomes (0 as any ? a!.method(...) : undefined)
@@ -41646,6 +41861,9 @@ class VeSafeLhsInferenceBugDetector {
     visitTypeofExpression(ast) {
         return ast.expression.visit(this);
     }
+    visitVoidExpression(ast) {
+        return ast.expression.visit(this);
+    }
     visitNonNullAssert(ast) {
         return ast.expression.visit(this);
     }
@@ -41667,6 +41885,9 @@ class VeSafeLhsInferenceBugDetector {
     visitTemplateLiteralElement(ast, context) {
         return false;
     }
+    visitTaggedTemplateLiteral(ast, context) {
+        return false;
+    }
 }
 
 /**