@angular/language-service 12.2.6 → 12.2.7

package/bundles/ivy.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.2.6
+ * @license Angular v12.2.7
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -8443,7 +8443,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     const _polyfillHostRe = /-shadowcsshost/gim;
     const _colonHostRe = /:host/gim;
     const _colonHostContextRe = /:host-context/gim;
-    const _commentRe = /\/\*\s*[\s\S]*?\*\//g;
+    const _commentRe = /\/\*[\s\S]*?\*\//g;
     function stripComments(input) {
         return input.replace(_commentRe, '');
     }
@@ -8654,9 +8654,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
     }
     class Text$2 extends NodeWithI18n {
-        constructor(value, sourceSpan, i18n) {
+        constructor(value, sourceSpan, tokens, i18n) {
             super(sourceSpan, i18n);
             this.value = value;
+            this.tokens = tokens;
         }
         visit(visitor, context) {
             return visitor.visitText(this, context);
@@ -8687,12 +8688,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
     }
     class Attribute extends NodeWithI18n {
-        constructor(name, value, sourceSpan, keySpan, valueSpan, i18n) {
+        constructor(name, value, sourceSpan, keySpan, valueSpan, valueTokens, i18n) {
             super(sourceSpan, i18n);
             this.name = name;
             this.value = value;
             this.keySpan = keySpan;
             this.valueSpan = valueSpan;
+            this.valueTokens = valueTokens;
         }
         visit(visitor, context) {
             return visitor.visitAttribute(this, context);
@@ -10884,38 +10886,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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
      */
-    var TokenType;
-    (function (TokenType) {
-        TokenType[TokenType["TAG_OPEN_START"] = 0] = "TAG_OPEN_START";
-        TokenType[TokenType["TAG_OPEN_END"] = 1] = "TAG_OPEN_END";
-        TokenType[TokenType["TAG_OPEN_END_VOID"] = 2] = "TAG_OPEN_END_VOID";
-        TokenType[TokenType["TAG_CLOSE"] = 3] = "TAG_CLOSE";
-        TokenType[TokenType["INCOMPLETE_TAG_OPEN"] = 4] = "INCOMPLETE_TAG_OPEN";
-        TokenType[TokenType["TEXT"] = 5] = "TEXT";
-        TokenType[TokenType["ESCAPABLE_RAW_TEXT"] = 6] = "ESCAPABLE_RAW_TEXT";
-        TokenType[TokenType["RAW_TEXT"] = 7] = "RAW_TEXT";
-        TokenType[TokenType["COMMENT_START"] = 8] = "COMMENT_START";
-        TokenType[TokenType["COMMENT_END"] = 9] = "COMMENT_END";
-        TokenType[TokenType["CDATA_START"] = 10] = "CDATA_START";
-        TokenType[TokenType["CDATA_END"] = 11] = "CDATA_END";
-        TokenType[TokenType["ATTR_NAME"] = 12] = "ATTR_NAME";
-        TokenType[TokenType["ATTR_QUOTE"] = 13] = "ATTR_QUOTE";
-        TokenType[TokenType["ATTR_VALUE"] = 14] = "ATTR_VALUE";
-        TokenType[TokenType["DOC_TYPE"] = 15] = "DOC_TYPE";
-        TokenType[TokenType["EXPANSION_FORM_START"] = 16] = "EXPANSION_FORM_START";
-        TokenType[TokenType["EXPANSION_CASE_VALUE"] = 17] = "EXPANSION_CASE_VALUE";
-        TokenType[TokenType["EXPANSION_CASE_EXP_START"] = 18] = "EXPANSION_CASE_EXP_START";
-        TokenType[TokenType["EXPANSION_CASE_EXP_END"] = 19] = "EXPANSION_CASE_EXP_END";
-        TokenType[TokenType["EXPANSION_FORM_END"] = 20] = "EXPANSION_FORM_END";
-        TokenType[TokenType["EOF"] = 21] = "EOF";
-    })(TokenType || (TokenType = {}));
-    class Token {
-        constructor(type, parts, sourceSpan) {
-            this.type = type;
-            this.parts = parts;
-            this.sourceSpan = sourceSpan;
-        }
-    }
     class TokenError extends ParseError {
         constructor(errorMsg, tokenType, span) {
             super(span, errorMsg);
@@ -11022,14 +10992,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                         }
                     }
                     else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {
-                        this._consumeText();
+                        // 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());
                     }
                 }
                 catch (e) {
                     this.handleError(e);
                 }
             }
-            this._beginToken(TokenType.EOF);
+            this._beginToken(24 /* EOF */);
             this._endToken([]);
         }
         /**
@@ -11068,7 +11040,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (this._currentTokenType === null) {
                 throw new TokenError('Programming error - attempted to end a token which has no token type', null, this._cursor.getSpan(this._currentTokenStart));
             }
-            const token = new Token(this._currentTokenType, parts, this._cursor.getSpan(this._currentTokenStart, this._leadingTriviaCodePoints));
+            const token = {
+                type: this._currentTokenType,
+                parts,
+                sourceSpan: (end !== null && end !== void 0 ? end : this._cursor).getSpan(this._currentTokenStart, this._leadingTriviaCodePoints),
+            };
             this.tokens.push(token);
             this._currentTokenStart = null;
             this._currentTokenType = null;
@@ -11161,19 +11137,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 this._cursor.advance();
             }
         }
-        _readChar(decodeEntities) {
-            if (decodeEntities && this._cursor.peek() === $AMPERSAND) {
-                return this._decodeEntity();
-            }
-            else {
-                // Don't rely upon reading directly from `_input` as the actual char value
-                // may have been generated from an escape sequence.
-                const char = String.fromCodePoint(this._cursor.peek());
-                this._cursor.advance();
-                return char;
-            }
+        _readChar() {
+            // Don't rely upon reading directly from `_input` as the actual char value
+            // may have been generated from an escape sequence.
+            const char = String.fromCodePoint(this._cursor.peek());
+            this._cursor.advance();
+            return char;
         }
-        _decodeEntity() {
+        _consumeEntity(textTokenType) {
+            this._beginToken(9 /* ENCODED_ENTITY */);
             const start = this._cursor.clone();
             this._cursor.advance();
             if (this._attemptCharCode($HASH)) {
@@ -11191,7 +11163,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 this._cursor.advance();
                 try {
                     const charCode = parseInt(strNum, isHex ? 16 : 10);
-                    return String.fromCharCode(charCode);
+                    this._endToken([String.fromCharCode(charCode), this._cursor.getChars(start)]);
                 }
                 catch (_a) {
                     throw this._createError(_unknownEntityErrorMsg(this._cursor.getChars(start)), this._cursor.getSpan());
@@ -11201,20 +11173,25 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 const nameStart = this._cursor.clone();
                 this._attemptCharCodeUntilFn(isNamedEntityEnd);
                 if (this._cursor.peek() != $SEMICOLON) {
+                    // No semicolon was found so abort the encoded entity token that was in progress, and treat
+                    // this as a text token
+                    this._beginToken(textTokenType, start);
                     this._cursor = nameStart;
-                    return '&';
+                    this._endToken(['&']);
                 }
-                const name = this._cursor.getChars(nameStart);
-                this._cursor.advance();
-                const char = NAMED_ENTITIES[name];
-                if (!char) {
-                    throw this._createError(_unknownEntityErrorMsg(name), this._cursor.getSpan(start));
+                else {
+                    const name = this._cursor.getChars(nameStart);
+                    this._cursor.advance();
+                    const char = NAMED_ENTITIES[name];
+                    if (!char) {
+                        throw this._createError(_unknownEntityErrorMsg(name), this._cursor.getSpan(start));
+                    }
+                    this._endToken([char, `&${name};`]);
                 }
-                return char;
             }
         }
-        _consumeRawText(decodeEntities, endMarkerPredicate) {
-            this._beginToken(decodeEntities ? TokenType.ESCAPABLE_RAW_TEXT : TokenType.RAW_TEXT);
+        _consumeRawText(consumeEntities, endMarkerPredicate) {
+            this._beginToken(consumeEntities ? 6 /* ESCAPABLE_RAW_TEXT */ : 7 /* RAW_TEXT */);
             const parts = [];
             while (true) {
                 const tagCloseStart = this._cursor.clone();
@@ -11223,30 +11200,38 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 if (foundEndMarker) {
                     break;
                 }
-                parts.push(this._readChar(decodeEntities));
+                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 */);
+                }
+                else {
+                    parts.push(this._readChar());
+                }
             }
-            return this._endToken([this._processCarriageReturns(parts.join(''))]);
+            this._endToken([this._processCarriageReturns(parts.join(''))]);
         }
         _consumeComment(start) {
-            this._beginToken(TokenType.COMMENT_START, start);
+            this._beginToken(10 /* COMMENT_START */, start);
             this._requireCharCode($MINUS);
             this._endToken([]);
             this._consumeRawText(false, () => this._attemptStr('-->'));
-            this._beginToken(TokenType.COMMENT_END);
+            this._beginToken(11 /* COMMENT_END */);
             this._requireStr('-->');
             this._endToken([]);
         }
         _consumeCdata(start) {
-            this._beginToken(TokenType.CDATA_START, start);
+            this._beginToken(12 /* CDATA_START */, start);
             this._requireStr('CDATA[');
             this._endToken([]);
             this._consumeRawText(false, () => this._attemptStr(']]>'));
-            this._beginToken(TokenType.CDATA_END);
+            this._beginToken(13 /* CDATA_END */);
             this._requireStr(']]>');
             this._endToken([]);
         }
         _consumeDocType(start) {
-            this._beginToken(TokenType.DOC_TYPE, start);
+            this._beginToken(18 /* DOC_TYPE */, start);
             const contentStart = this._cursor.clone();
             this._attemptUntilChar($GT);
             const content = this._cursor.getChars(contentStart);
@@ -11300,12 +11285,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 if (e instanceof _ControlFlowError) {
                     if (openTagToken) {
                         // We errored before we could close the opening tag, so it is incomplete.
-                        openTagToken.type = TokenType.INCOMPLETE_TAG_OPEN;
+                        openTagToken.type = 4 /* 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(TokenType.TEXT, start);
+                        this._beginToken(5 /* TEXT */, start);
                         this._endToken(['<']);
                     }
                     return;
@@ -11320,8 +11305,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 this._consumeRawTextWithTagClose(prefix, tagName, true);
             }
         }
