@angular/compiler 14.0.0-next.1 → 14.0.0-next.12

package/fesm2015/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v14.0.0-next.1
+ * @license Angular v14.0.0-next.12
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -224,11 +224,11 @@ class CssSelector {
                 const prefix = match[3 /* PREFIX */];
                 if (prefix === '#') {
                     // #hash
-                    current.addAttribute('id', tag.substr(1));
+                    current.addAttribute('id', tag.slice(1));
                 }
                 else if (prefix === '.') {
                     // Class
-                    current.addClassName(tag.substr(1));
+                    current.addClassName(tag.slice(1));
                 }
                 else {
                     // Element
@@ -2800,6 +2800,7 @@ Identifiers.stylePropInterpolate7 = { name: 'ɵɵstylePropInterpolate7', moduleN
 Identifiers.stylePropInterpolate8 = { name: 'ɵɵstylePropInterpolate8', moduleName: CORE };
 Identifiers.stylePropInterpolateV = { name: 'ɵɵstylePropInterpolateV', moduleName: CORE };
 Identifiers.nextContext = { name: 'ɵɵnextContext', moduleName: CORE };
+Identifiers.resetView = { name: 'ɵɵresetView', moduleName: CORE };
 Identifiers.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE };
 Identifiers.text = { name: 'ɵɵtext', moduleName: CORE };
 Identifiers.enableBindings = { name: 'ɵɵenableBindings', moduleName: CORE };
@@ -2910,6 +2911,7 @@ Identifiers.ModuleWithProviders = {
 Identifiers.defineNgModule = { name: 'ɵɵdefineNgModule', moduleName: CORE };
 Identifiers.declareNgModule = { name: 'ɵɵngDeclareNgModule', moduleName: CORE };
 Identifiers.setNgModuleScope = { name: 'ɵɵsetNgModuleScope', moduleName: CORE };
+Identifiers.registerNgModuleType = { name: 'ɵɵregisterNgModuleType', moduleName: CORE };
 Identifiers.PipeDeclaration = { name: 'ɵɵPipeDeclaration', moduleName: CORE };
 Identifiers.definePipe = { name: 'ɵɵdefinePipe', moduleName: CORE };
 Identifiers.declarePipe = { name: 'ɵɵngDeclarePipe', moduleName: CORE };
@@ -4876,6 +4878,65 @@ const IMPLICIT_REFERENCE = '$implicit';
 const NON_BINDABLE_ATTR = 'ngNonBindable';
 /** Name for the variable keeping track of the context returned by `ɵɵrestoreView`. */
 const RESTORED_VIEW_CONTEXT_NAME = 'restoredCtx';
+/** Instructions that support chaining. */
+const CHAINABLE_INSTRUCTIONS = new Set([
+    Identifiers.element,
+    Identifiers.elementStart,
+    Identifiers.elementEnd,
+    Identifiers.elementContainer,
+    Identifiers.elementContainerStart,
+    Identifiers.elementContainerEnd,
+    Identifiers.i18nExp,
+    Identifiers.listener,
+    Identifiers.classProp,
+    Identifiers.syntheticHostListener,
+    Identifiers.hostProperty,
+    Identifiers.syntheticHostProperty,
+    Identifiers.property,
+    Identifiers.propertyInterpolate1,
+    Identifiers.propertyInterpolate2,
+    Identifiers.propertyInterpolate3,
+    Identifiers.propertyInterpolate4,
+    Identifiers.propertyInterpolate5,
+    Identifiers.propertyInterpolate6,
+    Identifiers.propertyInterpolate7,
+    Identifiers.propertyInterpolate8,
+    Identifiers.propertyInterpolateV,
+    Identifiers.attribute,
+    Identifiers.attributeInterpolate1,
+    Identifiers.attributeInterpolate2,
+    Identifiers.attributeInterpolate3,
+    Identifiers.attributeInterpolate4,
+    Identifiers.attributeInterpolate5,
+    Identifiers.attributeInterpolate6,
+    Identifiers.attributeInterpolate7,
+    Identifiers.attributeInterpolate8,
+    Identifiers.attributeInterpolateV,
+    Identifiers.styleProp,
+    Identifiers.stylePropInterpolate1,
+    Identifiers.stylePropInterpolate2,
+    Identifiers.stylePropInterpolate3,
+    Identifiers.stylePropInterpolate4,
+    Identifiers.stylePropInterpolate5,
+    Identifiers.stylePropInterpolate6,
+    Identifiers.stylePropInterpolate7,
+    Identifiers.stylePropInterpolate8,
+    Identifiers.stylePropInterpolateV,
+    Identifiers.textInterpolate,
+    Identifiers.textInterpolate1,
+    Identifiers.textInterpolate2,
+    Identifiers.textInterpolate3,
+    Identifiers.textInterpolate4,
+    Identifiers.textInterpolate5,
+    Identifiers.textInterpolate6,
+    Identifiers.textInterpolate7,
+    Identifiers.textInterpolate8,
+    Identifiers.textInterpolateV,
+]);
+/** Generates a call to a single instruction. */
+function invokeInstruction(span, reference, params) {
+    return importExpr(reference, null, span).callFn(params, span);
+}
 /**
  * Creates an allocator for a temporary variable.
  *
@@ -5017,20 +5078,6 @@ function getAttrsForDirectiveMatching(elOrTpl) {
     }
     return attributesMap;
 }
-/** Returns a call expression to a chained instruction, e.g. `property(params[0])(params[1])`. */
-function chainedInstruction(reference, calls, span) {
-    let expression = importExpr(reference, null, span);
-    if (calls.length > 0) {
-        for (let i = 0; i < calls.length; i++) {
-            expression = expression.callFn(calls[i], span);
-        }
-    }
-    else {
-        // Add a blank invocation, in case the `calls` array is empty.
-        expression = expression.callFn([], span);
-    }
-    return expression;
-}
 /**
  * Gets the number of arguments expected to be passed to a generated instruction in the case of
  * interpolation instructions.
@@ -5048,6 +5095,40 @@ function getInterpolationArgsLength(interpolation) {
         return expressions.length + strings.length;
     }
 }
+/**
+ * Generates the final instruction call statements based on the passed in configuration.
+ * Will try to chain instructions as much as possible, if chaining is supported.
+ */
+function getInstructionStatements(instructions) {
+    var _a;
+    const statements = [];
+    let pendingExpression = null;
+    let pendingExpressionType = null;
+    for (const current of instructions) {
+        const resolvedParams = (_a = (typeof current.paramsOrFn === 'function' ? current.paramsOrFn() : current.paramsOrFn)) !== null && _a !== void 0 ? _a : [];
+        const params = Array.isArray(resolvedParams) ? resolvedParams : [resolvedParams];
+        // If the current instruction is the same as the previous one
+        // and it can be chained, add another call to the chain.
+        if (pendingExpressionType === current.reference &&
+            CHAINABLE_INSTRUCTIONS.has(pendingExpressionType)) {
+            // We'll always have a pending expression when there's a pending expression type.
+            pendingExpression = pendingExpression.callFn(params, pendingExpression.sourceSpan);
+        }
+        else {
+            if (pendingExpression !== null) {
+                statements.push(pendingExpression.toStmt());
+            }
+            pendingExpression = invokeInstruction(current.span, current.reference, params);
+            pendingExpressionType = current.reference;
+        }
+    }
+    // Since the current instruction adds the previous one to the statements,
+    // we may be left with the final one at the end that is still pending.
+    if (pendingExpression !== null) {
+        statements.push(pendingExpression.toStmt());
+    }
+    return statements;
+}
 
 /**
  * @license
@@ -5337,7 +5418,7 @@ class ParseLocation {
             const ch = source.charCodeAt(offset);
             if (ch == $LF) {
                 line--;
-                const priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode($LF));
+                const priorLine = source.substring(0, offset - 1).lastIndexOf(String.fromCharCode($LF));
                 col = priorLine > 0 ? offset - priorLine : offset;
             }
             else {
@@ -5892,20 +5973,49 @@ class R3JitReflector {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+/**
+ * How the selector scope of an NgModule (its declarations, imports, and exports) should be emitted
+ * as a part of the NgModule definition.
+ */
+var R3SelectorScopeMode;
+(function (R3SelectorScopeMode) {
+    /**
+     * Emit the declarations inline into the module definition.
+     *
+     * This option is useful in certain contexts where it's known that JIT support is required. The
+     * tradeoff here is that this emit style prevents directives and pipes from being tree-shaken if
+     * they are unused, but the NgModule is used.
+     */
+    R3SelectorScopeMode[R3SelectorScopeMode["Inline"] = 0] = "Inline";
+    /**
+     * Emit the declarations using a side effectful function call, `ɵɵsetNgModuleScope`, that is
+     * guarded with the `ngJitMode` flag.
+     *
+     * This form of emit supports JIT and can be optimized away if the `ngJitMode` flag is set to
+     * false, which allows unused directives and pipes to be tree-shaken.
+     */
+    R3SelectorScopeMode[R3SelectorScopeMode["SideEffect"] = 1] = "SideEffect";
+    /**
+     * Don't generate selector scopes at all.
+     *
+     * This is useful for contexts where JIT support is known to be unnecessary.
+     */
+    R3SelectorScopeMode[R3SelectorScopeMode["Omit"] = 2] = "Omit";
+})(R3SelectorScopeMode || (R3SelectorScopeMode = {}));
 /**
  * Construct an `R3NgModuleDef` for the given `R3NgModuleMetadata`.
  */
 function compileNgModule(meta) {
-    const { internalType, bootstrap, declarations, imports, exports, schemas, containsForwardDecls, emitInline, id } = meta;
+    const { adjacentType, internalType, bootstrap, declarations, imports, exports, schemas, containsForwardDecls, selectorScopeMode, id } = meta;
     const statements = [];
     const definitionMap = new DefinitionMap();
     definitionMap.set('type', internalType);
     if (bootstrap.length > 0) {
         definitionMap.set('bootstrap', refsToArray(bootstrap, containsForwardDecls));
     }
-    // If requested to emit scope information inline, pass the `declarations`, `imports` and `exports`
-    // to the `ɵɵdefineNgModule()` call. The JIT compilation uses this.
-    if (emitInline) {
+    if (selectorScopeMode === R3SelectorScopeMode.Inline) {
+        // If requested to emit scope information inline, pass the `declarations`, `imports` and
+        // `exports` to the `ɵɵdefineNgModule()` call directly.
         if (declarations.length > 0) {
             definitionMap.set('declarations', refsToArray(declarations, containsForwardDecls));
         }
@@ -5916,19 +6026,27 @@ function compileNgModule(meta) {
             definitionMap.set('exports', refsToArray(exports, containsForwardDecls));
         }
     }
-    // If not emitting inline, the scope information is not passed into `ɵɵdefineNgModule` as it would
-    // prevent tree-shaking of the declarations, imports and exports references.
-    else {
+    else if (selectorScopeMode === R3SelectorScopeMode.SideEffect) {
+        // In this mode, scope information is not passed into `ɵɵdefineNgModule` as it
+        // would prevent tree-shaking of the declarations, imports and exports references. Instead, it's
+        // patched onto the NgModule definition with a `ɵɵsetNgModuleScope` call that's guarded by the
+        // `ngJitMode` flag.
         const setNgModuleScopeCall = generateSetNgModuleScopeCall(meta);
         if (setNgModuleScopeCall !== null) {
             statements.push(setNgModuleScopeCall);
         }
     }
+    else {
+        // Selector scope emit was not requested, so skip it.
+    }
     if (schemas !== null && schemas.length > 0) {
         definitionMap.set('schemas', literalArr(schemas.map(ref => ref.value)));
     }
     if (id !== null) {
         definitionMap.set('id', id);
+        // Generate a side-effectful call to register this NgModule by its id, as per the semantics of
+        // NgModule ids.
+        statements.push(importExpr(Identifiers.registerNgModuleType).callFn([adjacentType, id]).toStmt());
     }
     const expression = importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()], undefined, true);
     const type = createNgModuleType(meta);
@@ -6024,6 +6142,9 @@ function compilePipeFromMetadata(metadata) {
     definitionMapValues.push({ key: 'type', value: metadata.type.value, quoted: false });
     // e.g. `pure: true`
     definitionMapValues.push({ key: 'pure', value: literal(metadata.pure), quoted: false });
+    if (metadata.isStandalone) {
+        definitionMapValues.push({ key: 'standalone', value: literal(true), quoted: false });
+    }
     const expression = importExpr(Identifiers.definePipe).callFn([literalMap(definitionMapValues)], undefined, true);
     const type = createPipeType(metadata);
     return { expression, type, statements: [] };
@@ -7878,7 +7999,7 @@ class ShadowCss {
                     this._scopeSelector(rule.selector, scopeSelector, hostSelector, this.strictStyling);
             }
             else if (rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||
-                rule.selector.startsWith('@document')) {
+                rule.selector.startsWith('@document') || rule.selector.startsWith('@layer')) {
                 content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
             }
             else if (rule.selector.startsWith('@font-face') || rule.selector.startsWith('@page')) {
@@ -8341,7 +8462,7 @@ function parse(value) {
         }
     }
     if (currentProp && valueStart) {
-        const styleVal = value.substr(valueStart).trim();
+        const styleVal = value.slice(valueStart).trim();
         styles.push(currentProp, valueHasQuotes ? stripUnnecessaryQuotes(styleVal) : styleVal);
     }
     return styles;
@@ -8519,7 +8640,7 @@ class StylingBuilder {
         const isClass = !isStyle && (name === 'class' || prefix === 'class.' || prefix === 'class!');
         if (isStyle || isClass) {
             const isMapBased = name.charAt(5) !== '.'; // style.prop or class.prop makes this a no
-            const property = name.substr(isMapBased ? 5 : 6); // the dot explains why there's a +1
+            const property = name.slice(isMapBased ? 5 : 6); // the dot explains why there's a +1
             if (isStyle) {
                 binding = this.registerStyleInput(property, isMapBased, expression, sourceSpan);
             }
@@ -8793,7 +8914,7 @@ function parseProperty(name) {
     let property = name;
     const unitIndex = name.lastIndexOf('.');
     if (unitIndex > 0) {
-        suffix = name.substr(unitIndex + 1);
+        suffix = name.slice(unitIndex + 1);
         property = name.substring(0, unitIndex);
     }
     return { property, suffix, hasOverrideFlag };
@@ -9340,11 +9461,15 @@ class Parser$1 {
         this._lexer = _lexer;
         this.errors = [];
     }
-    parseAction(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    parseAction(input, isAssignmentEvent, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
         this._checkNoInterpolation(input, location, interpolationConfig);
         const sourceToLex = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
-        const ast = new _ParseAST(input, location, absoluteOffset, tokens, true, this.errors, 0).parseChain();
+        let flags = 1 /* Action */;
+        if (isAssignmentEvent) {
+            flags |= 2 /* AssignmentEvent */;
+        }
+        const ast = new _ParseAST(input, location, absoluteOffset, tokens, flags, this.errors, 0).parseChain();
         return new ASTWithSource(ast, input, location, absoluteOffset, this.errors);
     }
     parseBinding(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
@@ -9371,7 +9496,7 @@ class Parser$1 {
         this._checkNoInterpolation(input, location, interpolationConfig);
         const sourceToLex = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
-        return new _ParseAST(input, location, absoluteOffset, tokens, false, this.errors, 0)
+        return new _ParseAST(input, location, absoluteOffset, tokens, 0 /* None */, this.errors, 0)
             .parseChain();
     }
     /**
@@ -9402,14 +9527,14 @@ class Parser$1 {
      */
     parseTemplateBindings(templateKey, templateValue, templateUrl, absoluteKeyOffset, absoluteValueOffset) {
         const tokens = this._lexer.tokenize(templateValue);
-        const parser = new _ParseAST(templateValue, templateUrl, absoluteValueOffset, tokens, false /* parseAction */, this.errors, 0 /* relative offset */);
+        const parser = new _ParseAST(templateValue, templateUrl, absoluteValueOffset, tokens, 0 /* None */, this.errors, 0 /* relative offset */);
         return parser.parseTemplateBindings({
             source: templateKey,
             span: new AbsoluteSourceSpan(absoluteKeyOffset, absoluteKeyOffset + templateKey.length),
         });
     }
-    parseInterpolation(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
-        const { strings, expressions, offsets } = this.splitInterpolation(input, location, interpolationConfig);
+    parseInterpolation(input, location, absoluteOffset, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+        const { strings, expressions, offsets } = this.splitInterpolation(input, location, interpolatedTokens, interpolationConfig);
         if (expressions.length === 0)
             return null;
         const expressionNodes = [];
@@ -9417,7 +9542,7 @@ class Parser$1 {
             const expressionText = expressions[i].text;
             const sourceToLex = this._stripComments(expressionText);
             const tokens = this._lexer.tokenize(sourceToLex);
-            const ast = new _ParseAST(input, location, absoluteOffset, tokens, false, this.errors, offsets[i])
+            const ast = new _ParseAST(input, location, absoluteOffset, tokens, 0 /* None */, this.errors, offsets[i])
                 .parseChain();
             expressionNodes.push(ast);
         }
@@ -9431,8 +9556,7 @@ class Parser$1 {
     parseInterpolationExpression(expression, location, absoluteOffset) {
         const sourceToLex = this._stripComments(expression);
         const tokens = this._lexer.tokenize(sourceToLex);
-        const ast = new _ParseAST(expression, location, absoluteOffset, tokens, 
-        /* parseAction */ false, this.errors, 0)
+        const ast = new _ParseAST(expression, location, absoluteOffset, tokens, 0 /* None */, this.errors, 0)
             .parseChain();
         const strings = ['', '']; // The prefix and suffix strings are both empty
         return this.createInterpolationAst(strings, [ast], expression, location, absoluteOffset);
@@ -9449,10 +9573,12 @@ class Parser$1 {
      * `SplitInterpolation` with splits that look like
      *   <raw text> <expression> <raw text> ... <raw text> <expression> <raw text>
      */
-    splitInterpolation(input, location, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    splitInterpolation(input, location, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+        var _a;
         const strings = [];
         const expressions = [];
         const offsets = [];
+        const inputToTemplateIndexMap = interpolatedTokens ? getIndexMapForOriginalTemplate(interpolatedTokens) : null;
         let i = 0;
         let atInterpolation = false;
         let extendLastString = false;
@@ -9487,7 +9613,9 @@ class Parser$1 {
                     this._reportError('Blank expressions are not allowed in interpolated strings', input, `at column ${i} in`, location);
                 }
                 expressions.push({ text, start: fullStart, end: fullEnd });
-                offsets.push(exprStart);
+                const startInOriginalTemplate = (_a = inputToTemplateIndexMap === null || inputToTemplateIndexMap === void 0 ? void 0 : inputToTemplateIndexMap.get(fullStart)) !== null && _a !== void 0 ? _a : fullStart;
+                const offset = startInOriginalTemplate + interpStart.length;
+                offsets.push(offset);
                 i = fullEnd;
                 atInterpolation = false;
             }
@@ -9603,12 +9731,12 @@ var ParseContextFlags;
     ParseContextFlags[ParseContextFlags["Writable"] = 1] = "Writable";
 })(ParseContextFlags || (ParseContextFlags = {}));
 class _ParseAST {
-    constructor(input, location, absoluteOffset, tokens, parseAction, errors, offset) {
+    constructor(input, location, absoluteOffset, tokens, parseFlags, errors, offset) {
         this.input = input;
         this.location = location;
         this.absoluteOffset = absoluteOffset;
         this.tokens = tokens;
-        this.parseAction = parseAction;
+        this.parseFlags = parseFlags;
         this.errors = errors;
         this.offset = offset;
         this.rparensExpected = 0;
@@ -9785,7 +9913,7 @@ class _ParseAST {
             const expr = this.parsePipe();
             exprs.push(expr);
             if (this.consumeOptionalCharacter($SEMICOLON)) {
-                if (!this.parseAction) {
+                if (!(this.parseFlags & 1 /* Action */)) {
                     this.error('Binding expression cannot contain chained expression');
                 }
                 while (this.consumeOptionalCharacter($SEMICOLON)) {
@@ -9809,7 +9937,7 @@ class _ParseAST {
         const start = this.inputIndex;
         let result = this.parseExpression();
         if (this.consumeOptionalOperator('|')) {
-            if (this.parseAction) {
+            if (this.parseFlags & 1 /* Action */) {
                 this.error('Cannot have a pipe in an action expression');
             }
             do {
@@ -10152,7 +10280,7 @@ class _ParseAST {
         const nameSpan = this.sourceSpan(nameStart);
         let receiver;
         if (isSafe) {
-            if (this.consumeOptionalOperator('=')) {
+            if (this.consumeOptionalAssignment()) {
                 this.error('The \'?.\' operator cannot be used in the assignment');
                 receiver = new EmptyExpr(this.span(start), this.sourceSpan(start));
             }
@@ -10161,8 +10289,8 @@ class _ParseAST {
             }
         }
         else {
-            if (this.consumeOptionalOperator('=')) {
-                if (!this.parseAction) {
+            if (this.consumeOptionalAssignment()) {
+                if (!(this.parseFlags & 1 /* Action */)) {
                     this.error('Bindings cannot contain assignments');
                     return new EmptyExpr(this.span(start), this.sourceSpan(start));
                 }
@@ -10188,6 +10316,22 @@ class _ParseAST {
         return isSafe ? new SafeCall(span, sourceSpan, receiver, args, argumentSpan) :
             new Call(span, sourceSpan, receiver, args, argumentSpan);
     }
+    consumeOptionalAssignment() {
+        // When parsing assignment events (originating from two-way-binding aka banana-in-a-box syntax),
+        // it is valid for the primary expression to be terminated by the non-null operator. This
+        // primary expression is substituted as LHS of the assignment operator to achieve
+        // two-way-binding, such that the LHS could be the non-null operator. The grammar doesn't
+        // naturally allow for this syntax, so assignment events are parsed specially.
+        if ((this.parseFlags & 2 /* AssignmentEvent */) && this.next.isOperator('!') &&
+            this.peek(1).isOperator('=')) {
+            // First skip over the ! operator.
+            this.advance();
+            // Then skip over the = operator, to fully consume the optional assignment operator.
+            this.advance();
+            return true;
+        }
+        return this.consumeOptionalOperator('=');
+    }
     parseCallArguments() {
         if (this.next.isCharacter($RPAREN))
             return [];
@@ -10480,6 +10624,41 @@ class SimpleExpressionChecker extends RecursiveAstVisitor {
         this.errors.push('pipes');
     }
 }
+/**
+ * Computes the real offset in the original template for indexes in an interpolation.
+ *
+ * Because templates can have encoded HTML entities and the input passed to the parser at this stage
+ * of the compiler is the _decoded_ value, we need to compute the real offset using the original
+ * encoded values in the interpolated tokens. Note that this is only a special case handling for
+ * `MlParserTokenType.ENCODED_ENTITY` token types. All other interpolated tokens are expected to
+ * have parts which exactly match the input string for parsing the interpolation.
+ *
+ * @param interpolatedTokens The tokens for the interpolated value.
+ *
+ * @returns A map of index locations in the decoded template to indexes in the original template
+ */
+function getIndexMapForOriginalTemplate(interpolatedTokens) {
+    let offsetMap = new Map();
+    let consumedInOriginalTemplate = 0;
+    let consumedInInput = 0;
+    let tokenIndex = 0;
+    while (tokenIndex < interpolatedTokens.length) {
+        const currentToken = interpolatedTokens[tokenIndex];
+        if (currentToken.type === 9 /* ENCODED_ENTITY */) {
+            const [decoded, encoded] = currentToken.parts;
+            consumedInOriginalTemplate += encoded.length;
+            consumedInInput += decoded.length;
+        }
+        else {
+            const lengthOfParts = currentToken.parts.reduce((sum, current) => sum + current.length, 0);
+            consumedInInput += lengthOfParts;
+            consumedInOriginalTemplate += lengthOfParts;
+        }
+        offsetMap.set(consumedInInput, consumedInOriginalTemplate);
+        tokenIndex++;
+    }
+    return offsetMap;
+}
 
 /**
  * @license
@@ -13721,7 +13900,7 @@ class EscapedCharacterCursor extends PlainCharacterCursor {
         }
     }
     decodeHexDigits(start, length) {
-        const hex = this.input.substr(start.internalState.offset, length);
+        const hex = this.input.slice(start.internalState.offset, start.internalState.offset + length);
         const charCode = parseInt(hex, 16);
         if (!isNaN(charCode)) {
             return charCode;
@@ -14878,7 +15057,7 @@ class BindingParser {
                 // Regardless, neither of these values are used in Ivy but are only here to satisfy the
                 // function signature. This should likely be refactored in the future so that `sourceSpan`
                 // isn't being used inaccurately.
-                this.parseEvent(propName, expression, sourceSpan, sourceSpan, [], targetEvents, sourceSpan);
+                this.parseEvent(propName, expression, /* isAssignmentEvent */ false, sourceSpan, sourceSpan, [], targetEvents, sourceSpan);
             }
             else {
                 this._reportError(`Value of the host listener "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`, sourceSpan);
@@ -14886,11 +15065,11 @@ class BindingParser {
         }
         return targetEvents;
     }
-    parseInterpolation(value, sourceSpan) {
+    parseInterpolation(value, sourceSpan, interpolatedTokens) {
         const sourceInfo = sourceSpan.start.toString();
         const absoluteOffset = sourceSpan.fullStart.offset;
         try {
-            const ast = this._exprParser.parseInterpolation(value, sourceInfo, absoluteOffset, this._interpolationConfig);
+            const ast = this._exprParser.parseInterpolation(value, sourceInfo, absoluteOffset, interpolatedTokens, this._interpolationConfig);
             if (ast)
                 this._reportExpressionParserErrors(ast.errors, sourceSpan);
             return ast;
@@ -15027,8 +15206,8 @@ class BindingParser {
             this._parsePropertyAst(name, this._parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
         }
     }
-    parsePropertyInterpolation(name, value, sourceSpan, valueSpan, targetMatchableAttrs, targetProps, keySpan) {
-        const expr = this.parseInterpolation(value, valueSpan || sourceSpan);
+    parsePropertyInterpolation(name, value, sourceSpan, valueSpan, targetMatchableAttrs, targetProps, keySpan, interpolatedTokens) {
+        const expr = this.parseInterpolation(value, valueSpan || sourceSpan, interpolatedTokens);
         if (expr) {
             this._parsePropertyAst(name, expr, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
             return true;
@@ -15115,30 +15294,30 @@ class BindingParser {
         return new BoundElementProperty(boundPropertyName, bindingType, securityContexts[0], boundProp.expression, unit, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
     }
     // TODO: keySpan should be required but was made optional to avoid changing VE parser.
-    parseEvent(name, expression, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
+    parseEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
         if (name.length === 0) {
             this._reportError(`Event name is missing in binding`, sourceSpan);
         }
         if (isAnimationLabel(name)) {
-            name = name.substr(1);
+            name = name.slice(1);
             if (keySpan !== undefined) {
                 keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
             }
-            this._parseAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan);
+            this._parseAnimationEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetEvents, keySpan);
         }
         else {
-            this._parseRegularEvent(name, expression, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan);
+            this._parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan);
         }
     }
     calcPossibleSecurityContexts(selector, propName, isAttribute) {
         const prop = this._schemaRegistry.getMappedPropName(propName);
         return calcPossibleSecurityContexts(this._schemaRegistry, selector, prop, isAttribute);
     }
-    _parseAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan) {
+    _parseAnimationEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetEvents, keySpan) {
         const matches = splitAtPeriod(name, [name, '']);
         const eventName = matches[0];
         const phase = matches[1].toLowerCase();
-        const ast = this._parseAction(expression, handlerSpan);
+        const ast = this._parseAction(expression, isAssignmentEvent, handlerSpan);
         targetEvents.push(new ParsedEvent(eventName, phase, 1 /* Animation */, ast, sourceSpan, handlerSpan, keySpan));
         if (eventName.length === 0) {
             this._reportError(`Animation event name is missing in binding`, sourceSpan);
@@ -15152,20 +15331,20 @@ class BindingParser {
             this._reportError(`The animation trigger output event (@${eventName}) is missing its phase value name (start or done are currently supported)`, sourceSpan);
         }
     }
-    _parseRegularEvent(name, expression, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
+    _parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
         // long format: 'target: eventName'
         const [target, eventName] = splitAtColon(name, [null, name]);
-        const ast = this._parseAction(expression, handlerSpan);
+        const ast = this._parseAction(expression, isAssignmentEvent, handlerSpan);
         targetMatchableAttrs.push([name, ast.source]);
         targetEvents.push(new ParsedEvent(eventName, target, 0 /* Regular */, ast, sourceSpan, handlerSpan, keySpan));
         // Don't detect directives for event names for now,
         // so don't add the event name to the matchableAttrs
     }
-    _parseAction(value, sourceSpan) {
+    _parseAction(value, isAssignmentEvent, sourceSpan) {
         const sourceInfo = (sourceSpan && sourceSpan.start || '(unknown').toString();
         const absoluteOffset = (sourceSpan && sourceSpan.start) ? sourceSpan.start.offset : 0;
         try {
-            const ast = this._exprParser.parseAction(value, sourceInfo, absoluteOffset, this._interpolationConfig);
+            const ast = this._exprParser.parseAction(value, isAssignmentEvent, sourceInfo, absoluteOffset, this._interpolationConfig);
             if (ast) {
                 this._reportExpressionParserErrors(ast.errors, sourceSpan);
             }
@@ -15525,7 +15704,7 @@ class HtmlAstToIvyAst {
         return new TextAttribute(attribute.name, attribute.value, attribute.sourceSpan, attribute.keySpan, attribute.valueSpan, attribute.i18n);
     }
     visitText(text) {
-        return this._visitTextWithInterpolation(text.value, text.sourceSpan, text.i18n);
+        return this._visitTextWithInterpolation(text.value, text.sourceSpan, text.tokens, text.i18n);
     }
     visitExpansion(expansion) {
         if (!expansion.i18n) {
@@ -15555,7 +15734,7 @@ class HtmlAstToIvyAst {
                 vars[formattedKey] = new BoundText(ast, value.sourceSpan);
             }
             else {
-                placeholders[key] = this._visitTextWithInterpolation(value.text, value.sourceSpan);
+                placeholders[key] = this._visitTextWithInterpolation(value.text, value.sourceSpan, null);
             }
         });
         return new Icu$1(vars, placeholders, expansion.sourceSpan, message);
@@ -15589,6 +15768,7 @@ class HtmlAstToIvyAst {
         return { bound, literal };
     }
     parseAttribute(isTemplateElement, attribute, matchableAttributes, parsedProperties, boundEvents, variables, references) {
+        var _a;
         const name = normalizeAttributeName(attribute.name);
         const value = attribute.value;
         const srcSpan = attribute.sourceSpan;
@@ -15627,7 +15807,7 @@ class HtmlAstToIvyAst {
                 const events = [];
                 const identifier = bindParts[IDENT_KW_IDX];
                 const keySpan = createKeySpan(srcSpan, bindParts[KW_ON_IDX], identifier);
-                this.bindingParser.parseEvent(identifier, value, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events, keySpan);
+                this.bindingParser.parseEvent(identifier, value, /* isAssignmentEvent */ false, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events, keySpan);
                 addEvents(events, boundEvents);
             }
             else if (bindParts[KW_BINDON_IDX]) {
@@ -15671,19 +15851,19 @@ class HtmlAstToIvyAst {
             }
             else {
                 const events = [];
-                this.bindingParser.parseEvent(identifier, value, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events, keySpan);
+                this.bindingParser.parseEvent(identifier, value, /* isAssignmentEvent */ false, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events, keySpan);
                 addEvents(events, boundEvents);
             }
             return true;
         }
         // No explicit binding found.
         const keySpan = createKeySpan(srcSpan, '' /* prefix */, name);
-        const hasBinding = this.bindingParser.parsePropertyInterpolation(name, value, srcSpan, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan);
+        const hasBinding = this.bindingParser.parsePropertyInterpolation(name, value, srcSpan, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan, (_a = attribute.valueTokens) !== null && _a !== void 0 ? _a : null);
         return hasBinding;
     }
-    _visitTextWithInterpolation(value, sourceSpan, i18n) {
+    _visitTextWithInterpolation(value, sourceSpan, interpolatedTokens, i18n) {
         const valueNoNgsp = replaceNgsp(value);
-        const expr = this.bindingParser.parseInterpolation(valueNoNgsp, sourceSpan);
+        const expr = this.bindingParser.parseInterpolation(valueNoNgsp, sourceSpan, interpolatedTokens);
         return expr ? new BoundText(expr, sourceSpan, i18n) : new Text$3(valueNoNgsp, sourceSpan);
     }
     parseVariable(identifier, value, sourceSpan, keySpan, valueSpan, variables) {
@@ -15709,7 +15889,7 @@ class HtmlAstToIvyAst {
     }
     parseAssignmentEvent(name, expression, sourceSpan, valueSpan, targetMatchableAttrs, boundEvents, keySpan) {
         const events = [];
-        this.bindingParser.parseEvent(`${name}Change`, `${expression}=$event`, sourceSpan, valueSpan || sourceSpan, targetMatchableAttrs, events, keySpan);
+        this.bindingParser.parseEvent(`${name}Change`, `${expression} =$event`, /* isAssignmentEvent */ true, sourceSpan, valueSpan || sourceSpan, targetMatchableAttrs, events, keySpan);
         addEvents(events, boundEvents);
     }
     reportError(message, sourceSpan, level = ParseErrorLevel.ERROR) {
@@ -16498,7 +16678,8 @@ class I18nMetaVisitor {
      */
     _parseMetadata(meta) {
         return typeof meta === 'string' ? parseI18nMeta(meta) :
-            meta instanceof Message ? meta : {};
+            meta instanceof Message ? meta :
+                {};
     }
     /**
      * Generate (or restore) message id if not specified already.
@@ -16523,9 +16704,9 @@ class I18nMetaVisitor {
             // `packages/compiler/src/render3/view/template.ts`).
             // In that case we want to reuse the legacy message generated in the 1st pass (see
             // `setI18nRefs()`).
-            const previousMessage = meta instanceof Message ?
-                meta :
-                meta instanceof IcuPlaceholder ? meta.previousMessage : undefined;
+            const previousMessage = meta instanceof Message ? meta :
+                meta instanceof IcuPlaceholder ? meta.previousMessage :
+                    undefined;
             message.legacyIds = previousMessage ? previousMessage.legacyIds : [];
         }
     }
@@ -16570,10 +16751,14 @@ function i18nMetaToJSDoc(meta) {
     if (meta.description) {
         tags.push({ tagName: "desc" /* Desc */, text: meta.description });
     }
+    else {
+        // Suppress the JSCompiler warning that a `@desc` was not given for this message.
+        tags.push({ tagName: "suppress" /* Suppress */, text: '{msgDescriptions}' });
+    }
     if (meta.meaning) {
         tags.push({ tagName: "meaning" /* Meaning */, text: meta.meaning });
     }
-    return tags.length == 0 ? null : jsDocComment(tags);
+    return jsDocComment(tags);
 }
 
 /** Closure uses `goog.getMsg(message)` to lookup translations */
@@ -16591,10 +16776,7 @@ function createGoogleGetMsgStatements(variable$1, message, closureVar, params) {
     // const MSG_... = goog.getMsg(..);
     // I18N_X = MSG_...;
     const googGetMsgStmt = closureVar.set(variable(GOOG_GET_MSG).callFn(args)).toConstDecl();
-    const metaComment = i18nMetaToJSDoc(message);
-    if (metaComment !== null) {
-        googGetMsgStmt.addLeadingComment(metaComment);
-    }
+    googGetMsgStmt.addLeadingComment(i18nMetaToJSDoc(message));
     const i18nAssignmentStmt = new ExpressionStatement(variable$1.set(closureVar));
     return [googGetMsgStmt, i18nAssignmentStmt];
 }
@@ -16775,13 +16957,27 @@ function prepareEventListenerParameters(eventAst, handlerName = null, scope = nu
         scope.getOrCreateSharedContextVar(0);
     const bindingStatements = convertActionBinding(scope, implicitReceiverExpr, handler, 'b', eventAst.handlerSpan, implicitReceiverAccesses, EVENT_BINDING_SCOPE_GLOBALS);
     const statements = [];
-    if (scope) {
+    const variableDeclarations = scope === null || scope === void 0 ? void 0 : scope.variableDeclarations();
+    const restoreViewStatement = scope === null || scope === void 0 ? void 0 : scope.restoreViewStatement();
+    if (variableDeclarations) {
         // `variableDeclarations` needs to run first, because
         // `restoreViewStatement` depends on the result.
-        statements.push(...scope.variableDeclarations());
-        statements.unshift(...scope.restoreViewStatement());
+        statements.push(...variableDeclarations);
     }
     statements.push(...bindingStatements);
+    if (restoreViewStatement) {
+        statements.unshift(restoreViewStatement);
+        // If there's a `restoreView` call, we need to reset the view at the end of the listener
+        // in order to avoid a leak. If there's a `return` statement already, we wrap it in the
+        // call, e.g. `return resetView(ctx.foo())`. Otherwise we add the call as the last statement.
+        const lastStatement = statements[statements.length - 1];
+        if (lastStatement instanceof ReturnStatement) {
+            statements[statements.length - 1] = new ReturnStatement(invokeInstruction(lastStatement.value.sourceSpan, Identifiers.resetView, [lastStatement.value]));
+        }
+        else {
+            statements.push(new ExpressionStatement(invokeInstruction(null, Identifiers.resetView, [])));
+        }
+    }
     const eventName = type === 1 /* Animation */ ? prepareSyntheticListenerName(name, phase) : name;
     const fnName = handlerName && sanitizeIdentifier(handlerName);
     const fnArgs = [];
@@ -16925,9 +17121,9 @@ class TemplateDefinitionBuilder {
             this.i18nEnd(null, selfClosingI18nInstruction);
         }
         // Generate all the creation mode instructions (e.g. resolve bindings in listeners)
-        const creationStatements = this._creationCodeFns.map((fn) => fn());
+        const creationStatements = getInstructionStatements(this._creationCodeFns);
         // Generate all the update mode instructions (e.g. resolve property or text bindings)
-        const updateStatements = this._updateCodeFns.map((fn) => fn());
+        const updateStatements = getInstructionStatements(this._updateCodeFns);
         //  Variable declaration must occur after binding resolution so we can generate context
         //  instructions that build on each other.
         // e.g. const b = nextContext().$implicit(); const b = nextContext();
@@ -17080,7 +17276,7 @@ class TemplateDefinitionBuilder {
                     if (Object.keys(icuMapping).length) {
                         args.push(mapLiteral(icuMapping, true));
                     }
-                    return instruction(null, Identifiers.i18nPostprocess, args);
+                    return invokeInstruction(null, Identifiers.i18nPostprocess, args);
                 };
             }
             this.i18nTranslate(meta, params, context.ref, transformFn);
@@ -17115,14 +17311,12 @@ class TemplateDefinitionBuilder {
         // setup accumulated bindings
         const { index, bindings } = this.i18n;
         if (bindings.size) {
-            const chainBindings = [];
-            bindings.forEach(binding => {
-                chainBindings.push({ sourceSpan: span, value: () => this.convertPropertyBinding(binding) });
-            });
-            // for i18n block, advance to the most recent element index (by taking the current number of
-            // elements and subtracting one) before invoking `i18nExp` instructions, to make sure the
-            // necessary lifecycle hooks of components/directives are properly flushed.
-            this.updateInstructionChainWithAdvance(this.getConstCount() - 1, Identifiers.i18nExp, chainBindings);
+            for (const binding of bindings) {
+                // for i18n block, advance to the most recent element index (by taking the current number of
+                // elements and subtracting one) before invoking `i18nExp` instructions, to make sure the
+                // necessary lifecycle hooks of components/directives are properly flushed.
+                this.updateInstructionWithAdvance(this.getConstCount() - 1, span, Identifiers.i18nExp, () => this.convertPropertyBinding(binding));
+            }
             this.updateInstruction(span, Identifiers.i18nApply, [literal(index)]);
         }
         if (!selfClosing) {
@@ -17133,7 +17327,6 @@ class TemplateDefinitionBuilder {
     i18nAttributesInstruction(nodeIndex, attrs, sourceSpan) {
         let hasBindings = false;
         const i18nAttrArgs = [];
-        const bindings = [];
         attrs.forEach(attr => {
             const message = attr.i18n;
             const converted = attr.value.visit(this._valueConverter);
@@ -17144,16 +17337,10 @@ class TemplateDefinitionBuilder {
                 i18nAttrArgs.push(literal(attr.name), this.i18nTranslate(message, params));
                 converted.expressions.forEach(expression => {
                     hasBindings = true;
-                    bindings.push({
-                        sourceSpan,
-                        value: () => this.convertPropertyBinding(expression),
-                    });
+                    this.updateInstructionWithAdvance(nodeIndex, sourceSpan, Identifiers.i18nExp, () => this.convertPropertyBinding(expression));
                 });
             }
         });
-        if (bindings.length > 0) {
-            this.updateInstructionChainWithAdvance(nodeIndex, Identifiers.i18nExp, bindings);
-        }
         if (i18nAttrArgs.length > 0) {
             const index = literal(this.allocateDataSlot());
             const constIndex = this.addToConsts(literalArr(i18nAttrArgs));
@@ -17282,11 +17469,9 @@ class TemplateDefinitionBuilder {
             }
             // Generate Listeners (outputs)
             if (element.outputs.length > 0) {
-                const listeners = element.outputs.map((outputAst) => ({
-                    sourceSpan: outputAst.sourceSpan,
-                    params: this.prepareListenerParameter(element.name, outputAst, elementIndex)
-                }));
-                this.creationInstructionChain(Identifiers.listener, listeners);
+                for (const outputAst of element.outputs) {
+                    this.creationInstruction(outputAst.sourceSpan, Identifiers.listener, this.prepareListenerParameter(element.name, outputAst, elementIndex));
+                }
             }
             // Note: it's important to keep i18n/i18nStart instructions after i18nAttributes and
             // listeners, to make sure i18nAttributes instruction targets current element at runtime.
@@ -17327,9 +17512,8 @@ class TemplateDefinitionBuilder {
                 const hasValue = value instanceof LiteralPrimitive ? !!value.value : true;
                 this.allocateBindingSlots(value);
                 propertyBindings.push({
-                    name: prepareSyntheticPropertyName(input.name),
-                    sourceSpan: input.sourceSpan,
-                    value: () => hasValue ? this.convertPropertyBinding(value) : emptyValueBindInstruction
+                    span: input.sourceSpan,
+                    paramsOrFn: getBindingFunctionParams(() => hasValue ? this.convertPropertyBinding(value) : emptyValueBindInstruction, prepareSyntheticPropertyName(input.name))
                 });
             }
             else {
@@ -17366,10 +17550,8 @@ class TemplateDefinitionBuilder {
                             // [prop]="value"
                             // Collect all the properties so that we can chain into a single function at the end.
                             propertyBindings.push({
-                                name: attrName,
-                                sourceSpan: input.sourceSpan,
-                                value: () => this.convertPropertyBinding(value),
-                                params
+                                span: input.sourceSpan,
+                                paramsOrFn: getBindingFunctionParams(() => this.convertPropertyBinding(value), attrName, params)
                             });
                         }
                     }
@@ -17383,10 +17565,8 @@ class TemplateDefinitionBuilder {
                             // [attr.name]="value" or attr.name="{{value}}"
                             // Collect the attribute bindings so that they can be chained at the end.
                             attributeBindings.push({
-                                name: attrName,
-                                sourceSpan: input.sourceSpan,
-                                value: () => this.convertPropertyBinding(boundValue),
-                                params
+                                span: input.sourceSpan,
+                                paramsOrFn: getBindingFunctionParams(() => this.convertPropertyBinding(boundValue), attrName, params)
                             });
                         }
                     }
@@ -17402,11 +17582,11 @@ class TemplateDefinitionBuilder {
                 }
             }
         });
-        if (propertyBindings.length > 0) {
-            this.updateInstructionChainWithAdvance(elementIndex, Identifiers.property, propertyBindings);
+        for (const propertyBinding of propertyBindings) {
+            this.updateInstructionWithAdvance(elementIndex, propertyBinding.span, Identifiers.property, propertyBinding.paramsOrFn);
         }
-        if (attributeBindings.length > 0) {
-            this.updateInstructionChainWithAdvance(elementIndex, Identifiers.attribute, attributeBindings);
+        for (const attributeBinding of attributeBindings) {
+            this.updateInstructionWithAdvance(elementIndex, attributeBinding.span, Identifiers.attribute, attributeBinding.paramsOrFn);
         }
         // Traverse element child nodes
         visitAll$1(this, element.children);
@@ -17486,12 +17666,8 @@ class TemplateDefinitionBuilder {
                 this.templatePropertyBindings(templateIndex, inputs);
             }
             // Generate listeners for directive output
-            if (template.outputs.length > 0) {
-                const listeners = template.outputs.map((outputAst) => ({
-                    sourceSpan: outputAst.sourceSpan,
-                    params: this.prepareListenerParameter('ng_template', outputAst, templateIndex)
-                }));
-                this.creationInstructionChain(Identifiers.listener, listeners);
+            for (const outputAst of template.outputs) {
+                this.creationInstruction(outputAst.sourceSpan, Identifiers.listener, this.prepareListenerParameter('ng_template', outputAst, templateIndex));
             }
         }
     }
@@ -17546,7 +17722,7 @@ class TemplateDefinitionBuilder {
         const transformFn = (raw) => {
             const params = Object.assign(Object.assign({}, vars), placeholders);
             const formatted = i18nFormatPlaceholderNames(params, /* useCamelCase */ false);
-            return instruction(null, Identifiers.i18nPostprocess, [raw, mapLiteral(formatted, true)]);
+            return invokeInstruction(null, Identifiers.i18nPostprocess, [raw, mapLiteral(formatted, true)]);
         };
         // in case the whole i18n message is a single ICU - we do not need to
         // create a separate top-level translation, we can use the root ref instead
@@ -17588,32 +17764,33 @@ class TemplateDefinitionBuilder {
     }
     templatePropertyBindings(templateIndex, attrs) {
         const propertyBindings = [];
-        attrs.forEach(input => {
-            if (input instanceof BoundAttribute) {
-                const value = input.value.visit(this._valueConverter);
-                if (value !== undefined) {
-                    this.allocateBindingSlots(value);
-                    if (value instanceof Interpolation) {
-                        // Params typically contain attribute namespace and value sanitizer, which is applicable
-                        // for regular HTML elements, but not applicable for <ng-template> (since props act as
-                        // inputs to directives), so keep params array empty.
-                        const params = [];
-                        // prop="{{value}}" case
-                        this.interpolatedUpdateInstruction(getPropertyInterpolationExpression(value), templateIndex, input.name, input, value, params);
-                    }
-                    else {
-                        // [prop]="value" case
-                        propertyBindings.push({
-                            name: input.name,
-                            sourceSpan: input.sourceSpan,
-                            value: () => this.convertPropertyBinding(value)
-                        });
-                    }
-                }
+        for (const input of attrs) {
+            if (!(input instanceof BoundAttribute)) {
+                continue;
             }
-        });
-        if (propertyBindings.length > 0) {
-            this.updateInstructionChainWithAdvance(templateIndex, Identifiers.property, propertyBindings);
+            const value = input.value.visit(this._valueConverter);
+            if (value === undefined) {
+                continue;
+            }
+            this.allocateBindingSlots(value);
+            if (value instanceof Interpolation) {
+                // Params typically contain attribute namespace and value sanitizer, which is applicable
+                // for regular HTML elements, but not applicable for <ng-template> (since props act as
+                // inputs to directives), so keep params array empty.
+                const params = [];
+                // prop="{{value}}" case
+                this.interpolatedUpdateInstruction(getPropertyInterpolationExpression(value), templateIndex, input.name, input, value, params);
+            }
+            else {
+                // [prop]="value" case
+                propertyBindings.push({
+                    span: input.sourceSpan,
+                    paramsOrFn: getBindingFunctionParams(() => this.convertPropertyBinding(value), input.name)
+                });
+            }
+        }
+        for (const propertyBinding of propertyBindings) {
+            this.updateInstructionWithAdvance(templateIndex, propertyBinding.span, Identifiers.property, propertyBinding.paramsOrFn);
         }
     }
     // Bindings must only be resolved after all local refs have been visited, so all
@@ -17621,39 +17798,23 @@ class TemplateDefinitionBuilder {
     // Otherwise, we wouldn't be able to support local refs that are defined after their
     // bindings. e.g. {{ foo }} <div #foo></div>
     instructionFn(fns, span, reference, paramsOrFn, prepend = false) {
-        fns[prepend ? 'unshift' : 'push'](() => {
-            const params = Array.isArray(paramsOrFn) ? paramsOrFn : paramsOrFn();
-            return instruction(span, reference, params).toStmt();
-        });
+        fns[prepend ? 'unshift' : 'push']({ span, reference, paramsOrFn });
     }
     processStylingUpdateInstruction(elementIndex, instruction) {
         let allocateBindingSlots = 0;
         if (instruction) {
-            const calls = [];
-            instruction.calls.forEach(call => {
+            for (const call of instruction.calls) {
                 allocateBindingSlots += call.allocateBindingSlots;
-                calls.push({
-                    sourceSpan: call.sourceSpan,
-                    value: () => {
-                        return call.params(value => (call.supportsInterpolation && value instanceof Interpolation) ?
-                            this.getUpdateInstructionArguments(value) :
-                            this.convertPropertyBinding(value));
-                    }
-                });
-            });
-            this.updateInstructionChainWithAdvance(elementIndex, instruction.reference, calls);
+                this.updateInstructionWithAdvance(elementIndex, call.sourceSpan, instruction.reference, () => call.params(value => (call.supportsInterpolation && value instanceof Interpolation) ?
+                    this.getUpdateInstructionArguments(value) :
+                    this.convertPropertyBinding(value)));
+            }
         }
         return allocateBindingSlots;
     }
     creationInstruction(span, reference, paramsOrFn, prepend) {
         this.instructionFn(this._creationCodeFns, span, reference, paramsOrFn || [], prepend);
     }
-    creationInstructionChain(reference, calls) {
-        const span = calls.length ? calls[0].sourceSpan : null;
-        this._creationCodeFns.push(() => {
-            return chainedInstruction(reference, calls.map(call => call.params()), span).toStmt();
-        });
-    }
     updateInstructionWithAdvance(nodeIndex, span, reference, paramsOrFn) {
         this.addAdvanceInstructionIfNecessary(nodeIndex, span);
         this.updateInstruction(span, reference, paramsOrFn);
@@ -17661,28 +17822,6 @@ class TemplateDefinitionBuilder {
     updateInstruction(span, reference, paramsOrFn) {
         this.instructionFn(this._updateCodeFns, span, reference, paramsOrFn || []);
     }
-    updateInstructionChain(reference, bindings) {
-        const span = bindings.length ? bindings[0].sourceSpan : null;
-        this._updateCodeFns.push(() => {
-            const calls = bindings.map(property => {
-                const value = property.value();
-                const fnParams = Array.isArray(value) ? value : [value];
-                if (property.params) {
-                    fnParams.push(...property.params);
-                }
-                if (property.name) {
-                    // We want the property name to always be the first function parameter.
-                    fnParams.unshift(literal(property.name));
-                }
-                return fnParams;
-            });
-            return chainedInstruction(reference, calls, span).toStmt();
-        });
-    }
-    updateInstructionChainWithAdvance(nodeIndex, reference, bindings) {
-        this.addAdvanceInstructionIfNecessary(nodeIndex, bindings.length ? bindings[0].sourceSpan : null);
-        this.updateInstructionChain(reference, bindings);
-    }
     addAdvanceInstructionIfNecessary(nodeIndex, span) {
         if (nodeIndex !== this._currentIndex) {
             const delta = nodeIndex - this._currentIndex;
@@ -17968,9 +18107,6 @@ function pureFunctionCallInfo(args) {
         isVarLength: !identifier,
     };
 }
-function instruction(span, reference, params) {
-    return importExpr(reference, null, span).callFn(params, span);
-}
 // e.g. x(2);
 function generateNextContextExpr(relativeLevelDiff) {
     return importExpr(Identifiers.nextContext)
@@ -18173,21 +18309,22 @@ class BindingScope {
         }
     }
     restoreViewStatement() {
-        const statements = [];
         if (this.restoreViewVariable) {
-            const restoreCall = instruction(null, Identifiers.restoreView, [this.restoreViewVariable]);
+            const restoreCall = invokeInstruction(null, Identifiers.restoreView, [this.restoreViewVariable]);
             // Either `const restoredCtx = restoreView($state$);` or `restoreView($state$);`
             // depending on whether it is being used.
-            statements.push(this.usesRestoredViewContext ?
+            return this.usesRestoredViewContext ?
                 variable(RESTORED_VIEW_CONTEXT_NAME).set(restoreCall).toConstDecl() :
-                restoreCall.toStmt());
+                restoreCall.toStmt();
         }
-        return statements;
+        return null;
     }
     viewSnapshotStatements() {
         // const $state$ = getCurrentView();
         return this.restoreViewVariable ?
-            [this.restoreViewVariable.set(instruction(null, Identifiers.getCurrentView, [])).toConstDecl()] :
+            [
+                this.restoreViewVariable.set(invokeInstruction(null, Identifiers.getCurrentView, [])).toConstDecl()
+            ] :
             [];
     }
     isListenerScope() {
@@ -18460,6 +18597,20 @@ function isTextNode(node) {
 function hasTextChildrenOnly(children) {
     return children.every(isTextNode);
 }
+function getBindingFunctionParams(deferredParams, name, eagerParams) {
+    return () => {
+        const value = deferredParams();
+        const fnParams = Array.isArray(value) ? value : [value];
+        if (eagerParams) {
+            fnParams.push(...eagerParams);
+        }
+        if (name) {
+            // We want the property name to always be the first function parameter.
+            fnParams.unshift(literal(name));
+        }
+        return fnParams;
+    };
+}
 /** Name of the global variable that is used to determine if we use Closure translations or not */
 const NG_I18N_CLOSURE_MODE = 'ngI18nClosureMode';
 /**
@@ -18556,6 +18707,9 @@ function baseDirectiveFields(meta, constantPool, bindingParser) {
     if (meta.exportAs !== null) {
         definitionMap.set('exportAs', literalArr(meta.exportAs.map(e => literal(e))));
     }
+    if (meta.isStandalone) {
+        definitionMap.set('standalone', literal(true));
+    }
     return definitionMap;
 }
 /**
@@ -18841,14 +18995,14 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
     if (classAttr !== undefined) {
         styleBuilder.registerClassAttr(classAttr);
     }
-    const createStatements = [];
-    const updateStatements = [];
+    const createInstructions = [];
+    const updateInstructions = [];
+    const updateVariables = [];
     const hostBindingSourceSpan = typeSourceSpan;
     // Calculate host event bindings
     const eventBindings = bindingParser.createDirectiveHostEventAsts(hostBindingsMetadata.listeners, hostBindingSourceSpan);
     if (eventBindings && eventBindings.length) {
-        const listeners = createHostListeners(eventBindings, name);
-        createStatements.push(...listeners);
+        createInstructions.push(...createHostListeners(eventBindings, name));
     }
     // Calculate the host property bindings
     const bindings = bindingParser.createBoundHostProperties(hostBindingsMetadata.properties, hostBindingSourceSpan);
@@ -18884,7 +19038,7 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
     const propertyBindings = [];
     const attributeBindings = [];
     const syntheticHostBindings = [];
-    allOtherBindings.forEach((binding) => {
+    for (const binding of allOtherBindings) {
         // resolve literal arrays and literal objects
         const value = binding.expression.visit(getValueConverter());
         const bindingExpr = bindingFn(bindingContext, value);
@@ -18910,7 +19064,7 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
         if (sanitizerFn) {
             instructionParams.push(sanitizerFn);
         }
-        updateStatements.push(...bindingExpr.stmts);
+        updateVariables.push(...bindingExpr.stmts);
         if (instruction === Identifiers.hostProperty) {
             propertyBindings.push(instructionParams);
         }
@@ -18921,17 +19075,17 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
             syntheticHostBindings.push(instructionParams);
         }
         else {
-            updateStatements.push(importExpr(instruction).callFn(instructionParams).toStmt());
+            updateInstructions.push({ reference: instruction, paramsOrFn: instructionParams, span: null });
         }
-    });
-    if (propertyBindings.length > 0) {
-        updateStatements.push(chainedInstruction(Identifiers.hostProperty, propertyBindings).toStmt());
     }
-    if (attributeBindings.length > 0) {
-        updateStatements.push(chainedInstruction(Identifiers.attribute, attributeBindings).toStmt());
+    for (const bindingParams of propertyBindings) {
+        updateInstructions.push({ reference: Identifiers.hostProperty, paramsOrFn: bindingParams, span: null });
     }
-    if (syntheticHostBindings.length > 0) {
-        updateStatements.push(chainedInstruction(Identifiers.syntheticHostProperty, syntheticHostBindings).toStmt());
+    for (const bindingParams of attributeBindings) {
+        updateInstructions.push({ reference: Identifiers.attribute, paramsOrFn: bindingParams, span: null });
+    }
+    for (const bindingParams of syntheticHostBindings) {
+        updateInstructions.push({ reference: Identifiers.syntheticHostProperty, paramsOrFn: bindingParams, span: null });
     }
     // since we're dealing with directives/components and both have hostBinding
     // functions, we need to generate a special hostAttrs instruction that deals
@@ -18947,30 +19101,30 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
         // the update block of a component/directive templateFn/hostBindingsFn so that the bindings
         // are evaluated and updated for the element.
         styleBuilder.buildUpdateLevelInstructions(getValueConverter()).forEach(instruction => {
-            if (instruction.calls.length > 0) {
-                const calls = [];
-                instruction.calls.forEach(call => {
-                    // we subtract a value of `1` here because the binding slot was already allocated
-                    // at the top of this method when all the input bindings were counted.
-                    totalHostVarsCount +=
-                        Math.max(call.allocateBindingSlots - MIN_STYLING_BINDING_SLOTS_REQUIRED, 0);
-                    calls.push(convertStylingCall(call, bindingContext, bindingFn));
+            for (const call of instruction.calls) {
+                // we subtract a value of `1` here because the binding slot was already allocated
+                // at the top of this method when all the input bindings were counted.
+                totalHostVarsCount +=
+                    Math.max(call.allocateBindingSlots - MIN_STYLING_BINDING_SLOTS_REQUIRED, 0);
+                updateInstructions.push({
+                    reference: instruction.reference,
+                    paramsOrFn: convertStylingCall(call, bindingContext, bindingFn),
+                    span: null
                 });
-                updateStatements.push(chainedInstruction(instruction.reference, calls).toStmt());
             }
         });
     }
     if (totalHostVarsCount) {
         definitionMap.set('hostVars', literal(totalHostVarsCount));
     }
-    if (createStatements.length > 0 || updateStatements.length > 0) {
+    if (createInstructions.length > 0 || updateInstructions.length > 0) {
         const hostBindingsFnName = name ? `${name}_HostBindings` : null;
         const statements = [];
-        if (createStatements.length > 0) {
-            statements.push(renderFlagCheckIfStmt(1 /* Create */, createStatements));
+        if (createInstructions.length > 0) {
+            statements.push(renderFlagCheckIfStmt(1 /* Create */, getInstructionStatements(createInstructions)));
         }
-        if (updateStatements.length > 0) {
-            statements.push(renderFlagCheckIfStmt(2 /* Update */, updateStatements));
+        if (updateInstructions.length > 0) {
+            statements.push(renderFlagCheckIfStmt(2 /* Update */, updateVariables.concat(getInstructionStatements(updateInstructions))));
         }
         return fn([new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null)], statements, INFERRED_TYPE, null, hostBindingsFnName);
     }
@@ -19006,10 +19160,10 @@ function getBindingNameAndInstruction(binding) {
     return { bindingName, instruction, isAttribute: !!attrMatches };
 }
 function createHostListeners(eventBindings, name) {
-    const listeners = [];
-    const syntheticListeners = [];
+    const listenerParams = [];
+    const syntheticListenerParams = [];
     const instructions = [];
-    eventBindings.forEach(binding => {
+    for (const binding of eventBindings) {
         let bindingName = binding.name && sanitizeIdentifier(binding.name);
         const bindingFnName = binding.type === 1 /* Animation */ ?
             prepareSyntheticListenerFunctionName(bindingName, binding.targetOrPhase) :
@@ -19017,17 +19171,17 @@ function createHostListeners(eventBindings, name) {
         const handlerName = name && bindingName ? `${name}_${bindingFnName}_HostBindingHandler` : null;
         const params = prepareEventListenerParameters(BoundEvent.fromParsedEvent(binding), handlerName);
         if (binding.type == 1 /* Animation */) {
-            syntheticListeners.push(params);
+            syntheticListenerParams.push(params);
         }
         else {
-            listeners.push(params);
+            listenerParams.push(params);
         }
-    });
-    if (syntheticListeners.length > 0) {
-        instructions.push(chainedInstruction(Identifiers.syntheticHostListener, syntheticListeners).toStmt());
     }
-    if (listeners.length > 0) {
-        instructions.push(chainedInstruction(Identifiers.listener, listeners).toStmt());
+    for (const params of syntheticListenerParams) {
+        instructions.push({ reference: Identifiers.syntheticHostListener, paramsOrFn: params, span: null });
+    }
+    for (const params of listenerParams) {
+        instructions.push({ reference: Identifiers.listener, paramsOrFn: params, span: null });
     }
     return instructions;
 }
@@ -19148,6 +19302,7 @@ class CompilerFacadeImpl {
             deps: null,
             pipeName: facade.pipeName,
             pure: facade.pure,
+            isStandalone: facade.isStandalone,
         };
         const res = compilePipeFromMetadata(metadata);
         return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, []);
@@ -19216,7 +19371,7 @@ class CompilerFacadeImpl {
             declarations: facade.declarations.map(wrapReference),
             imports: facade.imports.map(wrapReference),
             exports: facade.exports.map(wrapReference),
-            emitInline: true,
+            selectorScopeMode: R3SelectorScopeMode.Inline,
             containsForwardDecls: false,
             schemas: facade.schemas ? facade.schemas.map(wrapReference) : null,
             id: facade.id ? new WrappedNodeExpr(facade.id) : null,
@@ -19358,7 +19513,7 @@ function convertDirectiveFacadeToMetadata(facade) {
     return Object.assign(Object.assign({}, facade), { typeArgumentCount: 0, typeSourceSpan: facade.typeSourceSpan, type: wrapReference(facade.type), internalType: new WrappedNodeExpr(facade.type), deps: null, host: extractHostBindings(facade.propMetadata, facade.typeSourceSpan, facade.host), inputs: Object.assign(Object.assign({}, inputsFromMetadata), inputsFromType), outputs: Object.assign(Object.assign({}, outputsFromMetadata), outputsFromType), queries: facade.queries.map(convertToR3QueryMetadata), providers: facade.providers != null ? new WrappedNodeExpr(facade.providers) : null, viewQueries: facade.viewQueries.map(convertToR3QueryMetadata), fullInheritance: false });
 }
 function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     return {
         name: declaration.type.name,
         type: wrapReference(declaration.type),
@@ -19378,6 +19533,7 @@ function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
         deps: null,
         typeArgumentCount: 0,
         fullInheritance: false,
+        isStandalone: (_j = declaration.isStandalone) !== null && _j !== void 0 ? _j : false,
     };
 }
 function convertHostDeclarationToMetadata(host = {}) {
@@ -19541,7 +19697,7 @@ function parseInputOutputs(values) {
     }, {});
 }
 function convertDeclarePipeFacadeToMetadata(declaration) {
-    var _a;
+    var _a, _b;
     return {
         name: declaration.type.name,
         type: wrapReference(declaration.type),
@@ -19550,6 +19706,7 @@ function convertDeclarePipeFacadeToMetadata(declaration) {
         pipeName: declaration.name,
         deps: null,
         pure: (_a = declaration.pure) !== null && _a !== void 0 ? _a : true,
+        isStandalone: (_b = declaration.isStandalone) !== null && _b !== void 0 ? _b : false,
     };
 }
 function convertDeclareInjectorFacadeToMetadata(declaration) {
@@ -19576,7 +19733,7 @@ function publishFacade(global) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-const VERSION = new Version('14.0.0-next.1');
+const VERSION = new Version('14.0.0-next.12');
 
 /**
  * @license
@@ -21603,7 +21760,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$6 = '12.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-    definitionMap.set('version', literal('14.0.0-next.1'));
+    definitionMap.set('version', literal('14.0.0-next.12'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -21720,7 +21877,7 @@ function compileDeclareDirectiveFromMetadata(meta) {
 function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('14.0.0-next.1'));
+    definitionMap.set('version', literal('14.0.0-next.12'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.internalType);
     // e.g. `selector: 'some-dir'`
@@ -21941,7 +22098,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', literal('14.0.0-next.1'));
+    definitionMap.set('version', literal('14.0.0-next.12'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -21983,7 +22140,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('14.0.0-next.1'));
+    definitionMap.set('version', literal('14.0.0-next.12'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     // Only generate providedIn property if it has a non-null value
@@ -22041,7 +22198,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('14.0.0-next.1'));
+    definitionMap.set('version', literal('14.0.0-next.12'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     definitionMap.set('providers', meta.providers);
@@ -22078,7 +22235,7 @@ function compileDeclareNgModuleFromMetadata(meta) {
 function createNgModuleDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('14.0.0-next.1'));
+    definitionMap.set('version', literal('14.0.0-next.12'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -22136,7 +22293,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('14.0.0-next.1'));
+    definitionMap.set('version', literal('14.0.0-next.12'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.internalType);
@@ -22186,5 +22343,5 @@ publishFacade(_global);
  * found in the LICENSE file at https://angular.io/license
  */
 
-export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, R3BoundTarget, Identifiers as R3Identifiers, R3TargetBinder, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, Element$1 as TmplAstElement, Icu$1 as TmplAstIcu, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, Variable as TmplAstVariable, Token, TokenType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
+export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, R3BoundTarget, Identifiers as R3Identifiers, R3SelectorScopeMode, R3TargetBinder, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, Element$1 as TmplAstElement, Icu$1 as TmplAstIcu, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, Variable as TmplAstVariable, Token, TokenType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
 //# sourceMappingURL=compiler.mjs.map