@angular-eslint/bundled-angular-compiler 14.0.0-alpha.3 → 14.0.0-alpha.4

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v13.3.1
+ * @license Angular v14.0.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -211,7 +211,7 @@ class CssSelector {
         let inNot = false;
         _SELECTOR_REGEXP.lastIndex = 0;
         while (match = _SELECTOR_REGEXP.exec(selector)) {
-            if (match[1 /* NOT */]) {
+            if (match[1 /* SelectorRegexp.NOT */]) {
                 if (inNot) {
                     throw new Error('Nesting :not in a selector is not allowed');
                 }
@@ -219,31 +219,31 @@ class CssSelector {
                 current = new CssSelector();
                 cssSelector.notSelectors.push(current);
             }
-            const tag = match[2 /* TAG */];
+            const tag = match[2 /* SelectorRegexp.TAG */];
             if (tag) {
-                const prefix = match[3 /* PREFIX */];
+                const prefix = match[3 /* SelectorRegexp.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
                     current.setElement(tag);
                 }
             }
-            const attribute = match[4 /* ATTRIBUTE */];
+            const attribute = match[4 /* SelectorRegexp.ATTRIBUTE */];
             if (attribute) {
-                current.addAttribute(current.unescapeAttribute(attribute), match[6 /* ATTRIBUTE_VALUE */]);
+                current.addAttribute(current.unescapeAttribute(attribute), match[6 /* SelectorRegexp.ATTRIBUTE_VALUE */]);
             }
-            if (match[7 /* NOT_END */]) {
+            if (match[7 /* SelectorRegexp.NOT_END */]) {
                 inNot = false;
                 current = cssSelector;
             }
-            if (match[8 /* SEPARATOR */]) {
+            if (match[8 /* SelectorRegexp.SEPARATOR */]) {
                 if (inNot) {
                     throw new Error('Multiple selectors in :not are not supported');
                 }
@@ -611,26 +611,26 @@ var MissingTranslationStrategy;
 })(MissingTranslationStrategy || (MissingTranslationStrategy = {}));
 function parserSelectorToSimpleSelector(selector) {
     const classes = selector.classNames && selector.classNames.length ?
-        [8 /* CLASS */, ...selector.classNames] :
+        [8 /* SelectorFlags.CLASS */, ...selector.classNames] :
         [];
     const elementName = selector.element && selector.element !== '*' ? selector.element : '';
     return [elementName, ...selector.attrs, ...classes];
 }
 function parserSelectorToNegativeSelector(selector) {
     const classes = selector.classNames && selector.classNames.length ?
-        [8 /* CLASS */, ...selector.classNames] :
+        [8 /* SelectorFlags.CLASS */, ...selector.classNames] :
         [];
     if (selector.element) {
         return [
-            1 /* NOT */ | 4 /* ELEMENT */, selector.element, ...selector.attrs, ...classes
+            1 /* SelectorFlags.NOT */ | 4 /* SelectorFlags.ELEMENT */, selector.element, ...selector.attrs, ...classes
         ];
     }
     else if (selector.attrs.length) {
-        return [1 /* NOT */ | 2 /* ATTRIBUTE */, ...selector.attrs, ...classes];
+        return [1 /* SelectorFlags.NOT */ | 2 /* SelectorFlags.ATTRIBUTE */, ...selector.attrs, ...classes];
     }
     else {
         return selector.classNames && selector.classNames.length ?
-            [1 /* NOT */ | 8 /* CLASS */, ...selector.classNames] :
+            [1 /* SelectorFlags.NOT */ | 8 /* SelectorFlags.CLASS */, ...selector.classNames] :
             [];
     }
 }
@@ -752,13 +752,13 @@ class Version {
         this.patch = splits.slice(2).join('.');
     }
 }
-const __window = typeof window !== 'undefined' && window;
-const __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&
-    self instanceof WorkerGlobalScope && self;
-const __global = typeof global !== 'undefined' && global;
-// Check __global first, because in Node tests both __global and __window may be defined and _global
-// should be __global in that case.
-const _global = __global || __window || __self;
+// Check `global` first, because in Node tests both `global` and `window` may be defined and our
+// `_global` variable should point to the NodeJS `global` in that case. Note: Typeof/Instanceof
+// checks are considered side-effects in Terser. We explicitly mark this as side-effect free:
+// https://github.com/terser/terser/issues/250.
+const _global = ( /* @__PURE__ */(() => (typeof global !== 'undefined' && global) || (typeof window !== 'undefined' && window) ||
+    (typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&
+        self instanceof WorkerGlobalScope && self))());
 function newArray(size, value) {
     const list = [];
     for (let i = 0; i < size; i++) {
@@ -2796,6 +2796,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 };
@@ -2906,6 +2907,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 };
@@ -2918,6 +2920,7 @@ Identifiers.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE };
 Identifiers.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE };
 Identifiers.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', moduleName: CORE };
 Identifiers.CopyDefinitionFeature = { name: 'ɵɵCopyDefinitionFeature', moduleName: CORE };
+Identifiers.StandaloneFeature = { name: 'ɵɵStandaloneFeature', moduleName: CORE };
 Identifiers.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE };
 Identifiers.listener = { name: 'ɵɵlistener', moduleName: CORE };
 Identifiers.getInheritedFactory = {
@@ -3659,10 +3662,10 @@ function createMayBeForwardRefExpression(expression, forwardRef) {
  */
 function convertFromMaybeForwardRefExpression({ expression, forwardRef }) {
     switch (forwardRef) {
-        case 0 /* None */:
-        case 1 /* Wrapped */:
+        case 0 /* ForwardRefHandling.None */:
+        case 1 /* ForwardRefHandling.Wrapped */:
             return expression;
-        case 2 /* Unwrapped */:
+        case 2 /* ForwardRefHandling.Unwrapped */:
             return generateForwardRef(expression);
     }
 }
@@ -3786,14 +3789,14 @@ function compileInjectDependency(dep, target, index) {
     }
     else if (dep.attributeNameType === null) {
         // Build up the injection flags according to the metadata.
-        const flags = 0 /* Default */ | (dep.self ? 2 /* Self */ : 0) |
-            (dep.skipSelf ? 4 /* SkipSelf */ : 0) | (dep.host ? 1 /* Host */ : 0) |
-            (dep.optional ? 8 /* Optional */ : 0) |
-            (target === exports.FactoryTarget.Pipe ? 16 /* ForPipe */ : 0);
+        const flags = 0 /* InjectFlags.Default */ | (dep.self ? 2 /* InjectFlags.Self */ : 0) |
+            (dep.skipSelf ? 4 /* InjectFlags.SkipSelf */ : 0) | (dep.host ? 1 /* InjectFlags.Host */ : 0) |
+            (dep.optional ? 8 /* InjectFlags.Optional */ : 0) |
+            (target === exports.FactoryTarget.Pipe ? 16 /* InjectFlags.ForPipe */ : 0);
         // If this dependency is optional or otherwise has non-default flags, then additional
         // parameters describing how to inject the dependency must be passed to the inject function
         // that's being used.
-        let flagsParam = (flags !== 0 /* Default */ || dep.optional) ? literal(flags) : null;
+        let flagsParam = (flags !== 0 /* InjectFlags.Default */ || dep.optional) ? literal(flags) : null;
         // Build up the arguments to the injectFn call.
         const injectArgs = [dep.token];
         if (flagsParam) {
@@ -3964,8 +3967,8 @@ class BoundEvent {
         this.keySpan = keySpan;
     }
     static fromParsedEvent(event) {
-        const target = event.type === 0 /* Regular */ ? event.targetOrPhase : null;
-        const phase = event.type === 1 /* Animation */ ? event.targetOrPhase : null;
+        const target = event.type === 0 /* ParsedEventType.Regular */ ? event.targetOrPhase : null;
+        const phase = event.type === 1 /* ParsedEventType.Animation */ ? event.targetOrPhase : null;
         if (event.keySpan === undefined) {
             throw new Error(`Unexpected state: keySpan must be defined for bound event but was not for ${event.name}: ${event.sourceSpan}`);
         }
@@ -4706,7 +4709,7 @@ function assembleBoundTextPlaceholders(meta, bindingStartIndex = 0, contextId =
  * @param useCamelCase whether to camelCase the placeholder name when formatting.
  * @returns A new map of formatted placeholder names to expressions.
  */
-function i18nFormatPlaceholderNames(params = {}, useCamelCase) {
+function formatI18nPlaceholderNamesInMap(params = {}, useCamelCase) {
     const _params = {};
     if (params && Object.keys(params).length) {
         Object.keys(params).forEach(key => _params[formatI18nPlaceholderName(key, useCamelCase)] = params[key]);
@@ -4789,6 +4792,12 @@ 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';
+/**
+ * Maximum length of a single instruction chain. Because our output AST uses recursion, we're
+ * limited in how many expressions we can nest before we reach the call stack limit. This
+ * length is set very conservatively in order to reduce the chance of problems.
+ */
+const MAX_CHAIN_LENGTH = 500;
 /** Instructions that support chaining. */
 const CHAINABLE_INSTRUCTIONS = new Set([
     Identifiers.element,
@@ -4934,10 +4943,10 @@ function getQueryPredicate(query, constantPool) {
     else {
         // The original predicate may have been wrapped in a `forwardRef()` call.
         switch (query.predicate.forwardRef) {
-            case 0 /* None */:
-            case 2 /* Unwrapped */:
+            case 0 /* ForwardRefHandling.None */:
+            case 2 /* ForwardRefHandling.Unwrapped */:
                 return query.predicate.expression;
-            case 1 /* Wrapped */:
+            case 1 /* ForwardRefHandling.Wrapped */:
                 return importExpr(Identifiers.resolveForwardRef).callFn([query.predicate.expression]);
         }
     }
@@ -5015,15 +5024,17 @@ function getInstructionStatements(instructions) {
     const statements = [];
     let pendingExpression = null;
     let pendingExpressionType = null;
+    let chainLength = 0;
     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 &&
+        if (chainLength < MAX_CHAIN_LENGTH && 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);
+            chainLength++;
         }
         else {
             if (pendingExpression !== null) {
@@ -5031,6 +5042,7 @@ function getInstructionStatements(instructions) {
             }
             pendingExpression = invokeInstruction(current.span, current.reference, params);
             pendingExpressionType = current.reference;
+            chainLength = 0;
         }
     }
     // Since the current instruction adds the previous one to the statements,
@@ -5326,7 +5338,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 {
@@ -5881,43 +5893,78 @@ 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.
+ */
+exports.R3SelectorScopeMode = void 0;
+(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";
+})(exports.R3SelectorScopeMode || (exports.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: exports$1, 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 === exports.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));
         }
         if (imports.length > 0) {
             definitionMap.set('imports', refsToArray(imports, containsForwardDecls));
         }
-        if (exports.length > 0) {
-            definitionMap.set('exports', refsToArray(exports, containsForwardDecls));
+        if (exports$1.length > 0) {
+            definitionMap.set('exports', refsToArray(exports$1, 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 === exports.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 ;
     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);
@@ -6013,6 +6060,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: [] };
@@ -6021,9 +6071,24 @@ function createPipeType(metadata) {
     return new ExpressionType(importExpr(Identifiers.PipeDeclaration, [
         typeWithParameters(metadata.type.type, metadata.typeArgumentCount),
         new ExpressionType(new LiteralExpr(metadata.pipeName)),
+        new ExpressionType(new LiteralExpr(metadata.isStandalone)),
     ]));
 }
 
+/**
+ * @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.io/license
+ */
+exports.R3TemplateDependencyKind = void 0;
+(function (R3TemplateDependencyKind) {
+    R3TemplateDependencyKind[R3TemplateDependencyKind["Directive"] = 0] = "Directive";
+    R3TemplateDependencyKind[R3TemplateDependencyKind["Pipe"] = 1] = "Pipe";
+    R3TemplateDependencyKind[R3TemplateDependencyKind["NgModule"] = 2] = "NgModule";
+})(exports.R3TemplateDependencyKind || (exports.R3TemplateDependencyKind = {}));
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -6067,33 +6132,6 @@ class ASTWithName extends AST {
         this.nameSpan = nameSpan;
     }
 }
-/**
- * Represents a quoted expression of the form:
- *
- * quote = prefix `:` uninterpretedExpression
- * prefix = identifier
- * uninterpretedExpression = arbitrary string
- *
- * A quoted expression is meant to be pre-processed by an AST transformer that
- * converts it into another AST that no longer contains quoted expressions.
- * It is meant to allow third-party developers to extend Angular template
- * expression language. The `uninterpretedExpression` part of the quote is
- * therefore not interpreted by the Angular's own expression parser.
- */
-class Quote extends AST {
-    constructor(span, sourceSpan, prefix, uninterpretedExpression, location) {
-        super(span, sourceSpan);
-        this.prefix = prefix;
-        this.uninterpretedExpression = uninterpretedExpression;
-        this.location = location;
-    }
-    visit(visitor, context = null) {
-        return visitor.visitQuote(this, context);
-    }
-    toString() {
-        return 'Quote';
-    }
-}
 class EmptyExpr extends AST {
     visit(visitor, context = null) {
         // do nothing
@@ -6474,7 +6512,6 @@ class RecursiveAstVisitor {
         this.visit(ast.receiver, context);
         this.visitAll(ast.args, context);
     }
-    visitQuote(ast, context) { }
     // This is not part of the AstVisitor interface, just a helper method
     visitAll(asts, context) {
         for (const ast of asts) {
@@ -6557,9 +6594,6 @@ class AstTransformer {
     visitChain(ast, context) {
         return new Chain(ast.span, ast.sourceSpan, this.visitAll(ast.expressions));
     }
-    visitQuote(ast, context) {
-        return new Quote(ast.span, ast.sourceSpan, ast.prefix, ast.uninterpretedExpression, ast.location);
-    }
     visitSafeKeyedRead(ast, context) {
         return new SafeKeyedRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this));
     }
@@ -6722,9 +6756,6 @@ class AstMemoryEfficientTransformer {
         }
         return ast;
     }
-    visitQuote(ast, context) {
-        return ast;
-    }
     visitSafeKeyedRead(ast, context) {
         const obj = ast.receiver.visit(this);
         const key = ast.key.visit(this);
@@ -7198,10 +7229,6 @@ class _AstToIrVisitor {
     visitAll(asts, mode) {
         return asts.map(ast => this._visit(ast, mode));
     }
-    visitQuote(ast, mode) {
-        throw new Error(`Quotes are not supported for evaluation!
-        Statement: ${ast.uninterpretedExpression} located at ${ast.location}`);
-    }
     visitCall(ast, mode) {
         const leftMostSafe = this.leftMostSafeNode(ast);
         if (leftMostSafe) {
@@ -7387,9 +7414,6 @@ class _AstToIrVisitor {
             visitPropertyWrite(ast) {
                 return null;
             },
-            visitQuote(ast) {
-                return null;
-            },
             visitSafePropertyRead(ast) {
                 return visit(this, ast.receiver) || ast;
             },
@@ -7466,9 +7490,6 @@ class _AstToIrVisitor {
             visitPropertyWrite(ast) {
                 return false;
             },
-            visitQuote(ast) {
-                return false;
-            },
             visitSafePropertyRead(ast) {
                 return false;
             },
@@ -8320,7 +8341,7 @@ function parse(value) {
     const styles = [];
     let i = 0;
     let parenDepth = 0;
-    let quote = 0 /* QuoteNone */;
+    let quote = 0 /* Char.QuoteNone */;
     let valueStart = 0;
     let propStart = 0;
     let currentProp = null;
@@ -8328,41 +8349,41 @@ function parse(value) {
     while (i < value.length) {
         const token = value.charCodeAt(i++);
         switch (token) {
-            case 40 /* OpenParen */:
+            case 40 /* Char.OpenParen */:
                 parenDepth++;
                 break;
-            case 41 /* CloseParen */:
+            case 41 /* Char.CloseParen */:
                 parenDepth--;
                 break;
-            case 39 /* QuoteSingle */:
+            case 39 /* Char.QuoteSingle */:
                 // valueStart needs to be there since prop values don't
                 // have quotes in CSS
                 valueHasQuotes = valueHasQuotes || valueStart > 0;
-                if (quote === 0 /* QuoteNone */) {
-                    quote = 39 /* QuoteSingle */;
+                if (quote === 0 /* Char.QuoteNone */) {
+                    quote = 39 /* Char.QuoteSingle */;
                 }
-                else if (quote === 39 /* QuoteSingle */ && value.charCodeAt(i - 1) !== 92 /* BackSlash */) {
-                    quote = 0 /* QuoteNone */;
+                else if (quote === 39 /* Char.QuoteSingle */ && value.charCodeAt(i - 1) !== 92 /* Char.BackSlash */) {
+                    quote = 0 /* Char.QuoteNone */;
                 }
                 break;
-            case 34 /* QuoteDouble */:
+            case 34 /* Char.QuoteDouble */:
                 // same logic as above
                 valueHasQuotes = valueHasQuotes || valueStart > 0;
-                if (quote === 0 /* QuoteNone */) {
-                    quote = 34 /* QuoteDouble */;
+                if (quote === 0 /* Char.QuoteNone */) {
+                    quote = 34 /* Char.QuoteDouble */;
                 }
-                else if (quote === 34 /* QuoteDouble */ && value.charCodeAt(i - 1) !== 92 /* BackSlash */) {
-                    quote = 0 /* QuoteNone */;
+                else if (quote === 34 /* Char.QuoteDouble */ && value.charCodeAt(i - 1) !== 92 /* Char.BackSlash */) {
+                    quote = 0 /* Char.QuoteNone */;
                 }
                 break;
-            case 58 /* Colon */:
-                if (!currentProp && parenDepth === 0 && quote === 0 /* QuoteNone */) {
+            case 58 /* Char.Colon */:
+                if (!currentProp && parenDepth === 0 && quote === 0 /* Char.QuoteNone */) {
                     currentProp = hyphenate(value.substring(propStart, i - 1).trim());
                     valueStart = i;
                 }
                 break;
-            case 59 /* Semicolon */:
-                if (currentProp && valueStart > 0 && parenDepth === 0 && quote === 0 /* QuoteNone */) {
+            case 59 /* Char.Semicolon */:
+                if (currentProp && valueStart > 0 && parenDepth === 0 && quote === 0 /* Char.QuoteNone */) {
                     const styleVal = value.substring(valueStart, i - 1).trim();
                     styles.push(currentProp, valueHasQuotes ? stripUnnecessaryQuotes(styleVal) : styleVal);
                     propStart = i;
@@ -8374,7 +8395,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;
@@ -8382,7 +8403,7 @@ function parse(value) {
 function stripUnnecessaryQuotes(value) {
     const qS = value.charCodeAt(0);
     const qE = value.charCodeAt(value.length - 1);
-    if (qS == qE && (qS == 39 /* QuoteSingle */ || qS == 34 /* QuoteDouble */)) {
+    if (qS == qE && (qS == 39 /* Char.QuoteSingle */ || qS == 34 /* Char.QuoteDouble */)) {
         const tempValue = value.substring(1, value.length - 1);
         // special case to avoid using a multi-quoted string that was just chomped
         // (e.g. `font-family: "Verdana", "sans-serif"`)
@@ -8533,13 +8554,13 @@ class StylingBuilder {
         let binding = null;
         let name = input.name;
         switch (input.type) {
-            case 0 /* Property */:
+            case 0 /* BindingType.Property */:
                 binding = this.registerInputBasedOnName(name, input.value, input.sourceSpan);
                 break;
-            case 3 /* Style */:
+            case 3 /* BindingType.Style */:
                 binding = this.registerStyleInput(name, false, input.value, input.sourceSpan, input.unit);
                 break;
-            case 2 /* Class */:
+            case 2 /* BindingType.Class */:
                 binding = this.registerClassInput(name, false, input.value, input.sourceSpan);
                 break;
         }
@@ -8552,7 +8573,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);
             }
@@ -8638,14 +8659,14 @@ class StylingBuilder {
     populateInitialStylingAttrs(attrs) {
         // [CLASS_MARKER, 'foo', 'bar', 'baz' ...]
         if (this._initialClassValues.length) {
-            attrs.push(literal(1 /* Classes */));
+            attrs.push(literal(1 /* AttributeMarker.Classes */));
             for (let i = 0; i < this._initialClassValues.length; i++) {
                 attrs.push(literal(this._initialClassValues[i]));
             }
         }
         // [STYLE_MARKER, 'width', '200px', 'height', '100px', ...]
         if (this._initialStyleValues.length) {
-            attrs.push(literal(2 /* Styles */));
+            attrs.push(literal(2 /* AttributeMarker.Styles */));
             for (let i = 0; i < this._initialStyleValues.length; i += 2) {
                 attrs.push(literal(this._initialStyleValues[i]), literal(this._initialStyleValues[i + 1]));
             }
@@ -8826,7 +8847,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 };
@@ -9375,9 +9396,9 @@ class Parser$1 {
         this._checkNoInterpolation(input, location, interpolationConfig);
         const sourceToLex = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
-        let flags = 1 /* Action */;
+        let flags = 1 /* ParseFlags.Action */;
         if (isAssignmentEvent) {
-            flags |= 2 /* AssignmentEvent */;
+            flags |= 2 /* ParseFlags.AssignmentEvent */;
         }
         const ast = new _ParseAST(input, location, absoluteOffset, tokens, flags, this.errors, 0).parseChain();
         return new ASTWithSource(ast, input, location, absoluteOffset, this.errors);
@@ -9403,31 +9424,12 @@ class Parser$1 {
         this.errors.push(new ParserError(message, input, errLocation, ctxLocation));
     }
     _parseBindingAst(input, location, absoluteOffset, interpolationConfig) {
-        // Quotes expressions use 3rd-party expression language. We don't want to use
-        // our lexer or parser for that, so we check for that ahead of time.
-        const quote = this._parseQuote(input, location, absoluteOffset);
-        if (quote != null) {
-            return quote;
-        }
         this._checkNoInterpolation(input, location, interpolationConfig);
         const sourceToLex = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
-        return new _ParseAST(input, location, absoluteOffset, tokens, 0 /* None */, this.errors, 0)
+        return new _ParseAST(input, location, absoluteOffset, tokens, 0 /* ParseFlags.None */, this.errors, 0)
             .parseChain();
     }
-    _parseQuote(input, location, absoluteOffset) {
-        if (input == null)
-            return null;
-        const prefixSeparatorIndex = input.indexOf(':');
-        if (prefixSeparatorIndex == -1)
-            return null;
-        const prefix = input.substring(0, prefixSeparatorIndex).trim();
-        if (!isIdentifier(prefix))
-            return null;
-        const uninterpretedExpression = input.substring(prefixSeparatorIndex + 1);
-        const span = new ParseSpan(0, input.length);
-        return new Quote(span, span.toAbsolute(absoluteOffset), prefix, uninterpretedExpression, location);
-    }
     /**
      * Parse microsyntax template expression and return a list of bindings or
      * parsing errors in case the given expression is invalid.
@@ -9456,7 +9458,7 @@ class Parser$1 {
      */
     parseTemplateBindings(templateKey, templateValue, templateUrl, absoluteKeyOffset, absoluteValueOffset) {
         const tokens = this._lexer.tokenize(templateValue);
-        const parser = new _ParseAST(templateValue, templateUrl, absoluteValueOffset, tokens, 0 /* None */, this.errors, 0 /* relative offset */);
+        const parser = new _ParseAST(templateValue, templateUrl, absoluteValueOffset, tokens, 0 /* ParseFlags.None */, this.errors, 0 /* relative offset */);
         return parser.parseTemplateBindings({
             source: templateKey,
             span: new AbsoluteSourceSpan(absoluteKeyOffset, absoluteKeyOffset + templateKey.length),
@@ -9471,7 +9473,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, 0 /* None */, this.errors, offsets[i])
+            const ast = new _ParseAST(input, location, absoluteOffset, tokens, 0 /* ParseFlags.None */, this.errors, offsets[i])
                 .parseChain();
             expressionNodes.push(ast);
         }
@@ -9485,7 +9487,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, 0 /* None */, this.errors, 0)
+        const ast = new _ParseAST(expression, location, absoluteOffset, tokens, 0 /* ParseFlags.None */, this.errors, 0)
             .parseChain();
         const strings = ['', '']; // The prefix and suffix strings are both empty
         return this.createInterpolationAst(strings, [ast], expression, location, absoluteOffset);
@@ -9842,7 +9844,7 @@ class _ParseAST {
             const expr = this.parsePipe();
             exprs.push(expr);
             if (this.consumeOptionalCharacter($SEMICOLON)) {
-                if (!(this.parseFlags & 1 /* Action */)) {
+                if (!(this.parseFlags & 1 /* ParseFlags.Action */)) {
                     this.error('Binding expression cannot contain chained expression');
                 }
                 while (this.consumeOptionalCharacter($SEMICOLON)) {
@@ -9866,7 +9868,7 @@ class _ParseAST {
         const start = this.inputIndex;
         let result = this.parseExpression();
         if (this.consumeOptionalOperator('|')) {
-            if (this.parseFlags & 1 /* Action */) {
+            if (this.parseFlags & 1 /* ParseFlags.Action */) {
                 this.error('Cannot have a pipe in an action expression');
             }
             do {
@@ -10219,7 +10221,7 @@ class _ParseAST {
         }
         else {
             if (this.consumeOptionalAssignment()) {
-                if (!(this.parseFlags & 1 /* Action */)) {
+                if (!(this.parseFlags & 1 /* ParseFlags.Action */)) {
                     this.error('Bindings cannot contain assignments');
                     return new EmptyExpr(this.span(start), this.sourceSpan(start));
                 }
@@ -10251,7 +10253,7 @@ class _ParseAST {
         // 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('!') &&
+        if ((this.parseFlags & 2 /* ParseFlags.AssignmentEvent */) && this.next.isOperator('!') &&
             this.peek(1).isOperator('=')) {
             // First skip over the ! operator.
             this.advance();
@@ -10573,7 +10575,7 @@ function getIndexMapForOriginalTemplate(interpolatedTokens) {
     let tokenIndex = 0;
     while (tokenIndex < interpolatedTokens.length) {
         const currentToken = interpolatedTokens[tokenIndex];
-        if (currentToken.type === 9 /* ENCODED_ENTITY */) {
+        if (currentToken.type === 9 /* MlParserTokenType.ENCODED_ENTITY */) {
             const [decoded, encoded] = currentToken.parts;
             consumedInOriginalTemplate += encoded.length;
             consumedInInput += decoded.length;
@@ -12971,14 +12973,14 @@ class _Tokenizer {
                 else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {
                     // In (possibly interpolated) text the end of the text is given by `isTextEnd()`, while
                     // the premature end of an interpolation is given by the start of a new HTML element.
-                    this._consumeWithInterpolation(5 /* TEXT */, 8 /* INTERPOLATION */, () => this._isTextEnd(), () => this._isTagStart());
+                    this._consumeWithInterpolation(5 /* TokenType.TEXT */, 8 /* TokenType.INTERPOLATION */, () => this._isTextEnd(), () => this._isTagStart());
                 }
             }
             catch (e) {
                 this.handleError(e);
             }
         }
-        this._beginToken(24 /* EOF */);
+        this._beginToken(24 /* TokenType.EOF */);
         this._endToken([]);
     }
     /**
@@ -13122,7 +13124,7 @@ class _Tokenizer {
         return char;
     }
     _consumeEntity(textTokenType) {
-        this._beginToken(9 /* ENCODED_ENTITY */);
+        this._beginToken(9 /* TokenType.ENCODED_ENTITY */);
         const start = this._cursor.clone();
         this._cursor.advance();
         if (this._attemptCharCode($HASH)) {
@@ -13168,7 +13170,7 @@ class _Tokenizer {
         }
     }
     _consumeRawText(consumeEntities, endMarkerPredicate) {
-        this._beginToken(consumeEntities ? 6 /* ESCAPABLE_RAW_TEXT */ : 7 /* RAW_TEXT */);
+        this._beginToken(consumeEntities ? 6 /* TokenType.ESCAPABLE_RAW_TEXT */ : 7 /* TokenType.RAW_TEXT */);
         const parts = [];
         while (true) {
             const tagCloseStart = this._cursor.clone();
@@ -13180,8 +13182,8 @@ class _Tokenizer {
             if (consumeEntities && this._cursor.peek() === $AMPERSAND) {
                 this._endToken([this._processCarriageReturns(parts.join(''))]);
                 parts.length = 0;
-                this._consumeEntity(6 /* ESCAPABLE_RAW_TEXT */);
-                this._beginToken(6 /* ESCAPABLE_RAW_TEXT */);
+                this._consumeEntity(6 /* TokenType.ESCAPABLE_RAW_TEXT */);
+                this._beginToken(6 /* TokenType.ESCAPABLE_RAW_TEXT */);
             }
             else {
                 parts.push(this._readChar());
@@ -13190,25 +13192,25 @@ class _Tokenizer {
         this._endToken([this._processCarriageReturns(parts.join(''))]);
     }
     _consumeComment(start) {
-        this._beginToken(10 /* COMMENT_START */, start);
+        this._beginToken(10 /* TokenType.COMMENT_START */, start);
         this._requireCharCode($MINUS);
         this._endToken([]);
         this._consumeRawText(false, () => this._attemptStr('-->'));
-        this._beginToken(11 /* COMMENT_END */);
+        this._beginToken(11 /* TokenType.COMMENT_END */);
         this._requireStr('-->');
         this._endToken([]);
     }
     _consumeCdata(start) {
-        this._beginToken(12 /* CDATA_START */, start);
+        this._beginToken(12 /* TokenType.CDATA_START */, start);
         this._requireStr('CDATA[');
         this._endToken([]);
         this._consumeRawText(false, () => this._attemptStr(']]>'));
-        this._beginToken(13 /* CDATA_END */);
+        this._beginToken(13 /* TokenType.CDATA_END */);
         this._requireStr(']]>');
         this._endToken([]);
     }
     _consumeDocType(start) {
-        this._beginToken(18 /* DOC_TYPE */, start);
+        this._beginToken(18 /* TokenType.DOC_TYPE */, start);
         const contentStart = this._cursor.clone();
         this._attemptUntilChar($GT);
         const content = this._cursor.getChars(contentStart);
@@ -13262,12 +13264,12 @@ class _Tokenizer {
             if (e instanceof _ControlFlowError) {
                 if (openTagToken) {
                     // We errored before we could close the opening tag, so it is incomplete.
-                    openTagToken.type = 4 /* INCOMPLETE_TAG_OPEN */;
+                    openTagToken.type = 4 /* TokenType.INCOMPLETE_TAG_OPEN */;
                 }
                 else {
                     // When the start tag is invalid, assume we want a "<" as text.
                     // Back to back text tokens are merged at the end.
-                    this._beginToken(5 /* TEXT */, start);
+                    this._beginToken(5 /* TokenType.TEXT */, start);
                     this._endToken(['<']);
                 }
                 return;
@@ -13294,13 +13296,13 @@ class _Tokenizer {
             this._attemptCharCodeUntilFn(isNotWhitespace);
             return this._attemptCharCode($GT);
         });
-        this._beginToken(3 /* TAG_CLOSE */);
+        this._beginToken(3 /* TokenType.TAG_CLOSE */);
         this._requireCharCodeUntilFn(code => code === $GT, 3);
         this._cursor.advance(); // Consume the `>`
         this._endToken([prefix, tagName]);
     }
     _consumeTagOpenStart(start) {
-        this._beginToken(0 /* TAG_OPEN_START */, start);
+        this._beginToken(0 /* TokenType.TAG_OPEN_START */, start);
         const parts = this._consumePrefixAndName();
         return this._endToken(parts);
     }
@@ -13309,7 +13311,7 @@ class _Tokenizer {
         if (attrNameStart === $SQ || attrNameStart === $DQ) {
             throw this._createError(_unexpectedCharacterErrorMsg(attrNameStart), this._cursor.getSpan());
         }
-        this._beginToken(14 /* ATTR_NAME */);
+        this._beginToken(14 /* TokenType.ATTR_NAME */);
         const prefixAndName = this._consumePrefixAndName();
         this._endToken(prefixAndName);
     }
@@ -13320,27 +13322,27 @@ class _Tokenizer {
             // In an attribute then end of the attribute value and the premature end to an interpolation
             // are both triggered by the `quoteChar`.
             const endPredicate = () => this._cursor.peek() === quoteChar;
-            this._consumeWithInterpolation(16 /* ATTR_VALUE_TEXT */, 17 /* ATTR_VALUE_INTERPOLATION */, endPredicate, endPredicate);
+            this._consumeWithInterpolation(16 /* TokenType.ATTR_VALUE_TEXT */, 17 /* TokenType.ATTR_VALUE_INTERPOLATION */, endPredicate, endPredicate);
             this._consumeQuote(quoteChar);
         }
         else {
             const endPredicate = () => isNameEnd(this._cursor.peek());
-            this._consumeWithInterpolation(16 /* ATTR_VALUE_TEXT */, 17 /* ATTR_VALUE_INTERPOLATION */, endPredicate, endPredicate);
+            this._consumeWithInterpolation(16 /* TokenType.ATTR_VALUE_TEXT */, 17 /* TokenType.ATTR_VALUE_INTERPOLATION */, endPredicate, endPredicate);
         }
     }
     _consumeQuote(quoteChar) {
-        this._beginToken(15 /* ATTR_QUOTE */);
+        this._beginToken(15 /* TokenType.ATTR_QUOTE */);
         this._requireCharCode(quoteChar);
         this._endToken([String.fromCodePoint(quoteChar)]);
     }
     _consumeTagOpenEnd() {
-        const tokenType = this._attemptCharCode($SLASH) ? 2 /* TAG_OPEN_END_VOID */ : 1 /* TAG_OPEN_END */;
+        const tokenType = this._attemptCharCode($SLASH) ? 2 /* TokenType.TAG_OPEN_END_VOID */ : 1 /* TokenType.TAG_OPEN_END */;
         this._beginToken(tokenType);
         this._requireCharCode($GT);
         this._endToken([]);
     }
     _consumeTagClose(start) {
-        this._beginToken(3 /* TAG_CLOSE */, start);
+        this._beginToken(3 /* TokenType.TAG_CLOSE */, start);
         this._attemptCharCodeUntilFn(isNotWhitespace);
         const prefixAndName = this._consumePrefixAndName();
         this._attemptCharCodeUntilFn(isNotWhitespace);
@@ -13348,11 +13350,11 @@ class _Tokenizer {
         this._endToken(prefixAndName);
     }
     _consumeExpansionFormStart() {
-        this._beginToken(19 /* EXPANSION_FORM_START */);
+        this._beginToken(19 /* TokenType.EXPANSION_FORM_START */);
         this._requireCharCode($LBRACE);
         this._endToken([]);
-        this._expansionCaseStack.push(19 /* EXPANSION_FORM_START */);
-        this._beginToken(7 /* RAW_TEXT */);
+        this._expansionCaseStack.push(19 /* TokenType.EXPANSION_FORM_START */);
+        this._beginToken(7 /* TokenType.RAW_TEXT */);
         const condition = this._readUntil($COMMA);
         const normalizedCondition = this._processCarriageReturns(condition);
         if (this._i18nNormalizeLineEndingsInICUs) {
@@ -13368,32 +13370,32 @@ class _Tokenizer {
         }
         this._requireCharCode($COMMA);
         this._attemptCharCodeUntilFn(isNotWhitespace);
-        this._beginToken(7 /* RAW_TEXT */);
+        this._beginToken(7 /* TokenType.RAW_TEXT */);
         const type = this._readUntil($COMMA);
         this._endToken([type]);
         this._requireCharCode($COMMA);
         this._attemptCharCodeUntilFn(isNotWhitespace);
     }
     _consumeExpansionCaseStart() {
-        this._beginToken(20 /* EXPANSION_CASE_VALUE */);
+        this._beginToken(20 /* TokenType.EXPANSION_CASE_VALUE */);
         const value = this._readUntil($LBRACE).trim();
         this._endToken([value]);
         this._attemptCharCodeUntilFn(isNotWhitespace);
-        this._beginToken(21 /* EXPANSION_CASE_EXP_START */);
+        this._beginToken(21 /* TokenType.EXPANSION_CASE_EXP_START */);
         this._requireCharCode($LBRACE);
         this._endToken([]);
         this._attemptCharCodeUntilFn(isNotWhitespace);
-        this._expansionCaseStack.push(21 /* EXPANSION_CASE_EXP_START */);
+        this._expansionCaseStack.push(21 /* TokenType.EXPANSION_CASE_EXP_START */);
     }
     _consumeExpansionCaseEnd() {
-        this._beginToken(22 /* EXPANSION_CASE_EXP_END */);
+        this._beginToken(22 /* TokenType.EXPANSION_CASE_EXP_END */);
         this._requireCharCode($RBRACE);
         this._endToken([]);
         this._attemptCharCodeUntilFn(isNotWhitespace);
         this._expansionCaseStack.pop();
     }
     _consumeExpansionFormEnd() {
-        this._beginToken(23 /* EXPANSION_FORM_END */);
+        this._beginToken(23 /* TokenType.EXPANSION_FORM_END */);
         this._requireCharCode($RBRACE);
         this._endToken([]);
         this._expansionCaseStack.pop();
@@ -13543,12 +13545,12 @@ class _Tokenizer {
     _isInExpansionCase() {
         return this._expansionCaseStack.length > 0 &&
             this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
-                21 /* EXPANSION_CASE_EXP_START */;
+                21 /* TokenType.EXPANSION_CASE_EXP_START */;
     }
     _isInExpansionForm() {
         return this._expansionCaseStack.length > 0 &&
             this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
-                19 /* EXPANSION_FORM_START */;
+                19 /* TokenType.EXPANSION_FORM_START */;
     }
     isExpansionFormStart() {
         if (this._cursor.peek() !== $LBRACE) {
@@ -13595,9 +13597,9 @@ function mergeTextTokens(srcTokens) {
     let lastDstToken = undefined;
     for (let i = 0; i < srcTokens.length; i++) {
         const token = srcTokens[i];
-        if ((lastDstToken && lastDstToken.type === 5 /* TEXT */ && token.type === 5 /* TEXT */) ||
-            (lastDstToken && lastDstToken.type === 16 /* ATTR_VALUE_TEXT */ &&
-                token.type === 16 /* ATTR_VALUE_TEXT */)) {
+        if ((lastDstToken && lastDstToken.type === 5 /* TokenType.TEXT */ && token.type === 5 /* TokenType.TEXT */) ||
+            (lastDstToken && lastDstToken.type === 16 /* TokenType.ATTR_VALUE_TEXT */ &&
+                token.type === 16 /* TokenType.ATTR_VALUE_TEXT */)) {
             lastDstToken.parts[0] += token.parts[0];
             lastDstToken.sourceSpan.end = token.sourceSpan.end;
         }
@@ -13828,7 +13830,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;
@@ -13890,28 +13892,28 @@ class _TreeBuilder {
         this._advance();
     }
     build() {
-        while (this._peek.type !== 24 /* EOF */) {
-            if (this._peek.type === 0 /* TAG_OPEN_START */ ||
-                this._peek.type === 4 /* INCOMPLETE_TAG_OPEN */) {
+        while (this._peek.type !== 24 /* TokenType.EOF */) {
+            if (this._peek.type === 0 /* TokenType.TAG_OPEN_START */ ||
+                this._peek.type === 4 /* TokenType.INCOMPLETE_TAG_OPEN */) {
                 this._consumeStartTag(this._advance());
             }
-            else if (this._peek.type === 3 /* TAG_CLOSE */) {
+            else if (this._peek.type === 3 /* TokenType.TAG_CLOSE */) {
                 this._consumeEndTag(this._advance());
             }
-            else if (this._peek.type === 12 /* CDATA_START */) {
+            else if (this._peek.type === 12 /* TokenType.CDATA_START */) {
                 this._closeVoidElement();
                 this._consumeCdata(this._advance());
             }
-            else if (this._peek.type === 10 /* COMMENT_START */) {
+            else if (this._peek.type === 10 /* TokenType.COMMENT_START */) {
                 this._closeVoidElement();
                 this._consumeComment(this._advance());
             }
-            else if (this._peek.type === 5 /* TEXT */ || this._peek.type === 7 /* RAW_TEXT */ ||
-                this._peek.type === 6 /* ESCAPABLE_RAW_TEXT */) {
+            else if (this._peek.type === 5 /* TokenType.TEXT */ || this._peek.type === 7 /* TokenType.RAW_TEXT */ ||
+                this._peek.type === 6 /* TokenType.ESCAPABLE_RAW_TEXT */) {
                 this._closeVoidElement();
                 this._consumeText(this._advance());
             }
-            else if (this._peek.type === 19 /* EXPANSION_FORM_START */) {
+            else if (this._peek.type === 19 /* TokenType.EXPANSION_FORM_START */) {
                 this._consumeExpansion(this._advance());
             }
             else {
@@ -13937,11 +13939,11 @@ class _TreeBuilder {
     }
     _consumeCdata(_startToken) {
         this._consumeText(this._advance());
-        this._advanceIf(13 /* CDATA_END */);
+        this._advanceIf(13 /* TokenType.CDATA_END */);
     }
     _consumeComment(token) {
-        const text = this._advanceIf(7 /* RAW_TEXT */);
-        this._advanceIf(11 /* COMMENT_END */);
+        const text = this._advanceIf(7 /* TokenType.RAW_TEXT */);
+        this._advanceIf(11 /* TokenType.COMMENT_END */);
         const value = text != null ? text.parts[0].trim() : null;
         this._addToParent(new Comment(value, token.sourceSpan));
     }
@@ -13950,14 +13952,14 @@ class _TreeBuilder {
         const type = this._advance();
         const cases = [];
         // read =
-        while (this._peek.type === 20 /* EXPANSION_CASE_VALUE */) {
+        while (this._peek.type === 20 /* TokenType.EXPANSION_CASE_VALUE */) {
             const expCase = this._parseExpansionCase();
             if (!expCase)
                 return; // error
             cases.push(expCase);
         }
         // read the final }
-        if (this._peek.type !== 23 /* EXPANSION_FORM_END */) {
+        if (this._peek.type !== 23 /* TokenType.EXPANSION_FORM_END */) {
             this.errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '}'.`));
             return;
         }
@@ -13968,7 +13970,7 @@ class _TreeBuilder {
     _parseExpansionCase() {
         const value = this._advance();
         // read {
-        if (this._peek.type !== 21 /* EXPANSION_CASE_EXP_START */) {
+        if (this._peek.type !== 21 /* TokenType.EXPANSION_CASE_EXP_START */) {
             this.errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '{'.`));
             return null;
         }
@@ -13978,7 +13980,7 @@ class _TreeBuilder {
         if (!exp)
             return null;
         const end = this._advance();
-        exp.push({ type: 24 /* EOF */, parts: [], sourceSpan: end.sourceSpan });
+        exp.push({ type: 24 /* TokenType.EOF */, parts: [], sourceSpan: end.sourceSpan });
         // parse everything in between { and }
         const expansionCaseParser = new _TreeBuilder(exp, this.getTagDefinition);
         expansionCaseParser.build();
@@ -13992,14 +13994,14 @@ class _TreeBuilder {
     }
     _collectExpansionExpTokens(start) {
         const exp = [];
-        const expansionFormStack = [21 /* EXPANSION_CASE_EXP_START */];
+        const expansionFormStack = [21 /* TokenType.EXPANSION_CASE_EXP_START */];
         while (true) {
-            if (this._peek.type === 19 /* EXPANSION_FORM_START */ ||
-                this._peek.type === 21 /* EXPANSION_CASE_EXP_START */) {
+            if (this._peek.type === 19 /* TokenType.EXPANSION_FORM_START */ ||
+                this._peek.type === 21 /* TokenType.EXPANSION_CASE_EXP_START */) {
                 expansionFormStack.push(this._peek.type);
             }
-            if (this._peek.type === 22 /* EXPANSION_CASE_EXP_END */) {
-                if (lastOnStack(expansionFormStack, 21 /* EXPANSION_CASE_EXP_START */)) {
+            if (this._peek.type === 22 /* TokenType.EXPANSION_CASE_EXP_END */) {
+                if (lastOnStack(expansionFormStack, 21 /* TokenType.EXPANSION_CASE_EXP_START */)) {
                     expansionFormStack.pop();
                     if (expansionFormStack.length === 0)
                         return exp;
@@ -14009,8 +14011,8 @@ class _TreeBuilder {
                     return null;
                 }
             }
-            if (this._peek.type === 23 /* EXPANSION_FORM_END */) {
-                if (lastOnStack(expansionFormStack, 19 /* EXPANSION_FORM_START */)) {
+            if (this._peek.type === 23 /* TokenType.EXPANSION_FORM_END */) {
+                if (lastOnStack(expansionFormStack, 19 /* TokenType.EXPANSION_FORM_START */)) {
                     expansionFormStack.pop();
                 }
                 else {
@@ -14018,7 +14020,7 @@ class _TreeBuilder {
                     return null;
                 }
             }
-            if (this._peek.type === 24 /* EOF */) {
+            if (this._peek.type === 24 /* TokenType.EOF */) {
                 this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
                 return null;
             }
@@ -14037,18 +14039,18 @@ class _TreeBuilder {
                 tokens[0] = { type: token.type, sourceSpan: token.sourceSpan, parts: [text] };
             }
         }
-        while (this._peek.type === 8 /* INTERPOLATION */ || this._peek.type === 5 /* TEXT */ ||
-            this._peek.type === 9 /* ENCODED_ENTITY */) {
+        while (this._peek.type === 8 /* TokenType.INTERPOLATION */ || this._peek.type === 5 /* TokenType.TEXT */ ||
+            this._peek.type === 9 /* TokenType.ENCODED_ENTITY */) {
             token = this._advance();
             tokens.push(token);
-            if (token.type === 8 /* INTERPOLATION */) {
+            if (token.type === 8 /* TokenType.INTERPOLATION */) {
                 // For backward compatibility we decode HTML entities that appear in interpolation
                 // expressions. This is arguably a bug, but it could be a considerable breaking change to
                 // fix it. It should be addressed in a larger project to refactor the entire parser/lexer
                 // chain after View Engine has been removed.
                 text += token.parts.join('').replace(/&([^;]+);/g, decodeEntity);
             }
-            else if (token.type === 9 /* ENCODED_ENTITY */) {
+            else if (token.type === 9 /* TokenType.ENCODED_ENTITY */) {
                 text += token.parts[0];
             }
             else {
@@ -14069,14 +14071,14 @@ class _TreeBuilder {
     _consumeStartTag(startTagToken) {
         const [prefix, name] = startTagToken.parts;
         const attrs = [];
-        while (this._peek.type === 14 /* ATTR_NAME */) {
+        while (this._peek.type === 14 /* TokenType.ATTR_NAME */) {
             attrs.push(this._consumeAttr(this._advance()));
         }
         const fullName = this._getElementFullName(prefix, name, this._getParentElement());
         let selfClosing = false;
         // Note: There could have been a tokenizer error
         // so that we don't get a token for the end tag...
-        if (this._peek.type === 2 /* TAG_OPEN_END_VOID */) {
+        if (this._peek.type === 2 /* TokenType.TAG_OPEN_END_VOID */) {
             this._advance();
             selfClosing = true;
             const tagDef = this.getTagDefinition(fullName);
@@ -14084,7 +14086,7 @@ class _TreeBuilder {
                 this.errors.push(TreeError.create(fullName, startTagToken.sourceSpan, `Only void and foreign elements can be self closed "${startTagToken.parts[1]}"`));
             }
         }
-        else if (this._peek.type === 1 /* TAG_OPEN_END */) {
+        else if (this._peek.type === 1 /* TokenType.TAG_OPEN_END */) {
             this._advance();
             selfClosing = false;
         }
@@ -14099,7 +14101,7 @@ class _TreeBuilder {
             // element start tag also represents the end tag.
             this._popElement(fullName, span);
         }
-        else if (startTagToken.type === 4 /* INCOMPLETE_TAG_OPEN */) {
+        else if (startTagToken.type === 4 /* TokenType.INCOMPLETE_TAG_OPEN */) {
             // We already know the opening tag is not complete, so it is unlikely it has a corresponding
             // close tag. Let's optimistically parse it as a full element and emit an error.
             this._popElement(fullName, null);
@@ -14156,7 +14158,7 @@ class _TreeBuilder {
         const fullName = mergeNsAndName(attrName.parts[0], attrName.parts[1]);
         let attrEnd = attrName.sourceSpan.end;
         // Consume any quote
-        if (this._peek.type === 15 /* ATTR_QUOTE */) {
+        if (this._peek.type === 15 /* TokenType.ATTR_QUOTE */) {
             this._advance();
         }
         // Consume the attribute value
@@ -14169,22 +14171,22 @@ class _TreeBuilder {
         // being able to consider `ATTR_VALUE_INTERPOLATION` as an option. This is because TS is not
         // able to see that `_advance()` will actually mutate `_peek`.
         const nextTokenType = this._peek.type;
-        if (nextTokenType === 16 /* ATTR_VALUE_TEXT */) {
+        if (nextTokenType === 16 /* TokenType.ATTR_VALUE_TEXT */) {
             valueStartSpan = this._peek.sourceSpan;
             valueEnd = this._peek.sourceSpan.end;
-            while (this._peek.type === 16 /* ATTR_VALUE_TEXT */ ||
-                this._peek.type === 17 /* ATTR_VALUE_INTERPOLATION */ ||
-                this._peek.type === 9 /* ENCODED_ENTITY */) {
+            while (this._peek.type === 16 /* TokenType.ATTR_VALUE_TEXT */ ||
+                this._peek.type === 17 /* TokenType.ATTR_VALUE_INTERPOLATION */ ||
+                this._peek.type === 9 /* TokenType.ENCODED_ENTITY */) {
                 const valueToken = this._advance();
                 valueTokens.push(valueToken);
-                if (valueToken.type === 17 /* ATTR_VALUE_INTERPOLATION */) {
+                if (valueToken.type === 17 /* TokenType.ATTR_VALUE_INTERPOLATION */) {
                     // For backward compatibility we decode HTML entities that appear in interpolation
                     // expressions. This is arguably a bug, but it could be a considerable breaking change to
                     // fix it. It should be addressed in a larger project to refactor the entire parser/lexer
                     // chain after View Engine has been removed.
                     value += valueToken.parts.join('').replace(/&([^;]+);/g, decodeEntity);
                 }
-                else if (valueToken.type === 9 /* ENCODED_ENTITY */) {
+                else if (valueToken.type === 9 /* TokenType.ENCODED_ENTITY */) {
                     value += valueToken.parts[0];
                 }
                 else {
@@ -14194,7 +14196,7 @@ class _TreeBuilder {
             }
         }
         // Consume any quote
-        if (this._peek.type === 15 /* ATTR_QUOTE */) {
+        if (this._peek.type === 15 /* TokenType.ATTR_QUOTE */) {
             const quoteToken = this._advance();
             attrEnd = quoteToken.sourceSpan.end;
         }
@@ -14324,7 +14326,7 @@ class WhitespaceVisitor {
             (context.prev instanceof Expansion || context.next instanceof Expansion);
         if (isNotBlank || hasExpansionSibling) {
             // Process the whitespace in the tokens of this Text node
-            const tokens = text.tokens.map(token => token.type === 5 /* TEXT */ ? createWhitespaceProcessedTextToken(token) : token);
+            const tokens = text.tokens.map(token => token.type === 5 /* TokenType.TEXT */ ? createWhitespaceProcessedTextToken(token) : token);
             // Process the whitespace of the value of this Text node
             const value = processWhitespace(text.value);
             return new Text(value, text.sourceSpan, tokens, text.i18n);
@@ -15151,7 +15153,7 @@ class BindingParser {
     }
     createBoundElementProperty(elementSelector, boundProp, skipValidation = false, mapPropertyName = true) {
         if (boundProp.isAnimation) {
-            return new BoundElementProperty(boundProp.name, 4 /* Animation */, SecurityContext.NONE, boundProp.expression, null, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
+            return new BoundElementProperty(boundProp.name, 4 /* BindingType.Animation */, SecurityContext.NONE, boundProp.expression, null, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
         }
         let unit = null;
         let bindingType = undefined;
@@ -15172,17 +15174,17 @@ class BindingParser {
                     const name = boundPropertyName.substring(nsSeparatorIdx + 1);
                     boundPropertyName = mergeNsAndName(ns, name);
                 }
-                bindingType = 1 /* Attribute */;
+                bindingType = 1 /* BindingType.Attribute */;
             }
             else if (parts[0] == CLASS_PREFIX) {
                 boundPropertyName = parts[1];
-                bindingType = 2 /* Class */;
+                bindingType = 2 /* BindingType.Class */;
                 securityContexts = [SecurityContext.NONE];
             }
             else if (parts[0] == STYLE_PREFIX) {
                 unit = parts.length > 2 ? parts[2] : null;
                 boundPropertyName = parts[1];
-                bindingType = 3 /* Style */;
+                bindingType = 3 /* BindingType.Style */;
                 securityContexts = [SecurityContext.STYLE];
             }
         }
@@ -15191,7 +15193,7 @@ class BindingParser {
             const mappedPropName = this._schemaRegistry.getMappedPropName(boundProp.name);
             boundPropertyName = mapPropertyName ? mappedPropName : boundProp.name;
             securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, mappedPropName, false);
-            bindingType = 0 /* Property */;
+            bindingType = 0 /* BindingType.Property */;
             if (!skipValidation) {
                 this._validatePropertyOrAttributeName(mappedPropName, boundProp.sourceSpan, false);
             }
@@ -15204,7 +15206,7 @@ class BindingParser {
             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));
             }
@@ -15223,7 +15225,7 @@ class BindingParser {
         const eventName = matches[0];
         const phase = matches[1].toLowerCase();
         const ast = this._parseAction(expression, isAssignmentEvent, handlerSpan);
-        targetEvents.push(new ParsedEvent(eventName, phase, 1 /* Animation */, ast, sourceSpan, handlerSpan, keySpan));
+        targetEvents.push(new ParsedEvent(eventName, phase, 1 /* ParsedEventType.Animation */, ast, sourceSpan, handlerSpan, keySpan));
         if (eventName.length === 0) {
             this._reportError(`Animation event name is missing in binding`, sourceSpan);
         }
@@ -15241,7 +15243,7 @@ class BindingParser {
         const [target, eventName] = splitAtColon(name, [null, name]);
         const ast = this._parseAction(expression, isAssignmentEvent, handlerSpan);
         targetMatchableAttrs.push([name, ast.source]);
-        targetEvents.push(new ParsedEvent(eventName, target, 0 /* Regular */, ast, sourceSpan, handlerSpan, keySpan));
+        targetEvents.push(new ParsedEvent(eventName, target, 0 /* ParsedEventType.Regular */, ast, sourceSpan, handlerSpan, keySpan));
         // Don't detect directives for event names for now,
         // so don't add the event name to the matchableAttrs
     }
@@ -16311,8 +16313,8 @@ class _I18nVisitor {
         let hasInterpolation = false;
         for (const token of tokens) {
             switch (token.type) {
-                case 8 /* INTERPOLATION */:
-                case 17 /* ATTR_VALUE_INTERPOLATION */:
+                case 8 /* TokenType.INTERPOLATION */:
+                case 17 /* TokenType.ATTR_VALUE_INTERPOLATION */:
                     hasInterpolation = true;
                     const expression = token.parts[1];
                     const baseName = extractPlaceholderName(expression) || 'INTERPOLATION';
@@ -16641,25 +16643,78 @@ function parseI18nMeta(meta = '') {
 function i18nMetaToJSDoc(meta) {
     const tags = [];
     if (meta.description) {
-        tags.push({ tagName: "desc" /* Desc */, text: meta.description });
+        tags.push({ tagName: "desc" /* o.JSDocTagName.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}' });
+        tags.push({ tagName: "suppress" /* o.JSDocTagName.Suppress */, text: '{msgDescriptions}' });
     }
     if (meta.meaning) {
-        tags.push({ tagName: "meaning" /* Meaning */, text: meta.meaning });
+        tags.push({ tagName: "meaning" /* o.JSDocTagName.Meaning */, text: meta.meaning });
     }
     return jsDocComment(tags);
 }
 
 /** Closure uses `goog.getMsg(message)` to lookup translations */
 const GOOG_GET_MSG = 'goog.getMsg';
-function createGoogleGetMsgStatements(variable$1, message, closureVar, params) {
+/**
+ * Generates a `goog.getMsg()` statement and reassignment. The template:
+ *
+ * ```html
+ * <div i18n>Sent from {{ sender }} to <span class="receiver">{{ receiver }}</span></div>
+ * ```
+ *
+ * Generates:
+ *
+ * ```typescript
+ * const MSG_FOO = goog.getMsg(
+ *   // Message template.
+ *   'Sent from {$interpolation} to {$startTagSpan}{$interpolation_1}{$closeTagSpan}.',
+ *   // Placeholder values, set to magic strings which get replaced by the Angular runtime.
+ *   {
+ *     'interpolation': '\uFFFD0\uFFFD',
+ *     'startTagSpan': '\uFFFD1\uFFFD',
+ *     'interpolation_1': '\uFFFD2\uFFFD',
+ *     'closeTagSpan': '\uFFFD3\uFFFD',
+ *   },
+ *   // Options bag.
+ *   {
+ *     // Maps each placeholder to the original Angular source code which generates it's value.
+ *     original_code: {
+ *       'interpolation': '{{ sender }}',
+ *       'startTagSpan': '<span class="receiver">',
+ *       'interploation_1': '{{ receiver }}',
+ *       'closeTagSpan': '</span>',
+ *     },
+ *   },
+ * );
+ * const I18N_0 = MSG_FOO;
+ * ```
+ */
+function createGoogleGetMsgStatements(variable$1, message, closureVar, placeholderValues) {
     const messageString = serializeI18nMessageForGetMsg(message);
     const args = [literal(messageString)];
-    if (Object.keys(params).length) {
-        args.push(mapLiteral(params, true));
+    if (Object.keys(placeholderValues).length) {
+        // Message template parameters containing the magic strings replaced by the Angular runtime with
+        // real data, e.g. `{'interpolation': '\uFFFD0\uFFFD'}`.
+        args.push(mapLiteral(formatI18nPlaceholderNamesInMap(placeholderValues, true /* useCamelCase */), true /* quoted */));
+        // Message options object, which contains original source code for placeholders (as they are
+        // present in a template, e.g.
+        // `{original_code: {'interpolation': '{{ name }}', 'startTagSpan': '<span>'}}`.
+        args.push(mapLiteral({
+            original_code: literalMap(Object.keys(placeholderValues)
+                .map((param) => ({
+                key: formatI18nPlaceholderName(param),
+                quoted: true,
+                value: message.placeholders[param] ?
+                    // Get source span for typical placeholder if it exists.
+                    literal(message.placeholders[param].sourceSpan.toString()) :
+                    // Otherwise must be an ICU expression, get it's source span.
+                    literal(message.placeholderToMessage[param]
+                        .nodes.map((node) => node.sourceSpan.toString())
+                        .join('')),
+            }))),
+        }));
     }
     // /**
     //  * @desc description of message
@@ -16849,14 +16904,28 @@ 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);
-    const eventName = type === 1 /* Animation */ ? prepareSyntheticListenerName(name, phase) : name;
+    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 /* ParsedEventType.Animation */ ? prepareSyntheticListenerName(name, phase) : name;
     const fnName = handlerName && sanitizeIdentifier(handlerName);
     const fnArgs = [];
     if (implicitReceiverAccesses.has(eventArgumentName)) {
@@ -17008,10 +17077,10 @@ class TemplateDefinitionBuilder {
         const creationVariables = this._bindingScope.viewSnapshotStatements();
         const updateVariables = this._bindingScope.variableDeclarations().concat(this._tempVariables);
         const creationBlock = creationStatements.length > 0 ?
-            [renderFlagCheckIfStmt(1 /* Create */, creationVariables.concat(creationStatements))] :
+            [renderFlagCheckIfStmt(1 /* core.RenderFlags.Create */, creationVariables.concat(creationStatements))] :
             [];
         const updateBlock = updateStatements.length > 0 ?
-            [renderFlagCheckIfStmt(2 /* Update */, updateVariables.concat(updateStatements))] :
+            [renderFlagCheckIfStmt(2 /* core.RenderFlags.Update */, updateVariables.concat(updateStatements))] :
             [];
         return fn(
         // i.e. (rf: RenderFlags, ctx: any)
@@ -17049,7 +17118,7 @@ class TemplateDefinitionBuilder {
         const scopedName = this._bindingScope.freshReferenceName();
         const retrievalLevel = this.level;
         const lhs = variable(variable$1.name + scopedName);
-        this._bindingScope.set(retrievalLevel, variable$1.name, lhs, 1 /* CONTEXT */, (scope, relativeLevel) => {
+        this._bindingScope.set(retrievalLevel, variable$1.name, lhs, 1 /* DeclarationPriority.CONTEXT */, (scope, relativeLevel) => {
             let rhs;
             if (scope.bindingLevel === retrievalLevel) {
                 if (scope.isListenerScope() && scope.hasRestoreViewVariable()) {
@@ -17303,7 +17372,7 @@ class TemplateDefinitionBuilder {
         element.inputs.forEach(input => {
             const stylingInputWasSet = stylingBuilder.registerBoundInput(input);
             if (!stylingInputWasSet) {
-                if (input.type === 0 /* Property */ && input.i18n) {
+                if (input.type === 0 /* BindingType.Property */ && input.i18n) {
                     boundI18nAttrs.push(input);
                 }
                 else {
@@ -17376,7 +17445,7 @@ class TemplateDefinitionBuilder {
         // Generate element input bindings
         allOtherInputs.forEach(input => {
             const inputType = input.type;
-            if (inputType === 4 /* Animation */) {
+            if (inputType === 4 /* BindingType.Animation */) {
                 const value = input.value.visit(this._valueConverter);
                 // animation bindings can be presented in the following formats:
                 // 1. [@binding]="fooExp"
@@ -17403,7 +17472,7 @@ class TemplateDefinitionBuilder {
                 if (value !== undefined) {
                     const params = [];
                     const [attrNamespace, attrName] = splitNsName(input.name);
-                    const isAttributeBinding = inputType === 1 /* Attribute */;
+                    const isAttributeBinding = inputType === 1 /* BindingType.Attribute */;
                     const sanitizationRef = resolveSanitizationFn(input.securityContext, isAttributeBinding);
                     if (sanitizationRef)
                         params.push(sanitizationRef);
@@ -17419,7 +17488,7 @@ class TemplateDefinitionBuilder {
                         }
                     }
                     this.allocateBindingSlots(value);
-                    if (inputType === 0 /* Property */) {
+                    if (inputType === 0 /* BindingType.Property */) {
                         if (value instanceof Interpolation) {
                             // prop="{{value}}" and friends
                             this.interpolatedUpdateInstruction(getPropertyInterpolationExpression(value), elementIndex, attrName, input, value, params);
@@ -17433,7 +17502,7 @@ class TemplateDefinitionBuilder {
                             });
                         }
                     }
-                    else if (inputType === 1 /* Attribute */) {
+                    else if (inputType === 1 /* BindingType.Attribute */) {
                         if (value instanceof Interpolation && getInterpolationArgsLength(value) > 1) {
                             // attr.name="text{{value}}" and friends
                             this.interpolatedUpdateInstruction(getAttributeInterpolationExpression(value), elementIndex, attrName, input, value, params);
@@ -17599,7 +17668,7 @@ class TemplateDefinitionBuilder {
         // - all ICU vars (such as `VAR_SELECT` or `VAR_PLURAL`) are replaced with correct values
         const transformFn = (raw) => {
             const params = Object.assign(Object.assign({}, vars), placeholders);
-            const formatted = i18nFormatPlaceholderNames(params, /* useCamelCase */ false);
+            const formatted = formatI18nPlaceholderNamesInMap(params, /* useCamelCase */ false);
             return invokeInstruction(null, Identifiers.i18nPostprocess, [raw, mapLiteral(formatted, true)]);
         };
         // in case the whole i18n message is a single ICU - we do not need to
@@ -17830,13 +17899,13 @@ class TemplateDefinitionBuilder {
                 const input = inputs[i];
                 // We don't want the animation and attribute bindings in the
                 // attributes array since they aren't used for directive matching.
-                if (input.type !== 4 /* Animation */ && input.type !== 1 /* Attribute */) {
+                if (input.type !== 4 /* BindingType.Animation */ && input.type !== 1 /* BindingType.Attribute */) {
                     addAttrExpr(input.name);
                 }
             }
             for (let i = 0; i < outputs.length; i++) {
                 const output = outputs[i];
-                if (output.type !== 1 /* Animation */) {
+                if (output.type !== 1 /* ParsedEventType.Animation */) {
                     addAttrExpr(output.name);
                 }
             }
@@ -17845,15 +17914,15 @@ class TemplateDefinitionBuilder {
             // to the expressions. The marker is important because it tells the runtime
             // code that this is where attributes without values start...
             if (attrExprs.length !== attrsLengthBeforeInputs) {
-                attrExprs.splice(attrsLengthBeforeInputs, 0, literal(3 /* Bindings */));
+                attrExprs.splice(attrsLengthBeforeInputs, 0, literal(3 /* core.AttributeMarker.Bindings */));
             }
         }
         if (templateAttrs.length) {
-            attrExprs.push(literal(4 /* Template */));
+            attrExprs.push(literal(4 /* core.AttributeMarker.Template */));
             templateAttrs.forEach(attr => addAttrExpr(attr.name));
         }
         if (boundI18nAttrs.length) {
-            attrExprs.push(literal(6 /* I18n */));
+            attrExprs.push(literal(6 /* core.AttributeMarker.I18n */));
             boundI18nAttrs.forEach(attr => addAttrExpr(attr.name));
         }
         return attrExprs;
@@ -17884,7 +17953,7 @@ class TemplateDefinitionBuilder {
             const variableName = this._bindingScope.freshReferenceName();
             const retrievalLevel = this.level;
             const lhs = variable(variableName);
-            this._bindingScope.set(retrievalLevel, reference.name, lhs, 0 /* DEFAULT */, (scope, relativeLevel) => {
+            this._bindingScope.set(retrievalLevel, reference.name, lhs, 0 /* DeclarationPriority.DEFAULT */, (scope, relativeLevel) => {
                 // e.g. nextContext(2);
                 const nextContextStmt = relativeLevel > 0 ? [generateNextContextExpr(relativeLevel).toStmt()] : [];
                 // e.g. const $foo$ = reference(1);
@@ -17898,7 +17967,7 @@ class TemplateDefinitionBuilder {
     prepareListenerParameter(tagName, outputAst, index) {
         return () => {
             const eventName = outputAst.name;
-            const bindingFnName = outputAst.type === 1 /* Animation */ ?
+            const bindingFnName = outputAst.type === 1 /* ParsedEventType.Animation */ ?
                 // synthetic @listener.foo values are treated the exact same as are standard listeners
                 prepareSyntheticListenerFunctionName(eventName, outputAst.phase) :
                 sanitizeIdentifier(eventName);
@@ -18018,7 +18087,7 @@ function getAttributeNameLiterals(name) {
     const nameLiteral = literal(attributeName);
     if (attributeNamespace) {
         return [
-            literal(0 /* NamespaceURI */), literal(attributeNamespace), nameLiteral
+            literal(0 /* core.AttributeMarker.NamespaceURI */), literal(attributeNamespace), nameLiteral
         ];
     }
     return [nameLiteral];
@@ -18087,7 +18156,7 @@ class BindingScope {
      * @param declareLocalCallback The callback to invoke when declaring this local var
      * @param localRef Whether or not this is a local ref
      */
-    set(retrievalLevel, name, lhs, priority = 0 /* DEFAULT */, declareLocalCallback, localRef) {
+    set(retrievalLevel, name, lhs, priority = 0 /* DeclarationPriority.DEFAULT */, declareLocalCallback, localRef) {
         if (this.map.has(name)) {
             if (localRef) {
                 // Do not throw an error if it's a local ref and do not update existing value,
@@ -18143,7 +18212,7 @@ class BindingScope {
         return sharedCtxObj && sharedCtxObj.declare ? sharedCtxObj.lhs : null;
     }
     maybeGenerateSharedContextVar(value) {
-        if (value.priority === 1 /* CONTEXT */ &&
+        if (value.priority === 1 /* DeclarationPriority.CONTEXT */ &&
             value.retrievalLevel < this.bindingLevel) {
             const sharedCtxObj = this.map.get(SHARED_CONTEXT_KEY + value.retrievalLevel);
             if (sharedCtxObj) {
@@ -18164,7 +18233,7 @@ class BindingScope {
                 return [lhs.set(generateNextContextExpr(relativeLevel)).toConstDecl()];
             },
             declare: false,
-            priority: 2 /* SHARED_CONTEXT */,
+            priority: 2 /* DeclarationPriority.SHARED_CONTEXT */,
         });
     }
     getComponentProperty(name) {
@@ -18187,16 +18256,15 @@ class BindingScope {
         }
     }
     restoreViewStatement() {
-        const statements = [];
         if (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();
@@ -18262,7 +18330,7 @@ function getNgProjectAsLiteral(attribute) {
     // Parse the attribute value into a CssSelectorList. Note that we only take the
     // first selector, because we don't support multiple selectors in ngProjectAs.
     const parsedR3Selector = parseSelectorToR3Selector(attribute.value)[0];
-    return [literal(5 /* ProjectAs */), asLiteral(parsedR3Selector)];
+    return [literal(5 /* core.AttributeMarker.ProjectAs */), asLiteral(parsedR3Selector)];
 }
 /**
  * Gets the instruction to generate for an interpolated property
@@ -18521,7 +18589,7 @@ const NG_I18N_CLOSURE_MODE = 'ngI18nClosureMode';
 function getTranslationDeclStmts(message, variable, closureVar, params = {}, transformFn) {
     const statements = [
         declareI18nVariable(variable),
-        ifStmt(createClosureModeGuard(), createGoogleGetMsgStatements(variable, message, closureVar, i18nFormatPlaceholderNames(params, /* useCamelCase */ true)), createLocalizeStatements(variable, message, i18nFormatPlaceholderNames(params, /* useCamelCase */ false))),
+        ifStmt(createClosureModeGuard(), createGoogleGetMsgStatements(variable, message, closureVar, params), createLocalizeStatements(variable, message, formatI18nPlaceholderNamesInMap(params, /* useCamelCase */ false))),
     ];
     if (transformFn) {
         statements.push(new ExpressionStatement(variable.set(transformFn(variable))));
@@ -18586,6 +18654,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;
 }
 /**
@@ -18612,6 +18683,10 @@ function addFeatures(definitionMap, meta) {
     if (meta.lifecycle.usesOnChanges) {
         features.push(importExpr(Identifiers.NgOnChangesFeature));
     }
+    // TODO: better way of differentiating component vs directive metadata.
+    if (meta.hasOwnProperty('template') && meta.isStandalone) {
+        features.push(importExpr(Identifiers.StandaloneFeature));
+    }
     if (features.length) {
         definitionMap.set('features', literalArr(features));
     }
@@ -18675,17 +18750,8 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
         definitionMap.set('consts', constsExpr);
     }
     definitionMap.set('template', templateFunctionExpression);
-    // e.g. `directives: [MyDirective]`
-    if (meta.directives.length > 0) {
-        const directivesList = literalArr(meta.directives.map(dir => dir.type));
-        const directivesExpr = compileDeclarationList(directivesList, meta.declarationListEmitMode);
-        definitionMap.set('directives', directivesExpr);
-    }
-    // e.g. `pipes: [MyPipe]`
-    if (meta.pipes.size > 0) {
-        const pipesList = literalArr(Array.from(meta.pipes.values()));
-        const pipesExpr = compileDeclarationList(pipesList, meta.declarationListEmitMode);
-        definitionMap.set('pipes', pipesExpr);
+    if (meta.declarations.length > 0) {
+        definitionMap.set('dependencies', compileDeclarationList(literalArr(meta.declarations.map(decl => decl.type)), meta.declarationListEmitMode));
     }
     if (meta.encapsulation === null) {
         meta.encapsulation = exports.ViewEncapsulation.Emulated;
@@ -18695,8 +18761,15 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
         const styleValues = meta.encapsulation == exports.ViewEncapsulation.Emulated ?
             compileStyles(meta.styles, CONTENT_ATTR, HOST_ATTR) :
             meta.styles;
-        const strings = styleValues.map(str => constantPool.getConstLiteral(literal(str)));
-        definitionMap.set('styles', literalArr(strings));
+        const styleNodes = styleValues.reduce((result, style) => {
+            if (style.trim().length > 0) {
+                result.push(constantPool.getConstLiteral(literal(style)));
+            }
+            return result;
+        }, []);
+        if (styleNodes.length > 0) {
+            definitionMap.set('styles', literalArr(styleNodes));
+        }
     }
     else if (meta.encapsulation === exports.ViewEncapsulation.Emulated) {
         // If there is no style, don't generate css selectors on elements
@@ -18723,8 +18796,9 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
  * to be consumed by upstream compilations.
  */
 function createComponentType(meta) {
-    const typeParams = createDirectiveTypeParams(meta);
+    const typeParams = createBaseDirectiveTypeParams(meta);
     typeParams.push(stringArrayAsType(meta.template.ngContentSelectors));
+    typeParams.push(expressionType(literal(meta.isStandalone)));
     return expressionType(importExpr(Identifiers.ComponentDeclaration, typeParams));
 }
 /**
@@ -18733,13 +18807,13 @@ function createComponentType(meta) {
  */
 function compileDeclarationList(list, mode) {
     switch (mode) {
-        case 0 /* Direct */:
+        case 0 /* DeclarationListEmitMode.Direct */:
             // directives: [MyDir],
             return list;
-        case 1 /* Closure */:
+        case 1 /* DeclarationListEmitMode.Closure */:
             // directives: function () { return [MyDir]; }
             return fn([], [new ReturnStatement(list)]);
-        case 2 /* ClosureResolved */:
+        case 2 /* DeclarationListEmitMode.ClosureResolved */:
             // directives: function () { return [MyDir].map(ng.resolveForwardRef); }
             const resolvedList = list.prop('map').callFn([importExpr(Identifiers.resolveForwardRef)]);
             return fn([], [new ReturnStatement(resolvedList)]);
@@ -18757,9 +18831,9 @@ function prepareQueryParams(query, constantPool) {
  * @param query
  */
 function toQueryFlags(query) {
-    return (query.descendants ? 1 /* descendants */ : 0 /* none */) |
-        (query.static ? 2 /* isStatic */ : 0 /* none */) |
-        (query.emitDistinctChangesOnly ? 4 /* emitDistinctChangesOnly */ : 0 /* none */);
+    return (query.descendants ? 1 /* QueryFlags.descendants */ : 0 /* QueryFlags.none */) |
+        (query.static ? 2 /* QueryFlags.isStatic */ : 0 /* QueryFlags.none */) |
+        (query.emitDistinctChangesOnly ? 4 /* QueryFlags.emitDistinctChangesOnly */ : 0 /* QueryFlags.none */);
 }
 function convertAttributesToExpressions(attributes) {
     const values = [];
@@ -18793,8 +18867,8 @@ function createContentQueriesFunction(queries, constantPool, name) {
         new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null),
         new FnParam('dirIndex', null)
     ], [
-        renderFlagCheckIfStmt(1 /* Create */, createStatements),
-        renderFlagCheckIfStmt(2 /* Update */, updateStatements)
+        renderFlagCheckIfStmt(1 /* core.RenderFlags.Create */, createStatements),
+        renderFlagCheckIfStmt(2 /* core.RenderFlags.Update */, updateStatements)
     ], INFERRED_TYPE, null, contentQueriesFnName);
 }
 function stringAsType(str) {
@@ -18815,7 +18889,7 @@ function stringArrayAsType(arr) {
     return arr.length > 0 ? expressionType(literalArr(arr.map(value => literal(value)))) :
         NONE_TYPE;
 }
-function createDirectiveTypeParams(meta) {
+function createBaseDirectiveTypeParams(meta) {
     // On the type side, remove newlines from the selector as it will need to fit into a TypeScript
     // string literal, which must be on one line.
     const selectorForType = meta.selector !== null ? meta.selector.replace(/\n/g, '') : null;
@@ -18833,7 +18907,11 @@ function createDirectiveTypeParams(meta) {
  * to be consumed by upstream compilations.
  */
 function createDirectiveType(meta) {
-    const typeParams = createDirectiveTypeParams(meta);
+    const typeParams = createBaseDirectiveTypeParams(meta);
+    // Directives have no NgContentSelectors slot, but instead express a `never` type
+    // so that future fields align.
+    typeParams.push(NONE_TYPE);
+    typeParams.push(expressionType(literal(meta.isStandalone)));
     return expressionType(importExpr(Identifiers.DirectiveDeclaration, typeParams));
 }
 // Define and update any view queries
@@ -18856,8 +18934,8 @@ function createViewQueriesFunction(viewQueries, constantPool, name) {
     });
     const viewQueryFnName = name ? `${name}_Query` : null;
     return fn([new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null)], [
-        renderFlagCheckIfStmt(1 /* Create */, createStatements),
-        renderFlagCheckIfStmt(2 /* Update */, updateStatements)
+        renderFlagCheckIfStmt(1 /* core.RenderFlags.Create */, createStatements),
+        renderFlagCheckIfStmt(2 /* core.RenderFlags.Update */, updateStatements)
     ], INFERRED_TYPE, null, viewQueryFnName);
 }
 // Return a host binding function or null if one is not necessary.
@@ -18997,10 +19075,10 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
         const hostBindingsFnName = name ? `${name}_HostBindings` : null;
         const statements = [];
         if (createInstructions.length > 0) {
-            statements.push(renderFlagCheckIfStmt(1 /* Create */, getInstructionStatements(createInstructions)));
+            statements.push(renderFlagCheckIfStmt(1 /* core.RenderFlags.Create */, getInstructionStatements(createInstructions)));
         }
         if (updateInstructions.length > 0) {
-            statements.push(renderFlagCheckIfStmt(2 /* Update */, updateVariables.concat(getInstructionStatements(updateInstructions))));
+            statements.push(renderFlagCheckIfStmt(2 /* core.RenderFlags.Update */, updateVariables.concat(getInstructionStatements(updateInstructions))));
         }
         return fn([new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null)], statements, INFERRED_TYPE, null, hostBindingsFnName);
     }
@@ -19041,12 +19119,12 @@ function createHostListeners(eventBindings, name) {
     const instructions = [];
     for (const binding of eventBindings) {
         let bindingName = binding.name && sanitizeIdentifier(binding.name);
-        const bindingFnName = binding.type === 1 /* Animation */ ?
+        const bindingFnName = binding.type === 1 /* ParsedEventType.Animation */ ?
             prepareSyntheticListenerFunctionName(bindingName, binding.targetOrPhase) :
             bindingName;
         const handlerName = name && bindingName ? `${name}_${bindingFnName}_HostBindingHandler` : null;
         const params = prepareEventListenerParameters(BoundEvent.fromParsedEvent(binding), handlerName);
-        if (binding.type == 1 /* Animation */) {
+        if (binding.type == 1 /* ParsedEventType.Animation */) {
             syntheticListenerParams.push(params);
         }
         else {
@@ -19095,7 +19173,7 @@ function parseHostBindings(host) {
                     }
             }
         }
-        else if (matches[1 /* Binding */] != null) {
+        else if (matches[1 /* HostBindingGroup.Binding */] != null) {
             if (typeof value !== 'string') {
                 // TODO(alxhub): make this a diagnostic.
                 throw new Error(`Property binding must be string`);
@@ -19103,14 +19181,14 @@ function parseHostBindings(host) {
             // synthetic properties (the ones that have a `@` as a prefix)
             // are still treated the same as regular properties. Therefore
             // there is no point in storing them in a separate map.
-            properties[matches[1 /* Binding */]] = value;
+            properties[matches[1 /* HostBindingGroup.Binding */]] = value;
         }
-        else if (matches[2 /* Event */] != null) {
+        else if (matches[2 /* HostBindingGroup.Event */] != null) {
             if (typeof value !== 'string') {
                 // TODO(alxhub): make this a diagnostic.
                 throw new Error(`Event binding must be string`);
             }
-            listeners[matches[2 /* Event */]] = value;
+            listeners[matches[2 /* HostBindingGroup.Event */]] = value;
         }
     }
     return { attributes, listeners, properties, specialAttributes };
@@ -19178,6 +19256,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, []);
@@ -19195,10 +19274,10 @@ class CompilerFacadeImpl {
             internalType: new WrappedNodeExpr(facade.type),
             typeArgumentCount: facade.typeArgumentCount,
             providedIn: computeProvidedIn(facade.providedIn),
-            useClass: convertToProviderExpression(facade, USE_CLASS),
-            useFactory: wrapExpression(facade, USE_FACTORY),
-            useValue: convertToProviderExpression(facade, USE_VALUE),
-            useExisting: convertToProviderExpression(facade, USE_EXISTING),
+            useClass: convertToProviderExpression(facade, 'useClass'),
+            useFactory: wrapExpression(facade, 'useFactory'),
+            useValue: convertToProviderExpression(facade, 'useValue'),
+            useExisting: convertToProviderExpression(facade, 'useExisting'),
             deps: (_a = facade.deps) === null || _a === void 0 ? void 0 : _a.map(convertR3DependencyMetadata),
         }, 
         /* resolveForwardRefs */ true);
@@ -19212,10 +19291,10 @@ class CompilerFacadeImpl {
             internalType: new WrappedNodeExpr(facade.type),
             typeArgumentCount: 0,
             providedIn: computeProvidedIn(facade.providedIn),
-            useClass: convertToProviderExpression(facade, USE_CLASS),
-            useFactory: wrapExpression(facade, USE_FACTORY),
-            useValue: convertToProviderExpression(facade, USE_VALUE),
-            useExisting: convertToProviderExpression(facade, USE_EXISTING),
+            useClass: convertToProviderExpression(facade, 'useClass'),
+            useFactory: wrapExpression(facade, 'useFactory'),
+            useValue: convertToProviderExpression(facade, 'useValue'),
+            useExisting: convertToProviderExpression(facade, 'useExisting'),
             deps: (_a = facade.deps) === null || _a === void 0 ? void 0 : _a.map(convertR3DeclareDependencyMetadata),
         }, 
         /* resolveForwardRefs */ true);
@@ -19246,7 +19325,7 @@ class CompilerFacadeImpl {
             declarations: facade.declarations.map(wrapReference),
             imports: facade.imports.map(wrapReference),
             exports: facade.exports.map(wrapReference),
-            emitInline: true,
+            selectorScopeMode: exports.R3SelectorScopeMode.Inline,
             containsForwardDecls: false,
             schemas: facade.schemas ? facade.schemas.map(wrapReference) : null,
             id: facade.id ? new WrappedNodeExpr(facade.id) : null,
@@ -19277,7 +19356,7 @@ class CompilerFacadeImpl {
         // Parse the template and check for errors.
         const { template, interpolation } = parseJitTemplate(facade.template, facade.name, sourceMapUrl, facade.preserveWhitespaces, facade.interpolation);
         // Compile the component metadata, including template, into an expression.
-        const meta = Object.assign(Object.assign(Object.assign({}, facade), convertDirectiveFacadeToMetadata(facade)), { selector: facade.selector || this.elementSchemaRegistry.getDefaultComponentElementName(), template, declarationListEmitMode: 0 /* Direct */, styles: [...facade.styles, ...template.styles], encapsulation: facade.encapsulation, interpolation, changeDetection: facade.changeDetection, animations: facade.animations != null ? new WrappedNodeExpr(facade.animations) : null, viewProviders: facade.viewProviders != null ? new WrappedNodeExpr(facade.viewProviders) :
+        const meta = Object.assign(Object.assign(Object.assign({}, facade), convertDirectiveFacadeToMetadata(facade)), { selector: facade.selector || this.elementSchemaRegistry.getDefaultComponentElementName(), template, declarations: facade.declarations.map(convertDeclarationFacadeToMetadata), declarationListEmitMode: 0 /* DeclarationListEmitMode.Direct */, styles: [...facade.styles, ...template.styles], encapsulation: facade.encapsulation, interpolation, changeDetection: facade.changeDetection, animations: facade.animations != null ? new WrappedNodeExpr(facade.animations) : null, viewProviders: facade.viewProviders != null ? new WrappedNodeExpr(facade.viewProviders) :
                 null, relativeContextFilePath: '', i18nUseExternalIds: true });
         const jitExpressionSourceMap = `ng:///${facade.name}.js`;
         return this.compileComponentFromMeta(angularCoreEnv, jitExpressionSourceMap, meta);
@@ -19340,10 +19419,6 @@ class CompilerFacadeImpl {
         return res['$def'];
     }
 }
-const USE_CLASS = Object.keys({ useClass: null })[0];
-const USE_FACTORY = Object.keys({ useFactory: null })[0];
-const USE_VALUE = Object.keys({ useValue: null })[0];
-const USE_EXISTING = Object.keys({ useExisting: null })[0];
 function convertToR3QueryMetadata(facade) {
     return Object.assign(Object.assign({}, facade), { predicate: convertQueryPredicate(facade.predicate), read: facade.read ? new WrappedNodeExpr(facade.read) : null, static: facade.static, emitDistinctChangesOnly: facade.emitDistinctChangesOnly });
 }
@@ -19364,7 +19439,7 @@ function convertQueryPredicate(predicate) {
         // The predicate is an array of strings so pass it through.
         predicate :
         // The predicate is a type - assume that we will need to unwrap any `forwardRef()` calls.
-        createMayBeForwardRefExpression(new WrappedNodeExpr(predicate), 1 /* Wrapped */);
+        createMayBeForwardRefExpression(new WrappedNodeExpr(predicate), 1 /* ForwardRefHandling.Wrapped */);
 }
 function convertDirectiveFacadeToMetadata(facade) {
     const inputsFromMetadata = parseInputOutputs(facade.inputs || []);
@@ -19388,7 +19463,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),
@@ -19408,6 +19483,7 @@ function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
         deps: null,
         typeArgumentCount: 0,
         fullInheritance: false,
+        isStandalone: (_j = declaration.isStandalone) !== null && _j !== void 0 ? _j : false,
     };
 }
 function convertHostDeclarationToMetadata(host = {}) {
@@ -19429,19 +19505,43 @@ function convertOpaqueValuesToExpressions(obj) {
     }
     return result;
 }
-function convertDeclareComponentFacadeToMetadata(declaration, typeSourceSpan, sourceMapUrl) {
-    var _a, _b, _c, _d, _e, _f;
-    const { template, interpolation } = parseJitTemplate(declaration.template, declaration.type.name, sourceMapUrl, (_a = declaration.preserveWhitespaces) !== null && _a !== void 0 ? _a : false, declaration.interpolation);
-    return Object.assign(Object.assign({}, convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan)), { template, styles: (_b = declaration.styles) !== null && _b !== void 0 ? _b : [], directives: ((_c = declaration.components) !== null && _c !== void 0 ? _c : [])
-            .concat((_d = declaration.directives) !== null && _d !== void 0 ? _d : [])
-            .map(convertUsedDirectiveDeclarationToMetadata), pipes: convertUsedPipesToMetadata(declaration.pipes), viewProviders: declaration.viewProviders !== undefined ?
-            new WrappedNodeExpr(declaration.viewProviders) :
-            null, animations: declaration.animations !== undefined ? new WrappedNodeExpr(declaration.animations) :
-            null, changeDetection: (_e = declaration.changeDetection) !== null && _e !== void 0 ? _e : exports.ChangeDetectionStrategy.Default, encapsulation: (_f = declaration.encapsulation) !== null && _f !== void 0 ? _f : exports.ViewEncapsulation.Emulated, interpolation, declarationListEmitMode: 2 /* ClosureResolved */, relativeContextFilePath: '', i18nUseExternalIds: true });
-}
-function convertUsedDirectiveDeclarationToMetadata(declaration) {
+function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMapUrl) {
+    var _a, _b, _c, _d;
+    const { template, interpolation } = parseJitTemplate(decl.template, decl.type.name, sourceMapUrl, (_a = decl.preserveWhitespaces) !== null && _a !== void 0 ? _a : false, decl.interpolation);
+    const declarations = [];
+    if (decl.dependencies) {
+        for (const innerDep of decl.dependencies) {
+            switch (innerDep.kind) {
+                case 'directive':
+                case 'component':
+                    declarations.push(convertDirectiveDeclarationToMetadata(innerDep));
+                    break;
+                case 'pipe':
+                    declarations.push(convertPipeDeclarationToMetadata(innerDep));
+                    break;
+            }
+        }
+    }
+    else if (decl.components || decl.directives || decl.pipes) {
+        // Existing declarations on NPM may not be using the new `dependencies` merged field, and may
+        // have separate fields for dependencies instead. Unify them for JIT compilation.
+        decl.components &&
+            declarations.push(...decl.components.map(dir => convertDirectiveDeclarationToMetadata(dir, /* isComponent */ true)));
+        decl.directives &&
+            declarations.push(...decl.directives.map(dir => convertDirectiveDeclarationToMetadata(dir)));
+        decl.pipes && declarations.push(...convertPipeMapToMetadata(decl.pipes));
+    }
+    return Object.assign(Object.assign({}, convertDeclareDirectiveFacadeToMetadata(decl, typeSourceSpan)), { template, styles: (_b = decl.styles) !== null && _b !== void 0 ? _b : [], declarations, viewProviders: decl.viewProviders !== undefined ? new WrappedNodeExpr(decl.viewProviders) :
+            null, animations: decl.animations !== undefined ? new WrappedNodeExpr(decl.animations) : null, changeDetection: (_c = decl.changeDetection) !== null && _c !== void 0 ? _c : exports.ChangeDetectionStrategy.Default, encapsulation: (_d = decl.encapsulation) !== null && _d !== void 0 ? _d : exports.ViewEncapsulation.Emulated, interpolation, declarationListEmitMode: 2 /* DeclarationListEmitMode.ClosureResolved */, relativeContextFilePath: '', i18nUseExternalIds: true });
+}
+function convertDeclarationFacadeToMetadata(declaration) {
+    return Object.assign(Object.assign({}, declaration), { type: new WrappedNodeExpr(declaration.type) });
+}
+function convertDirectiveDeclarationToMetadata(declaration, isComponent = null) {
     var _a, _b, _c;
     return {
+        kind: exports.R3TemplateDependencyKind.Directive,
+        isComponent: isComponent || declaration.kind === 'component',
         selector: declaration.selector,
         type: new WrappedNodeExpr(declaration.type),
         inputs: (_a = declaration.inputs) !== null && _a !== void 0 ? _a : [],
@@ -19449,16 +19549,24 @@ function convertUsedDirectiveDeclarationToMetadata(declaration) {
         exportAs: (_c = declaration.exportAs) !== null && _c !== void 0 ? _c : null,
     };
 }
-function convertUsedPipesToMetadata(declaredPipes) {
-    const pipes = new Map();
-    if (declaredPipes === undefined) {
-        return pipes;
-    }
-    for (const pipeName of Object.keys(declaredPipes)) {
-        const pipeType = declaredPipes[pipeName];
-        pipes.set(pipeName, new WrappedNodeExpr(pipeType));
+function convertPipeMapToMetadata(pipes) {
+    if (!pipes) {
+        return [];
     }
-    return pipes;
+    return Object.keys(pipes).map(name => {
+        return {
+            kind: exports.R3TemplateDependencyKind.Pipe,
+            name,
+            type: new WrappedNodeExpr(pipes[name]),
+        };
+    });
+}
+function convertPipeDeclarationToMetadata(pipe) {
+    return {
+        kind: exports.R3TemplateDependencyKind.Pipe,
+        name: pipe.name,
+        type: new WrappedNodeExpr(pipe.type),
+    };
 }
 function parseJitTemplate(template, typeName, sourceMapUrl, preserveWhitespaces, interpolation) {
     const interpolationConfig = interpolation ? InterpolationConfig.fromArray(interpolation) : DEFAULT_INTERPOLATION_CONFIG;
@@ -19480,7 +19588,7 @@ function parseJitTemplate(template, typeName, sourceMapUrl, preserveWhitespaces,
  */
 function convertToProviderExpression(obj, property) {
     if (obj.hasOwnProperty(property)) {
-        return createMayBeForwardRefExpression(new WrappedNodeExpr(obj[property]), 0 /* None */);
+        return createMayBeForwardRefExpression(new WrappedNodeExpr(obj[property]), 0 /* ForwardRefHandling.None */);
     }
     else {
         return undefined;
@@ -19498,7 +19606,7 @@ function computeProvidedIn(providedIn) {
     const expression = typeof providedIn === 'function' ? new WrappedNodeExpr(providedIn) :
         new LiteralExpr(providedIn !== null && providedIn !== void 0 ? providedIn : null);
     // See `convertToProviderExpression()` for why this uses `ForwardRefHandling.None`.
-    return createMayBeForwardRefExpression(expression, 0 /* None */);
+    return createMayBeForwardRefExpression(expression, 0 /* ForwardRefHandling.None */);
 }
 function convertR3DependencyMetadataArray(facades) {
     return facades == null ? null : facades.map(convertR3DependencyMetadata);
@@ -19571,7 +19679,7 @@ function parseInputOutputs(values) {
     }, {});
 }
 function convertDeclarePipeFacadeToMetadata(declaration) {
-    var _a;
+    var _a, _b;
     return {
         name: declaration.type.name,
         type: wrapReference(declaration.type),
@@ -19580,6 +19688,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) {
@@ -19606,7 +19715,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('13.3.1');
+const VERSION = new Version('14.0.0');
 
 /**
  * @license
@@ -21633,7 +21742,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('13.3.1'));
+    definitionMap.set('version', literal('14.0.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -21733,7 +21842,7 @@ function compileDependency(dep) {
  *
  * Do not include any prerelease in these versions as they are ignored.
  */
-const MINIMUM_PARTIAL_LINKER_VERSION$5 = '12.0.0';
+const MINIMUM_PARTIAL_LINKER_VERSION$5 = '14.0.0';
 /**
  * Compile a directive declaration defined by the `R3DirectiveMetadata`.
  */
@@ -21750,9 +21859,12 @@ function compileDeclareDirectiveFromMetadata(meta) {
 function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('13.3.1'));
+    definitionMap.set('version', literal('14.0.0'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.internalType);
+    if (meta.isStandalone) {
+        definitionMap.set('isStandalone', literal(meta.isStandalone));
+    }
     // e.g. `selector: 'some-dir'`
     if (meta.selector !== null) {
         definitionMap.set('selector', literal(meta.selector));
@@ -21854,9 +21966,7 @@ function createComponentDefinitionMap(meta, template, templateInfo) {
         definitionMap.set('isInline', literal(true));
     }
     definitionMap.set('styles', toOptionalLiteralArray(meta.styles, literal));
-    definitionMap.set('components', compileUsedDirectiveMetadata(meta, directive => directive.isComponent === true));
-    definitionMap.set('directives', compileUsedDirectiveMetadata(meta, directive => directive.isComponent !== true));
-    definitionMap.set('pipes', compileUsedPipeMetadata(meta));
+    definitionMap.set('dependencies', compileUsedDependenciesMetadata(meta));
     definitionMap.set('viewProviders', meta.viewProviders);
     definitionMap.set('animations', meta.animations);
     if (meta.changeDetection !== undefined) {
@@ -21912,43 +22022,35 @@ function computeEndLocation(file, contents) {
     } while (lineStart !== -1);
     return new ParseLocation(file, length, line, length - lastLineStart);
 }
-/**
- * Compiles the directives as registered in the component metadata into an array literal of the
- * individual directives. If the component does not use any directives, then null is returned.
- */
-function compileUsedDirectiveMetadata(meta, predicate) {
-    const wrapType = meta.declarationListEmitMode !== 0 /* Direct */ ?
+function compileUsedDependenciesMetadata(meta) {
+    const wrapType = meta.declarationListEmitMode !== 0 /* DeclarationListEmitMode.Direct */ ?
         generateForwardRef :
         (expr) => expr;
-    const directives = meta.directives.filter(predicate);
-    return toOptionalLiteralArray(directives, directive => {
-        const dirMeta = new DefinitionMap();
-        dirMeta.set('type', wrapType(directive.type));
-        dirMeta.set('selector', literal(directive.selector));
-        dirMeta.set('inputs', toOptionalLiteralArray(directive.inputs, literal));
-        dirMeta.set('outputs', toOptionalLiteralArray(directive.outputs, literal));
-        dirMeta.set('exportAs', toOptionalLiteralArray(directive.exportAs, literal));
-        return dirMeta.toLiteralMap();
+    return toOptionalLiteralArray(meta.declarations, decl => {
+        switch (decl.kind) {
+            case exports.R3TemplateDependencyKind.Directive:
+                const dirMeta = new DefinitionMap();
+                dirMeta.set('kind', literal(decl.isComponent ? 'component' : 'directive'));
+                dirMeta.set('type', wrapType(decl.type));
+                dirMeta.set('selector', literal(decl.selector));
+                dirMeta.set('inputs', toOptionalLiteralArray(decl.inputs, literal));
+                dirMeta.set('outputs', toOptionalLiteralArray(decl.outputs, literal));
+                dirMeta.set('exportAs', toOptionalLiteralArray(decl.exportAs, literal));
+                return dirMeta.toLiteralMap();
+            case exports.R3TemplateDependencyKind.Pipe:
+                const pipeMeta = new DefinitionMap();
+                pipeMeta.set('kind', literal('pipe'));
+                pipeMeta.set('type', wrapType(decl.type));
+                pipeMeta.set('name', literal(decl.name));
+                return pipeMeta.toLiteralMap();
+            case exports.R3TemplateDependencyKind.NgModule:
+                const ngModuleMeta = new DefinitionMap();
+                ngModuleMeta.set('kind', literal('ngmodule'));
+                ngModuleMeta.set('type', wrapType(decl.type));
+                return ngModuleMeta.toLiteralMap();
+        }
     });
 }
-/**
- * Compiles the pipes as registered in the component metadata into an object literal, where the
- * pipe's name is used as key and a reference to its type as value. If the component does not use
- * any pipes, then null is returned.
- */
-function compileUsedPipeMetadata(meta) {
-    if (meta.pipes.size === 0) {
-        return null;
-    }
-    const wrapType = meta.declarationListEmitMode !== 0 /* Direct */ ?
-        generateForwardRef :
-        (expr) => expr;
-    const entries = [];
-    for (const [name, pipe] of meta.pipes) {
-        entries.push({ key: name, value: wrapType(pipe), quoted: true });
-    }
-    return literalMap(entries);
-}
 
 /**
  * @license
@@ -21968,7 +22070,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('13.3.1'));
+    definitionMap.set('version', literal('14.0.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -22010,7 +22112,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('13.3.1'));
+    definitionMap.set('version', literal('14.0.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     // Only generate providedIn property if it has a non-null value
@@ -22068,7 +22170,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('13.3.1'));
+    definitionMap.set('version', literal('14.0.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     definitionMap.set('providers', meta.providers);
@@ -22092,7 +22194,7 @@ function createInjectorDefinitionMap(meta) {
  *
  * Do not include any prerelease in these versions as they are ignored.
  */
-const MINIMUM_PARTIAL_LINKER_VERSION$1 = '12.0.0';
+const MINIMUM_PARTIAL_LINKER_VERSION$1 = '14.0.0';
 function compileDeclareNgModuleFromMetadata(meta) {
     const definitionMap = createNgModuleDefinitionMap(meta);
     const expression = importExpr(Identifiers.declareNgModule).callFn([definitionMap.toLiteralMap()]);
@@ -22105,7 +22207,7 @@ function compileDeclareNgModuleFromMetadata(meta) {
 function createNgModuleDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('13.3.1'));
+    definitionMap.set('version', literal('14.0.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -22147,7 +22249,7 @@ function createNgModuleDefinitionMap(meta) {
  *
  * Do not include any prerelease in these versions as they are ignored.
  */
-const MINIMUM_PARTIAL_LINKER_VERSION = '12.0.0';
+const MINIMUM_PARTIAL_LINKER_VERSION = '14.0.0';
 /**
  * Compile a Pipe declaration defined by the `R3PipeMetadata`.
  */
@@ -22163,10 +22265,13 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('13.3.1'));
+    definitionMap.set('version', literal('14.0.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.internalType);
+    if (meta.isStandalone) {
+        definitionMap.set('isStandalone', literal(meta.isStandalone));
+    }
     // e.g. `name: "myPipe"`
     definitionMap.set('name', literal(meta.pipeName));
     if (meta.pure === false) {
@@ -22273,7 +22378,6 @@ exports.ParserError = ParserError;
 exports.PrefixNot = PrefixNot;
 exports.PropertyRead = PropertyRead;
 exports.PropertyWrite = PropertyWrite;
-exports.Quote = Quote;
 exports.R3BoundTarget = R3BoundTarget;
 exports.R3Identifiers = Identifiers;
 exports.R3TargetBinder = R3TargetBinder;