-        _consumeRawTextWithTagClose(prefix, tagName, decodeEntities) {
-            this._consumeRawText(decodeEntities, () => {
+        _consumeRawTextWithTagClose(prefix, tagName, consumeEntities) {
+            this._consumeRawText(consumeEntities, () => {
                 if (!this._attemptCharCode($LT))
                     return false;
                 if (!this._attemptCharCode($SLASH))
@@ -11332,13 +11317,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 this._attemptCharCodeUntilFn(isNotWhitespace);
                 return this._attemptCharCode($GT);
             });
-            this._beginToken(TokenType.TAG_CLOSE);
+            this._beginToken(3 /* TAG_CLOSE */);
             this._requireCharCodeUntilFn(code => code === $GT, 3);
             this._cursor.advance(); // Consume the `>`
             this._endToken([prefix, tagName]);
         }
         _consumeTagOpenStart(start) {
-            this._beginToken(TokenType.TAG_OPEN_START, start);
+            this._beginToken(0 /* TAG_OPEN_START */, start);
             const parts = this._consumePrefixAndName();
             return this._endToken(parts);
         }
@@ -11347,44 +11332,38 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (attrNameStart === $SQ || attrNameStart === $DQ) {
                 throw this._createError(_unexpectedCharacterErrorMsg(attrNameStart), this._cursor.getSpan());
             }
-            this._beginToken(TokenType.ATTR_NAME);
+            this._beginToken(14 /* ATTR_NAME */);
             const prefixAndName = this._consumePrefixAndName();
             this._endToken(prefixAndName);
         }
         _consumeAttributeValue() {
-            let value;
             if (this._cursor.peek() === $SQ || this._cursor.peek() === $DQ) {
-                this._beginToken(TokenType.ATTR_QUOTE);
                 const quoteChar = this._cursor.peek();
-                this._cursor.advance();
-                this._endToken([String.fromCodePoint(quoteChar)]);
-                this._beginToken(TokenType.ATTR_VALUE);
-                const parts = [];
-                while (this._cursor.peek() !== quoteChar) {
-                    parts.push(this._readChar(true));
-                }
-                value = parts.join('');
-                this._endToken([this._processCarriageReturns(value)]);
-                this._beginToken(TokenType.ATTR_QUOTE);
-                this._cursor.advance();
-                this._endToken([String.fromCodePoint(quoteChar)]);
+                this._consumeQuote(quoteChar);
+                // 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._consumeQuote(quoteChar);
             }
             else {
-                this._beginToken(TokenType.ATTR_VALUE);
-                const valueStart = this._cursor.clone();
-                this._requireCharCodeUntilFn(isNameEnd, 1);
-                value = this._cursor.getChars(valueStart);
-                this._endToken([this._processCarriageReturns(value)]);
+                const endPredicate = () => isNameEnd(this._cursor.peek());
+                this._consumeWithInterpolation(16 /* ATTR_VALUE_TEXT */, 17 /* ATTR_VALUE_INTERPOLATION */, endPredicate, endPredicate);
             }
         }
+        _consumeQuote(quoteChar) {
+            this._beginToken(15 /* ATTR_QUOTE */);
+            this._requireCharCode(quoteChar);
+            this._endToken([String.fromCodePoint(quoteChar)]);
+        }
         _consumeTagOpenEnd() {
-            const tokenType = this._attemptCharCode($SLASH) ? TokenType.TAG_OPEN_END_VOID : TokenType.TAG_OPEN_END;
+            const tokenType = this._attemptCharCode($SLASH) ? 2 /* TAG_OPEN_END_VOID */ : 1 /* TAG_OPEN_END */;
             this._beginToken(tokenType);
             this._requireCharCode($GT);
             this._endToken([]);
         }
         _consumeTagClose(start) {
-            this._beginToken(TokenType.TAG_CLOSE, start);
+            this._beginToken(3 /* TAG_CLOSE */, start);
             this._attemptCharCodeUntilFn(isNotWhitespace);
             const prefixAndName = this._consumePrefixAndName();
             this._attemptCharCodeUntilFn(isNotWhitespace);
@@ -11392,11 +11371,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this._endToken(prefixAndName);
         }
         _consumeExpansionFormStart() {
-            this._beginToken(TokenType.EXPANSION_FORM_START);
+            this._beginToken(19 /* EXPANSION_FORM_START */);
             this._requireCharCode($LBRACE);
             this._endToken([]);
-            this._expansionCaseStack.push(TokenType.EXPANSION_FORM_START);
-            this._beginToken(TokenType.RAW_TEXT);
+            this._expansionCaseStack.push(19 /* EXPANSION_FORM_START */);
+            this._beginToken(7 /* RAW_TEXT */);
             const condition = this._readUntil($COMMA);
             const normalizedCondition = this._processCarriageReturns(condition);
             if (this._i18nNormalizeLineEndingsInICUs) {
@@ -11412,59 +11391,139 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             this._requireCharCode($COMMA);
             this._attemptCharCodeUntilFn(isNotWhitespace);
-            this._beginToken(TokenType.RAW_TEXT);
+            this._beginToken(7 /* RAW_TEXT */);
             const type = this._readUntil($COMMA);
             this._endToken([type]);
             this._requireCharCode($COMMA);
             this._attemptCharCodeUntilFn(isNotWhitespace);
         }
         _consumeExpansionCaseStart() {
-            this._beginToken(TokenType.EXPANSION_CASE_VALUE);
+            this._beginToken(20 /* EXPANSION_CASE_VALUE */);
             const value = this._readUntil($LBRACE).trim();
             this._endToken([value]);
             this._attemptCharCodeUntilFn(isNotWhitespace);
-            this._beginToken(TokenType.EXPANSION_CASE_EXP_START);
+            this._beginToken(21 /* EXPANSION_CASE_EXP_START */);
             this._requireCharCode($LBRACE);
             this._endToken([]);
             this._attemptCharCodeUntilFn(isNotWhitespace);
-            this._expansionCaseStack.push(TokenType.EXPANSION_CASE_EXP_START);
+            this._expansionCaseStack.push(21 /* EXPANSION_CASE_EXP_START */);
         }
         _consumeExpansionCaseEnd() {
-            this._beginToken(TokenType.EXPANSION_CASE_EXP_END);
+            this._beginToken(22 /* EXPANSION_CASE_EXP_END */);
             this._requireCharCode($RBRACE);
             this._endToken([]);
             this._attemptCharCodeUntilFn(isNotWhitespace);
             this._expansionCaseStack.pop();
         }
         _consumeExpansionFormEnd() {
-            this._beginToken(TokenType.EXPANSION_FORM_END);
+            this._beginToken(23 /* EXPANSION_FORM_END */);
             this._requireCharCode($RBRACE);
             this._endToken([]);
             this._expansionCaseStack.pop();
         }
-        _consumeText() {
-            const start = this._cursor.clone();
-            this._beginToken(TokenType.TEXT, start);
+        /**
+         * Consume a string that may contain interpolation expressions.
+         *
+         * The first token consumed will be of `tokenType` and then there will be alternating
+         * `interpolationTokenType` and `tokenType` tokens until the `endPredicate()` returns true.
+         *
+         * If an interpolation token ends prematurely it will have no end marker in its `parts` array.
+         *
+         * @param textTokenType the kind of tokens to interleave around interpolation tokens.
+         * @param interpolationTokenType the kind of tokens that contain interpolation.
+         * @param endPredicate a function that should return true when we should stop consuming.
+         * @param endInterpolation a function that should return true if there is a premature end to an
+         *     interpolation expression - i.e. before we get to the normal interpolation closing marker.
+         */
+        _consumeWithInterpolation(textTokenType, interpolationTokenType, endPredicate, endInterpolation) {
+            this._beginToken(textTokenType);
             const parts = [];
-            do {
+            while (!endPredicate()) {
+                const current = this._cursor.clone();
                 if (this._interpolationConfig && this._attemptStr(this._interpolationConfig.start)) {
-                    parts.push(this._interpolationConfig.start);
-                    this._inInterpolation = true;
+                    this._endToken([this._processCarriageReturns(parts.join(''))], current);
+                    parts.length = 0;
+                    this._consumeInterpolation(interpolationTokenType, current, endInterpolation);
+                    this._beginToken(textTokenType);
                 }
-                else if (this._interpolationConfig && this._inInterpolation &&
-                    this._attemptStr(this._interpolationConfig.end)) {
-                    parts.push(this._interpolationConfig.end);
-                    this._inInterpolation = false;
+                else if (this._cursor.peek() === $AMPERSAND) {
+                    this._endToken([this._processCarriageReturns(parts.join(''))]);
+                    parts.length = 0;
+                    this._consumeEntity(textTokenType);
+                    this._beginToken(textTokenType);
                 }
                 else {
-                    parts.push(this._readChar(true));
+                    parts.push(this._readChar());
                 }
-            } while (!this._isTextEnd());
+            }
             // It is possible that an interpolation was started but not ended inside this text token.
             // Make sure that we reset the state of the lexer correctly.
             this._inInterpolation = false;
             this._endToken([this._processCarriageReturns(parts.join(''))]);
         }
+        /**
+         * Consume a block of text that has been interpreted as an Angular interpolation.
+         *
+         * @param interpolationTokenType the type of the interpolation token to generate.
+         * @param interpolationStart a cursor that points to the start of this interpolation.
+         * @param prematureEndPredicate a function that should return true if the next characters indicate
+         *     an end to the interpolation before its normal closing marker.
+         */
+        _consumeInterpolation(interpolationTokenType, interpolationStart, prematureEndPredicate) {
+            const parts = [];
+            this._beginToken(interpolationTokenType, interpolationStart);
+            parts.push(this._interpolationConfig.start);
+            // Find the end of the interpolation, ignoring content inside quotes.
+            const expressionStart = this._cursor.clone();
+            let inQuote = null;
+            let inComment = false;
+            while (this._cursor.peek() !== $EOF &&
+                (prematureEndPredicate === null || !prematureEndPredicate())) {
+                const current = this._cursor.clone();
+                if (this._isTagStart()) {
+                    // We are starting what looks like an HTML element in the middle of this interpolation.
+                    // Reset the cursor to before the `<` character and end the interpolation token.
+                    // (This is actually wrong but here for backward compatibility).
+                    this._cursor = current;
+                    parts.push(this._getProcessedChars(expressionStart, current));
+                    this._endToken(parts);
+                    return;
+                }
+                if (inQuote === null) {
+                    if (this._attemptStr(this._interpolationConfig.end)) {
+                        // We are not in a string, and we hit the end interpolation marker
+                        parts.push(this._getProcessedChars(expressionStart, current));
+                        parts.push(this._interpolationConfig.end);
+                        this._endToken(parts);
+                        return;
+                    }
+                    else if (this._attemptStr('//')) {
+                        // Once we are in a comment we ignore any quotes
+                        inComment = true;
+                    }
+                }
+                const char = this._cursor.peek();
+                this._cursor.advance();
+                if (char === $BACKSLASH) {
+                    // Skip the next character because it was escaped.
+                    this._cursor.advance();
+                }
+                else if (char === inQuote) {
+                    // Exiting the current quoted string
+                    inQuote = null;
+                }
+                else if (!inComment && inQuote === null && isQuote(char)) {
+                    // Entering a new quoted string
+                    inQuote = char;
+                }
+            }
+            // We hit EOF without finding a closing interpolation marker
+            parts.push(this._getProcessedChars(expressionStart, this._cursor));
+            this._endToken(parts);
+        }
+        _getProcessedChars(start, end) {
+            return this._processCarriageReturns(end.getChars(start));
+        }
         _isTextEnd() {
             if (this._isTagStart() || this._cursor.peek() === $EOF) {
                 return true;
@@ -11507,12 +11566,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         _isInExpansionCase() {
             return this._expansionCaseStack.length > 0 &&
                 this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
-                    TokenType.EXPANSION_CASE_EXP_START;
+                    21 /* EXPANSION_CASE_EXP_START */;
         }
         _isInExpansionForm() {
             return this._expansionCaseStack.length > 0 &&
                 this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
-                    TokenType.EXPANSION_FORM_START;
+                    19 /* EXPANSION_FORM_START */;
         }
         isExpansionFormStart() {
             if (this._cursor.peek() !== $LBRACE) {
@@ -11559,7 +11618,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         let lastDstToken = undefined;
         for (let i = 0; i < srcTokens.length; i++) {
             const token = srcTokens[i];
-            if (lastDstToken && lastDstToken.type === TokenType.TEXT && token.type === TokenType.TEXT) {
+            if ((lastDstToken && lastDstToken.type === 5 /* TEXT */ && token.type === 5 /* TEXT */) ||
+                (lastDstToken && lastDstToken.type === 16 /* ATTR_VALUE_TEXT */ &&
+                    token.type === 16 /* ATTR_VALUE_TEXT */)) {
                 lastDstToken.parts[0] += token.parts[0];
                 lastDstToken.sourceSpan.end = token.sourceSpan.end;
             }
@@ -11852,28 +11913,28 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this._advance();
         }
         build() {
-            while (this._peek.type !== TokenType.EOF) {
-                if (this._peek.type === TokenType.TAG_OPEN_START ||
-                    this._peek.type === TokenType.INCOMPLETE_TAG_OPEN) {
+            while (this._peek.type !== 24 /* EOF */) {
+                if (this._peek.type === 0 /* TAG_OPEN_START */ ||
+                    this._peek.type === 4 /* INCOMPLETE_TAG_OPEN */) {
                     this._consumeStartTag(this._advance());
                 }
-                else if (this._peek.type === TokenType.TAG_CLOSE) {
+                else if (this._peek.type === 3 /* TAG_CLOSE */) {
                     this._consumeEndTag(this._advance());
                 }
-                else if (this._peek.type === TokenType.CDATA_START) {
+                else if (this._peek.type === 12 /* CDATA_START */) {
                     this._closeVoidElement();
                     this._consumeCdata(this._advance());
                 }
-                else if (this._peek.type === TokenType.COMMENT_START) {
+                else if (this._peek.type === 10 /* COMMENT_START */) {
                     this._closeVoidElement();
                     this._consumeComment(this._advance());
                 }
-                else if (this._peek.type === TokenType.TEXT || this._peek.type === TokenType.RAW_TEXT ||
-                    this._peek.type === TokenType.ESCAPABLE_RAW_TEXT) {
+                else if (this._peek.type === 5 /* TEXT */ || this._peek.type === 7 /* RAW_TEXT */ ||
+                    this._peek.type === 6 /* ESCAPABLE_RAW_TEXT */) {
                     this._closeVoidElement();
                     this._consumeText(this._advance());
                 }
-                else if (this._peek.type === TokenType.EXPANSION_FORM_START) {
+                else if (this._peek.type === 19 /* EXPANSION_FORM_START */) {
                     this._consumeExpansion(this._advance());
                 }
                 else {
@@ -11899,11 +11960,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         _consumeCdata(_startToken) {
             this._consumeText(this._advance());
-            this._advanceIf(TokenType.CDATA_END);
+            this._advanceIf(13 /* CDATA_END */);
         }
         _consumeComment(token) {
-            const text = this._advanceIf(TokenType.RAW_TEXT);
-            this._advanceIf(TokenType.COMMENT_END);
+            const text = this._advanceIf(7 /* RAW_TEXT */);
+            this._advanceIf(11 /* COMMENT_END */);
             const value = text != null ? text.parts[0].trim() : null;
             this._addToParent(new Comment$1(value, token.sourceSpan));
         }
@@ -11912,14 +11973,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const type = this._advance();
             const cases = [];
             // read =
-            while (this._peek.type === TokenType.EXPANSION_CASE_VALUE) {
+            while (this._peek.type === 20 /* EXPANSION_CASE_VALUE */) {
                 const expCase = this._parseExpansionCase();
                 if (!expCase)
                     return; // error
                 cases.push(expCase);
             }
             // read the final }
-            if (this._peek.type !== TokenType.EXPANSION_FORM_END) {
+            if (this._peek.type !== 23 /* EXPANSION_FORM_END */) {
                 this.errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '}'.`));
                 return;
             }
@@ -11930,7 +11991,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         _parseExpansionCase() {
             const value = this._advance();
             // read {
-            if (this._peek.type !== TokenType.EXPANSION_CASE_EXP_START) {
+            if (this._peek.type !== 21 /* EXPANSION_CASE_EXP_START */) {
                 this.errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '{'.`));
                 return null;
             }
@@ -11940,7 +12001,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (!exp)
                 return null;
             const end = this._advance();
-            exp.push(new Token(TokenType.EOF, [], end.sourceSpan));
+            exp.push({ type: 24 /* EOF */, parts: [], sourceSpan: end.sourceSpan });
             // parse everything in between { and }
             const expansionCaseParser = new _TreeBuilder(exp, this.getTagDefinition);
             expansionCaseParser.build();
@@ -11954,14 +12015,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         _collectExpansionExpTokens(start) {
             const exp = [];
-            const expansionFormStack = [TokenType.EXPANSION_CASE_EXP_START];
+            const expansionFormStack = [21 /* EXPANSION_CASE_EXP_START */];
             while (true) {
-                if (this._peek.type === TokenType.EXPANSION_FORM_START ||
-                    this._peek.type === TokenType.EXPANSION_CASE_EXP_START) {
+                if (this._peek.type === 19 /* EXPANSION_FORM_START */ ||
+                    this._peek.type === 21 /* EXPANSION_CASE_EXP_START */) {
                     expansionFormStack.push(this._peek.type);
                 }
-                if (this._peek.type === TokenType.EXPANSION_CASE_EXP_END) {
-                    if (lastOnStack(expansionFormStack, TokenType.EXPANSION_CASE_EXP_START)) {
+                if (this._peek.type === 22 /* EXPANSION_CASE_EXP_END */) {
+                    if (lastOnStack(expansionFormStack, 21 /* EXPANSION_CASE_EXP_START */)) {
                         expansionFormStack.pop();
                         if (expansionFormStack.length === 0)
                             return exp;
@@ -11971,8 +12032,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                         return null;
                     }
                 }
-                if (this._peek.type === TokenType.EXPANSION_FORM_END) {
-                    if (lastOnStack(expansionFormStack, TokenType.EXPANSION_FORM_START)) {
+                if (this._peek.type === 23 /* EXPANSION_FORM_END */) {
+                    if (lastOnStack(expansionFormStack, 19 /* EXPANSION_FORM_START */)) {
                         expansionFormStack.pop();
                     }
                     else {
@@ -11980,7 +12041,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                         return null;
                     }
                 }
-                if (this._peek.type === TokenType.EOF) {
+                if (this._peek.type === 24 /* EOF */) {
                     this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
                     return null;
                 }
@@ -11988,16 +12049,38 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
         }
         _consumeText(token) {
+            const tokens = [token];
+            const startSpan = token.sourceSpan;
             let text = token.parts[0];
             if (text.length > 0 && text[0] === '\n') {
                 const parent = this._getParentElement();
                 if (parent != null && parent.children.length === 0 &&
                     this.getTagDefinition(parent.name).ignoreFirstLf) {
                     text = text.substring(1);
+                    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 */) {
+                token = this._advance();
+                tokens.push(token);
+                if (token.type === 8 /* 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 */) {
+                    text += token.parts[0];
+                }
+                else {
+                    text += token.parts.join('');
                 }
             }
             if (text.length > 0) {
-                this._addToParent(new Text$2(text, token.sourceSpan));
+                const endSpan = token.sourceSpan;
+                this._addToParent(new Text$2(text, new ParseSourceSpan(startSpan.start, endSpan.end, startSpan.fullStart, startSpan.details), tokens));
             }
         }
         _closeVoidElement() {
@@ -12009,14 +12092,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         _consumeStartTag(startTagToken) {
             const [prefix, name] = startTagToken.parts;
             const attrs = [];
-            while (this._peek.type === TokenType.ATTR_NAME) {
+            while (this._peek.type === 14 /* 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 === TokenType.TAG_OPEN_END_VOID) {
+            if (this._peek.type === 2 /* TAG_OPEN_END_VOID */) {
                 this._advance();
                 selfClosing = true;
                 const tagDef = this.getTagDefinition(fullName);
@@ -12024,7 +12107,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     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 === TokenType.TAG_OPEN_END) {
+            else if (this._peek.type === 1 /* TAG_OPEN_END */) {
                 this._advance();
                 selfClosing = false;
             }
@@ -12039,7 +12122,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 // element start tag also represents the end tag.
                 this._popElement(fullName, span);
             }
-            else if (startTagToken.type === TokenType.INCOMPLETE_TAG_OPEN) {
+            else if (startTagToken.type === 4 /* 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);
@@ -12094,24 +12177,53 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         _consumeAttr(attrName) {
             const fullName = mergeNsAndName(attrName.parts[0], attrName.parts[1]);
-            let end = attrName.sourceSpan.end;
-            let value = '';
-            let valueSpan = undefined;
-            if (this._peek.type === TokenType.ATTR_QUOTE) {
+            let attrEnd = attrName.sourceSpan.end;
+            // Consume any quote
+            if (this._peek.type === 15 /* ATTR_QUOTE */) {
                 this._advance();
             }
-            if (this._peek.type === TokenType.ATTR_VALUE) {
-                const valueToken = this._advance();
-                value = valueToken.parts[0];
-                end = valueToken.sourceSpan.end;
-                valueSpan = valueToken.sourceSpan;
+            // Consume the attribute value
+            let value = '';
+            const valueTokens = [];
+            let valueStartSpan = undefined;
+            let valueEnd = undefined;
+            // NOTE: We need to use a new variable `nextTokenType` here to hide the actual type of
+            // `_peek.type` from TS. Otherwise TS will narrow the type of `_peek.type` preventing it from
+            // 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 */) {
+                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 */) {
+                    const valueToken = this._advance();
+                    valueTokens.push(valueToken);
+                    if (valueToken.type === 17 /* 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 */) {
+                        value += valueToken.parts[0];
+                    }
+                    else {
+                        value += valueToken.parts.join('');
+                    }
+                    valueEnd = attrEnd = valueToken.sourceSpan.end;
+                }
             }
-            if (this._peek.type === TokenType.ATTR_QUOTE) {
+            // Consume any quote
+            if (this._peek.type === 15 /* ATTR_QUOTE */) {
                 const quoteToken = this._advance();
-                end = quoteToken.sourceSpan.end;
+                attrEnd = quoteToken.sourceSpan.end;
             }
-            const keySpan = new ParseSourceSpan(attrName.sourceSpan.start, attrName.sourceSpan.end);
-            return new Attribute(fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, end, attrName.sourceSpan.fullStart), keySpan, valueSpan);
+            const valueSpan = valueStartSpan && valueEnd &&
+                new ParseSourceSpan(valueStartSpan.start, valueEnd, valueStartSpan.fullStart);
+            return new Attribute(fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, attrEnd, attrName.sourceSpan.fullStart), attrName.sourceSpan, valueSpan, valueTokens.length > 0 ? valueTokens : undefined, undefined);
         }
         _getParentElement() {
             return this._elementStack.length > 0 ? this._elementStack[this._elementStack.length - 1] : null;
@@ -12142,6 +12254,23 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function lastOnStack(stack, element) {
         return stack.length > 0 && stack[stack.length - 1] === element;
     }
+    /**
+     * Decode the `entity` string, which we believe is the contents of an HTML entity.
+     *
+     * If the string is not actually a valid/known entity then just return the original `match` string.
+     */
+    function decodeEntity(match, entity) {
+        if (NAMED_ENTITIES[entity] !== undefined) {
+            return NAMED_ENTITIES[entity] || match;
+        }
+        if (/^#x[a-f0-9]+$/i.test(entity)) {
+            return String.fromCodePoint(parseInt(entity.slice(2), 16));
+        }
+        if (/^#\d+$/.test(entity)) {
+            return String.fromCodePoint(parseInt(entity.slice(1), 10));
+        }
+        return match;
+    }
 
     /**
      * @license
@@ -12217,7 +12346,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const hasExpansionSibling = context &&
                 (context.prev instanceof Expansion || context.next instanceof Expansion);
             if (isNotBlank || hasExpansionSibling) {
-                return new Text$2(replaceNgsp(text.value).replace(WS_REPLACE_REGEXP, ' '), text.sourceSpan, text.i18n);
+                // Process the whitespace in the tokens of this Text node
+                const tokens = text.tokens.map(token => token.type === 5 /* TEXT */ ? createWhitespaceProcessedTextToken(token) : token);
+                // Process the whitespace of the value of this Text node
+                const value = processWhitespace(text.value);
+                return new Text$2(value, text.sourceSpan, tokens, text.i18n);
             }
             return null;
         }
@@ -12231,6 +12364,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return expansionCase;
         }
     }
+    function createWhitespaceProcessedTextToken({ type, parts, sourceSpan }) {
+        return { type, parts: [processWhitespace(parts[0])], sourceSpan };
+    }
+    function processWhitespace(text) {
+        return replaceNgsp(text).replace(WS_REPLACE_REGEXP, ' ');
+    }
     function visitAllWithSiblings(visitor, nodes) {
         const result = [];
         nodes.forEach((ast, i) => {
@@ -13481,7 +13620,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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
      */
-    var TokenType$1;
+    var TokenType;
     (function (TokenType) {
         TokenType[TokenType["Character"] = 0] = "Character";
         TokenType[TokenType["Identifier"] = 1] = "Identifier";
@@ -13491,7 +13630,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         TokenType[TokenType["Operator"] = 5] = "Operator";
         TokenType[TokenType["Number"] = 6] = "Number";
         TokenType[TokenType["Error"] = 7] = "Error";
-    })(TokenType$1 || (TokenType$1 = {}));
+    })(TokenType || (TokenType = {}));
     const KEYWORDS = ['var', 'let', 'as', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];
     class Lexer {
         tokenize(text) {
@@ -13505,7 +13644,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return tokens;
         }
     }
-    class Token$1 {
+    class Token {
         constructor(index, end, type, numValue, strValue) {
             this.index = index;
             this.end = end;
@@ -13514,64 +13653,64 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.strValue = strValue;
         }
         isCharacter(code) {
-            return this.type == TokenType$1.Character && this.numValue == code;
+            return this.type == TokenType.Character && this.numValue == code;
         }
         isNumber() {
-            return this.type == TokenType$1.Number;
+            return this.type == TokenType.Number;
         }
         isString() {
-            return this.type == TokenType$1.String;
+            return this.type == TokenType.String;
         }
         isOperator(operator) {
-            return this.type == TokenType$1.Operator && this.strValue == operator;
+            return this.type == TokenType.Operator && this.strValue == operator;
         }
         isIdentifier() {
-            return this.type == TokenType$1.Identifier;
+            return this.type == TokenType.Identifier;
         }
         isPrivateIdentifier() {
-            return this.type == TokenType$1.PrivateIdentifier;
+            return this.type == TokenType.PrivateIdentifier;
         }
         isKeyword() {
-            return this.type == TokenType$1.Keyword;
+            return this.type == TokenType.Keyword;
         }
         isKeywordLet() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'let';
+            return this.type == TokenType.Keyword && this.strValue == 'let';
         }
         isKeywordAs() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'as';
+            return this.type == TokenType.Keyword && this.strValue == 'as';
         }
         isKeywordNull() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'null';
+            return this.type == TokenType.Keyword && this.strValue == 'null';
         }
         isKeywordUndefined() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'undefined';
+            return this.type == TokenType.Keyword && this.strValue == 'undefined';
         }
         isKeywordTrue() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'true';
+            return this.type == TokenType.Keyword && this.strValue == 'true';
         }
         isKeywordFalse() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'false';
+            return this.type == TokenType.Keyword && this.strValue == 'false';
         }
         isKeywordThis() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'this';
+            return this.type == TokenType.Keyword && this.strValue == 'this';
         }
         isError() {
-            return this.type == TokenType$1.Error;
+            return this.type == TokenType.Error;
         }
         toNumber() {
-            return this.type == TokenType$1.Number ? this.numValue : -1;
+            return this.type == TokenType.Number ? this.numValue : -1;
         }
         toString() {
             switch (this.type) {
-                case TokenType$1.Character:
-                case TokenType$1.Identifier:
-                case TokenType$1.Keyword:
-                case TokenType$1.Operator:
-                case TokenType$1.PrivateIdentifier:
-                case TokenType$1.String:
-                case TokenType$1.Error:
+                case TokenType.Character:
+                case TokenType.Identifier:
+                case TokenType.Keyword:
+                case TokenType.Operator:
+                case TokenType.PrivateIdentifier:
+                case TokenType.String:
+                case TokenType.Error:
                     return this.strValue;
-                case TokenType$1.Number:
+                case TokenType.Number:
                     return this.numValue.toString();
                 default:
                     return null;
@@ -13579,30 +13718,30 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
     }
     function newCharacterToken(index, end, code) {
-        return new Token$1(index, end, TokenType$1.Character, code, String.fromCharCode(code));
+        return new Token(index, end, TokenType.Character, code, String.fromCharCode(code));
     }
     function newIdentifierToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.Identifier, 0, text);
+        return new Token(index, end, TokenType.Identifier, 0, text);
     }
     function newPrivateIdentifierToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.PrivateIdentifier, 0, text);
+        return new Token(index, end, TokenType.PrivateIdentifier, 0, text);
     }
     function newKeywordToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.Keyword, 0, text);
+        return new Token(index, end, TokenType.Keyword, 0, text);
     }
     function newOperatorToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.Operator, 0, text);
+        return new Token(index, end, TokenType.Operator, 0, text);
     }
     function newStringToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.String, 0, text);
+        return new Token(index, end, TokenType.String, 0, text);
     }
     function newNumberToken(index, end, n) {
-        return new Token$1(index, end, TokenType$1.Number, n, '');
+        return new Token(index, end, TokenType.Number, n, '');
     }
     function newErrorToken(index, end, message) {
-        return new Token$1(index, end, TokenType$1.Error, 0, message);
+        return new Token(index, end, TokenType.Error, 0, message);
     }
-    const EOF = new Token$1(-1, -1, TokenType$1.Character, 0, '');
+    const EOF = new Token(-1, -1, TokenType.Character, 0, '');
     class _Scanner {
         constructor(input) {
             this.input = input;
@@ -14509,7 +14648,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             // '==','!=','===','!=='
             const start = this.inputIndex;
             let result = this.parseRelational();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '==':
@@ -14529,7 +14668,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             // '<', '>', '<=', '>='
             const start = this.inputIndex;
             let result = this.parseAdditive();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '<':
@@ -14549,7 +14688,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             // '+', '-'
             const start = this.inputIndex;
             let result = this.parseMultiplicative();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '+':
@@ -14567,7 +14706,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             // '*', '%', '/'
             const start = this.inputIndex;
             let result = this.parsePrefix();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '*':
@@ -14583,7 +14722,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return result;
         }
         parsePrefix() {
-            if (this.next.type == TokenType$1.Operator) {
+            if (this.next.type == TokenType.Operator) {
                 const start = this.inputIndex;
                 const operator = this.next.strValue;
                 let result;
@@ -16515,11 +16654,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return context.visitNodeFn(el, node);
         }
         visitAttribute(attribute, context) {
-            const node = this._visitTextWithInterpolation(attribute.value, attribute.valueSpan || attribute.sourceSpan, context, attribute.i18n);
+            const node = attribute.valueTokens === undefined || attribute.valueTokens.length === 1 ?
+                new Text$1(attribute.value, attribute.valueSpan || attribute.sourceSpan) :
+                this._visitTextWithInterpolation(attribute.valueTokens, attribute.valueSpan || attribute.sourceSpan, context, attribute.i18n);
             return context.visitNodeFn(attribute, node);
         }
         visitText(text, context) {
-            const node = this._visitTextWithInterpolation(text.value, text.sourceSpan, context, text.i18n);
+            const node = text.tokens.length === 1 ?
+                new Text$1(text.value, text.sourceSpan) :
+                this._visitTextWithInterpolation(text.tokens, text.sourceSpan, context, text.i18n);
             return context.visitNodeFn(text, node);
         }
         visitComment(comment, context) {
@@ -16558,61 +16701,58 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             throw new Error('Unreachable code');
         }
         /**
-         * Split the, potentially interpolated, text up into text and placeholder pieces.
+         * Convert, text and interpolated tokens up into text and placeholder pieces.
          *
-         * @param text The potentially interpolated string to be split.
+         * @param tokens The text and interpolated tokens.
          * @param sourceSpan The span of the whole of the `text` string.
          * @param context The current context of the visitor, used to compute and store placeholders.
          * @param previousI18n Any i18n metadata associated with this `text` from a previous pass.
          */
-        _visitTextWithInterpolation(text, sourceSpan, context, previousI18n) {
-            const { strings, expressions } = this._expressionParser.splitInterpolation(text, sourceSpan.start.toString(), this._interpolationConfig);
-            // No expressions, return a single text.
-            if (expressions.length === 0) {
-                return new Text$1(text, sourceSpan);
-            }
+        _visitTextWithInterpolation(tokens, sourceSpan, context, previousI18n) {
             // Return a sequence of `Text` and `Placeholder` nodes grouped in a `Container`.
             const nodes = [];
-            for (let i = 0; i < strings.length - 1; i++) {
-                this._addText(nodes, strings[i], sourceSpan);
-                this._addPlaceholder(nodes, context, expressions[i], sourceSpan);
+            // We will only create a container if there are actually interpolations,
+            // so this flag tracks that.
+            let hasInterpolation = false;
+            for (const token of tokens) {
+                switch (token.type) {
+                    case 8 /* INTERPOLATION */:
+                    case 17 /* ATTR_VALUE_INTERPOLATION */:
+                        hasInterpolation = true;
+                        const expression = token.parts[1];
+                        const baseName = extractPlaceholderName(expression) || 'INTERPOLATION';
+                        const phName = context.placeholderRegistry.getPlaceholderName(baseName, expression);
+                        context.placeholderToContent[phName] = {
+                            text: token.parts.join(''),
+                            sourceSpan: token.sourceSpan
+                        };
+                        nodes.push(new Placeholder(expression, phName, token.sourceSpan));
+                        break;
+                    default:
+                        if (token.parts[0].length > 0) {
+                            // This token is text or an encoded entity.
+                            // If it is following on from a previous text node then merge it into that node
+                            // Otherwise, if it is following an interpolation, then add a new node.
+                            const previous = nodes[nodes.length - 1];
+                            if (previous instanceof Text$1) {
+                                previous.value += token.parts[0];
+                                previous.sourceSpan = new ParseSourceSpan(previous.sourceSpan.start, token.sourceSpan.end, previous.sourceSpan.fullStart, previous.sourceSpan.details);
+                            }
+                            else {
+                                nodes.push(new Text$1(token.parts[0], token.sourceSpan));
+                            }
+                        }
+                        break;
+                }
             }
-            // The last index contains no expression
-            this._addText(nodes, strings[strings.length - 1], sourceSpan);
-            // Whitespace removal may have invalidated the interpolation source-spans.
-            reusePreviousSourceSpans(nodes, previousI18n);
-            return new Container(nodes, sourceSpan);
-        }
-        /**
-         * Create a new `Text` node from the `textPiece` and add it to the `nodes` collection.
-         *
-         * @param nodes The nodes to which the created `Text` node should be added.
-         * @param textPiece The text and relative span information for this `Text` node.
-         * @param interpolationSpan The span of the whole interpolated text.
-         */
-        _addText(nodes, textPiece, interpolationSpan) {
-            if (textPiece.text.length > 0) {
-                // No need to add empty strings
-                const stringSpan = getOffsetSourceSpan(interpolationSpan, textPiece);
-                nodes.push(new Text$1(textPiece.text, stringSpan));
+            if (hasInterpolation) {
+                // Whitespace removal may have invalidated the interpolation source-spans.
+                reusePreviousSourceSpans(nodes, previousI18n);
+                return new Container(nodes, sourceSpan);
+            }
+            else {
+                return nodes[0];
             }
-        }
-        /**
-         * Create a new `Placeholder` node from the `expression` and add it to the `nodes` collection.
-         *
-         * @param nodes The nodes to which the created `Text` node should be added.
-         * @param context The current context of the visitor, used to compute and store placeholders.
-         * @param expression The expression text and relative span information for this `Placeholder`
-         *     node.
-         * @param interpolationSpan The span of the whole interpolated text.
-         */
-        _addPlaceholder(nodes, context, expression, interpolationSpan) {
-            const sourceSpan = getOffsetSourceSpan(interpolationSpan, expression);
-            const baseName = extractPlaceholderName(expression.text) || 'INTERPOLATION';
-            const phName = context.placeholderRegistry.getPlaceholderName(baseName, expression.text);
-            const text = this._interpolationConfig.start + expression.text + this._interpolationConfig.end;
-            context.placeholderToContent[phName] = { text, sourceSpan };
-            nodes.push(new Placeholder(expression.text, phName, sourceSpan));
         }
     }
     /**
@@ -16634,7 +16774,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         if (previousI18n instanceof Container) {
             // The `previousI18n` is a `Container`, which means that this is a second i18n extraction pass
-            // after whitespace has been removed from the AST ndoes.
+            // after whitespace has been removed from the AST nodes.
             assertEquivalentNodes(previousI18n.children, nodes);
             // Reuse the source-spans from the first pass.
             for (let i = 0; i < nodes.length; i++) {
@@ -16663,12 +16803,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             throw new Error('The types of the i18n message children changed between first and second pass.');
         }
     }
-    /**
-     * Create a new `ParseSourceSpan` from the `sourceSpan`, offset by the `start` and `end` values.
-     */
-    function getOffsetSourceSpan(sourceSpan, { start, end }) {
-        return new ParseSourceSpan(sourceSpan.fullStart.moveBy(start), sourceSpan.fullStart.moveBy(end));
-    }
     const _CUSTOM_PH_EXP = /\/\/[\s\S]*i18n[\s\S]*\([\s\S]*ph[\s\S]*=[\s\S]*("|')([\s\S]*?)\1[\s\S]*\)/g;
     function extractPlaceholderName(input) {
         return input.split(_CUSTOM_PH_EXP)[2];
@@ -16988,7 +17122,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 context[context.length - 1].text += text.value;
             }
             else {
-                context.push(new LiteralPiece(text.value, text.sourceSpan));
+                const sourceSpan = new ParseSourceSpan(text.sourceSpan.fullStart, text.sourceSpan.end, text.sourceSpan.fullStart, text.sourceSpan.details);
+                context.push(new LiteralPiece(text.value, sourceSpan));
             }
         }
         visitContainer(container, context) {
@@ -17032,7 +17167,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function getSourceSpan(message) {
         const startNode = message.nodes[0];
         const endNode = message.nodes[message.nodes.length - 1];
-        return new ParseSourceSpan(startNode.sourceSpan.start, endNode.sourceSpan.end, startNode.sourceSpan.fullStart, startNode.sourceSpan.details);
+        return new ParseSourceSpan(startNode.sourceSpan.fullStart, endNode.sourceSpan.end, startNode.sourceSpan.fullStart, startNode.sourceSpan.details);
     }
     /**
      * Convert the list of serialized MessagePieces into two arrays.
@@ -19938,7 +20073,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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$1 = new Version('12.2.6');
+    const VERSION$1 = new Version('12.2.7');
 
     /**
      * @license
@@ -20577,7 +20712,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function compileDeclareClassMetadata(metadata) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-        definitionMap.set('version', literal('12.2.6'));
+        definitionMap.set('version', literal('12.2.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', metadata.type);
         definitionMap.set('decorators', metadata.decorators);
@@ -20617,7 +20752,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createDirectiveDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-        definitionMap.set('version', literal('12.2.6'));
+        definitionMap.set('version', literal('12.2.7'));
         // e.g. `type: MyDirective`
         definitionMap.set('type', meta.internalType);
         // e.g. `selector: 'some-dir'`
@@ -20834,7 +20969,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function compileDeclareFactoryFunction(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-        definitionMap.set('version', literal('12.2.6'));
+        definitionMap.set('version', literal('12.2.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('deps', compileDependencies(meta.deps));
@@ -20876,7 +21011,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createInjectableDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-        definitionMap.set('version', literal('12.2.6'));
+        definitionMap.set('version', literal('12.2.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // Only generate providedIn property if it has a non-null value
@@ -20955,7 +21090,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createInjectorDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-        definitionMap.set('version', literal('12.2.6'));
+        definitionMap.set('version', literal('12.2.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('providers', meta.providers);
@@ -20992,7 +21127,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createNgModuleDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-        definitionMap.set('version', literal('12.2.6'));
+        definitionMap.set('version', literal('12.2.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // We only generate the keys in the metadata if the arrays contain values.
@@ -21050,7 +21185,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createPipeDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-        definitionMap.set('version', literal('12.2.6'));
+        definitionMap.set('version', literal('12.2.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         // e.g. `type: MyPipe`
         definitionMap.set('type', meta.internalType);
@@ -21082,7 +21217,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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$2 = new Version('12.2.6');
+    const VERSION$2 = new Version('12.2.7');
 
     /**
      * @license
@@ -23219,11 +23354,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         getAdjacentNameOfClass(clazz) {
             return clazz.name;
         }
-        isStaticallyExported(clazz) {
-            // First check if there's an `export` modifier directly on the class declaration.
-            let topLevel = clazz;
-            if (ts$1.isVariableDeclaration(clazz) && ts$1.isVariableDeclarationList(clazz.parent)) {
-                topLevel = clazz.parent.parent;
+        isStaticallyExported(decl) {
+            // First check if there's an `export` modifier directly on the declaration.
+            let topLevel = decl;
+            if (ts$1.isVariableDeclaration(decl) && ts$1.isVariableDeclarationList(decl.parent)) {
+                topLevel = decl.parent.parent;
             }
             if (topLevel.modifiers !== undefined &&
                 topLevel.modifiers.some(modifier => modifier.kind === ts$1.SyntaxKind.ExportKeyword)) {
@@ -23242,8 +23377,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (topLevel.parent === undefined || !ts$1.isSourceFile(topLevel.parent)) {
                 return false;
             }
-            const localExports = this.getLocalExportedClassesOfSourceFile(clazz.getSourceFile());
-            return localExports.has(clazz);
+            const localExports = this.getLocalExportedDeclarationsOfSourceFile(decl.getSourceFile());
+            return localExports.has(decl);
         }
         getDirectImportOfIdentifier(id) {
             const symbol = this.checker.getSymbolAtLocation(id);
@@ -23446,16 +23581,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             };
         }
         /**
-         * Get the set of classes declared in `file` which are exported.
+         * Get the set of declarations declared in `file` which are exported.
          */
-        getLocalExportedClassesOfSourceFile(file) {
+        getLocalExportedDeclarationsOfSourceFile(file) {
             const cacheSf = file;
-            if (cacheSf[LocalExportedClasses] !== undefined) {
+            if (cacheSf[LocalExportedDeclarations] !== undefined) {
                 // TS does not currently narrow symbol-keyed fields, hence the non-null assert is needed.
-                return cacheSf[LocalExportedClasses];
+                return cacheSf[LocalExportedDeclarations];
             }
             const exportSet = new Set();
-            cacheSf[LocalExportedClasses] = exportSet;
+            cacheSf[LocalExportedDeclarations] = exportSet;
             const sfSymbol = this.checker.getSymbolAtLocation(cacheSf);
             if (sfSymbol === undefined || sfSymbol.exports === undefined) {
                 return exportSet;
@@ -23480,8 +23615,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     exportedSymbol = this.checker.getAliasedSymbol(exportedSymbol);
                 }
                 if (exportedSymbol.valueDeclaration !== undefined &&
-                    exportedSymbol.valueDeclaration.getSourceFile() === file &&
-                    this.isClass(exportedSymbol.valueDeclaration)) {
+                    exportedSymbol.valueDeclaration.getSourceFile() === file) {
                     exportSet.add(exportedSymbol.valueDeclaration);
                 }
                 item = iter.next();
@@ -23640,7 +23774,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             (decl.propertyName !== undefined ? decl.propertyName : decl.name).text :
             originalId.text;
     }
-    const LocalExportedClasses = Symbol('LocalExportedClasses');
+    const LocalExportedDeclarations = Symbol('LocalExportedDeclarations');
 
     /**
      * @license
@@ -35493,15 +35627,20 @@ Either add the @Injectable() decorator to '${provider.node.name
                     resolutionContext: type.getSourceFile().fileName,
                 };
             }
-            // If no owning module is known, the reference needs to be exported to be able to emit an import
+            // The declaration needs to be exported as a top-level export to be able to emit an import
             // statement for it. If the declaration is not exported, null is returned to prevent emit.
-            if (owningModule === null && !this.isStaticallyExported(declaration.node)) {
+            if (!this.isTopLevelExport(declaration.node)) {
                 return null;
             }
             return new Reference$1(declaration.node, owningModule);
         }
-        isStaticallyExported(decl) {
-            return isNamedClassDeclaration(decl) && this.reflector.isStaticallyExported(decl);
+        isTopLevelExport(decl) {
+            if (decl.parent === undefined || !ts$1.isSourceFile(decl.parent)) {
+                // The declaration has to exist at the top-level, as the reference emitters are not capable of
+                // generating imports to classes declared in a namespace.
+                return false;
+            }
+            return this.reflector.isStaticallyExported(decl);
         }
         isLocalTypeParameter(decl) {
             // Checking for local type parameters only occurs during resolution of type parameters, so it is
@@ -40295,7 +40434,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             if (!(node instanceof Binary) || node.operation !== '??')
                 return [];
             const symbolLeft = ctx.templateTypeChecker.getSymbolOfNode(node.left, component);
-            if (symbolLeft.kind !== SymbolKind.Expression) {
+            if (symbolLeft === null || symbolLeft.kind !== SymbolKind.Expression) {
                 return [];
             }
             const typeLeft = symbolLeft.tsType;