@angular/language-service 12.2.10 → 12.2.14

package/bundles/ivy.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.2.10
+ * @license Angular v12.2.14
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -2687,846 +2687,994 @@ 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
      */
-    /**
-     * This is an R3 `Node`-like wrapper for a raw `html.Comment` node. We do not currently
-     * require the implementation of a visitor for Comments as they are only collected at
-     * the top-level of the R3 AST, and only if `Render3ParseOptions['collectCommentNodes']`
-     * is true.
-     */
-    class Comment {
-        constructor(value, sourceSpan) {
-            this.value = value;
-            this.sourceSpan = sourceSpan;
+    // https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+    const VERSION = 3;
+    const JS_B64_PREFIX = '# sourceMappingURL=data:application/json;base64,';
+    class SourceMapGenerator {
+        constructor(file = null) {
+            this.file = file;
+            this.sourcesContent = new Map();
+            this.lines = [];
+            this.lastCol0 = 0;
+            this.hasMappings = false;
         }
-        visit(_visitor) {
-            throw new Error('visit() not implemented for Comment');
+        // The content is `null` when the content is expected to be loaded using the URL
+        addSource(url, content = null) {
+            if (!this.sourcesContent.has(url)) {
+                this.sourcesContent.set(url, content);
+            }
+            return this;
         }
-    }
-    class Text {
-        constructor(value, sourceSpan) {
-            this.value = value;
-            this.sourceSpan = sourceSpan;
+        addLine() {
+            this.lines.push([]);
+            this.lastCol0 = 0;
+            return this;
         }
-        visit(visitor) {
-            return visitor.visitText(this);
+        addMapping(col0, sourceUrl, sourceLine0, sourceCol0) {
+            if (!this.currentLine) {
+                throw new Error(`A line must be added before mappings can be added`);
+            }
+            if (sourceUrl != null && !this.sourcesContent.has(sourceUrl)) {
+                throw new Error(`Unknown source file "${sourceUrl}"`);
+            }
+            if (col0 == null) {
+                throw new Error(`The column in the generated code must be provided`);
+            }
+            if (col0 < this.lastCol0) {
+                throw new Error(`Mapping should be added in output order`);
+            }
+            if (sourceUrl && (sourceLine0 == null || sourceCol0 == null)) {
+                throw new Error(`The source location must be provided when a source url is provided`);
+            }
+            this.hasMappings = true;
+            this.lastCol0 = col0;
+            this.currentLine.push({ col0, sourceUrl, sourceLine0, sourceCol0 });
+            return this;
+        }
+        /**
+         * @internal strip this from published d.ts files due to
+         * https://github.com/microsoft/TypeScript/issues/36216
+         */
+        get currentLine() {
+            return this.lines.slice(-1)[0];
+        }
+        toJSON() {
+            if (!this.hasMappings) {
+                return null;
+            }
+            const sourcesIndex = new Map();
+            const sources = [];
+            const sourcesContent = [];
+            Array.from(this.sourcesContent.keys()).forEach((url, i) => {
+                sourcesIndex.set(url, i);
+                sources.push(url);
+                sourcesContent.push(this.sourcesContent.get(url) || null);
+            });
+            let mappings = '';
+            let lastCol0 = 0;
+            let lastSourceIndex = 0;
+            let lastSourceLine0 = 0;
+            let lastSourceCol0 = 0;
+            this.lines.forEach(segments => {
+                lastCol0 = 0;
+                mappings += segments
+                    .map(segment => {
+                    // zero-based starting column of the line in the generated code
+                    let segAsStr = toBase64VLQ(segment.col0 - lastCol0);
+                    lastCol0 = segment.col0;
+                    if (segment.sourceUrl != null) {
+                        // zero-based index into the “sources” list
+                        segAsStr +=
+                            toBase64VLQ(sourcesIndex.get(segment.sourceUrl) - lastSourceIndex);
+                        lastSourceIndex = sourcesIndex.get(segment.sourceUrl);
+                        // the zero-based starting line in the original source
+                        segAsStr += toBase64VLQ(segment.sourceLine0 - lastSourceLine0);
+                        lastSourceLine0 = segment.sourceLine0;
+                        // the zero-based starting column in the original source
+                        segAsStr += toBase64VLQ(segment.sourceCol0 - lastSourceCol0);
+                        lastSourceCol0 = segment.sourceCol0;
+                    }
+                    return segAsStr;
+                })
+                    .join(',');
+                mappings += ';';
+            });
+            mappings = mappings.slice(0, -1);
+            return {
+                'file': this.file || '',
+                'version': VERSION,
+                'sourceRoot': '',
+                'sources': sources,
+                'sourcesContent': sourcesContent,
+                'mappings': mappings,
+            };
+        }
+        toJsComment() {
+            return this.hasMappings ? '//' + JS_B64_PREFIX + toBase64String(JSON.stringify(this, null, 0)) :
+                '';
         }
     }
-    class BoundText {
-        constructor(value, sourceSpan, i18n) {
-            this.value = value;
-            this.sourceSpan = sourceSpan;
-            this.i18n = i18n;
+    function toBase64String(value) {
+        let b64 = '';
+        const encoded = utf8Encode(value);
+        for (let i = 0; i < encoded.length;) {
+            const i1 = encoded[i++];
+            const i2 = i < encoded.length ? encoded[i++] : null;
+            const i3 = i < encoded.length ? encoded[i++] : null;
+            b64 += toBase64Digit(i1 >> 2);
+            b64 += toBase64Digit(((i1 & 3) << 4) | (i2 === null ? 0 : i2 >> 4));
+            b64 += i2 === null ? '=' : toBase64Digit(((i2 & 15) << 2) | (i3 === null ? 0 : i3 >> 6));
+            b64 += i2 === null || i3 === null ? '=' : toBase64Digit(i3 & 63);
         }
-        visit(visitor) {
-            return visitor.visitBoundText(this);
+        return b64;
+    }
+    function toBase64VLQ(value) {
+        value = value < 0 ? ((-value) << 1) + 1 : value << 1;
+        let out = '';
+        do {
+            let digit = value & 31;
+            value = value >> 5;
+            if (value > 0) {
+                digit = digit | 32;
+            }
+            out += toBase64Digit(digit);
+        } while (value > 0);
+        return out;
+    }
+    const B64_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    function toBase64Digit(value) {
+        if (value < 0 || value >= 64) {
+            throw new Error(`Can only encode value in the range [0, 63]`);
         }
+        return B64_DIGITS[value];
     }
+
     /**
-     * Represents a text attribute in the template.
+     * @license
+     * Copyright Google LLC All Rights Reserved.
      *
-     * `valueSpan` may not be present in cases where there is no value `<div a></div>`.
-     * `keySpan` may also not be present for synthetic attributes from ICU expansions.
+     * 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
      */
-    class TextAttribute {
-        constructor(name, value, sourceSpan, keySpan, valueSpan, i18n) {
-            this.name = name;
-            this.value = value;
-            this.sourceSpan = sourceSpan;
-            this.keySpan = keySpan;
-            this.valueSpan = valueSpan;
-            this.i18n = i18n;
-        }
-        visit(visitor) {
-            return visitor.visitTextAttribute(this);
+    const _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\|\n|\r|\$/g;
+    const _LEGAL_IDENTIFIER_RE = /^[$A-Z_][0-9A-Z_$]*$/i;
+    const _INDENT_WITH = '  ';
+    const CATCH_ERROR_VAR$1 = variable('error', null, null);
+    const CATCH_STACK_VAR$1 = variable('stack', null, null);
+    class _EmittedLine {
+        constructor(indent) {
+            this.indent = indent;
+            this.partsLength = 0;
+            this.parts = [];
+            this.srcSpans = [];
         }
     }
-    class BoundAttribute {
-        constructor(name, type, securityContext, value, unit, sourceSpan, keySpan, valueSpan, i18n) {
-            this.name = name;
-            this.type = type;
-            this.securityContext = securityContext;
-            this.value = value;
-            this.unit = unit;
-            this.sourceSpan = sourceSpan;
-            this.keySpan = keySpan;
-            this.valueSpan = valueSpan;
-            this.i18n = i18n;
+    class EmitterVisitorContext {
+        constructor(_indent) {
+            this._indent = _indent;
+            this._classes = [];
+            this._preambleLineCount = 0;
+            this._lines = [new _EmittedLine(_indent)];
         }
-        static fromBoundElementProperty(prop, i18n) {
-            if (prop.keySpan === undefined) {
-                throw new Error(`Unexpected state: keySpan must be defined for bound attributes but was not for ${prop.name}: ${prop.sourceSpan}`);
-            }
-            return new BoundAttribute(prop.name, prop.type, prop.securityContext, prop.value, prop.unit, prop.sourceSpan, prop.keySpan, prop.valueSpan, i18n);
+        static createRoot() {
+            return new EmitterVisitorContext(0);
         }
-        visit(visitor) {
-            return visitor.visitBoundAttribute(this);
+        /**
+         * @internal strip this from published d.ts files due to
+         * https://github.com/microsoft/TypeScript/issues/36216
+         */
+        get _currentLine() {
+            return this._lines[this._lines.length - 1];
         }
-    }
-    class BoundEvent {
-        constructor(name, type, handler, target, phase, sourceSpan, handlerSpan, keySpan) {
-            this.name = name;
-            this.type = type;
-            this.handler = handler;
-            this.target = target;
-            this.phase = phase;
-            this.sourceSpan = sourceSpan;
-            this.handlerSpan = handlerSpan;
-            this.keySpan = keySpan;
+        println(from, lastPart = '') {
+            this.print(from || null, lastPart, true);
         }
-        static fromParsedEvent(event) {
-            const target = event.type === 0 /* Regular */ ? event.targetOrPhase : null;
-            const phase = event.type === 1 /* 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}`);
-            }
-            return new BoundEvent(event.name, event.type, event.handler, target, phase, event.sourceSpan, event.handlerSpan, event.keySpan);
+        lineIsEmpty() {
+            return this._currentLine.parts.length === 0;
         }
-        visit(visitor) {
-            return visitor.visitBoundEvent(this);
+        lineLength() {
+            return this._currentLine.indent * _INDENT_WITH.length + this._currentLine.partsLength;
         }
-    }
-    class Element {
-        constructor(name, attributes, inputs, outputs, children, references, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
-            this.name = name;
-            this.attributes = attributes;
-            this.inputs = inputs;
-            this.outputs = outputs;
-            this.children = children;
-            this.references = references;
-            this.sourceSpan = sourceSpan;
-            this.startSourceSpan = startSourceSpan;
-            this.endSourceSpan = endSourceSpan;
-            this.i18n = i18n;
-        }
-        visit(visitor) {
-            return visitor.visitElement(this);
-        }
-    }
-    class Template {
-        constructor(tagName, attributes, inputs, outputs, templateAttrs, children, references, variables, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
-            this.tagName = tagName;
-            this.attributes = attributes;
-            this.inputs = inputs;
-            this.outputs = outputs;
-            this.templateAttrs = templateAttrs;
-            this.children = children;
-            this.references = references;
-            this.variables = variables;
-            this.sourceSpan = sourceSpan;
-            this.startSourceSpan = startSourceSpan;
-            this.endSourceSpan = endSourceSpan;
-            this.i18n = i18n;
-        }
-        visit(visitor) {
-            return visitor.visitTemplate(this);
-        }
-    }
-    class Content {
-        constructor(selector, attributes, sourceSpan, i18n) {
-            this.selector = selector;
-            this.attributes = attributes;
-            this.sourceSpan = sourceSpan;
-            this.i18n = i18n;
-            this.name = 'ng-content';
-        }
-        visit(visitor) {
-            return visitor.visitContent(this);
-        }
-    }
-    class Variable {
-        constructor(name, value, sourceSpan, keySpan, valueSpan) {
-            this.name = name;
-            this.value = value;
-            this.sourceSpan = sourceSpan;
-            this.keySpan = keySpan;
-            this.valueSpan = valueSpan;
+        print(from, part, newLine = false) {
+            if (part.length > 0) {
+                this._currentLine.parts.push(part);
+                this._currentLine.partsLength += part.length;
+                this._currentLine.srcSpans.push(from && from.sourceSpan || null);
+            }
+            if (newLine) {
+                this._lines.push(new _EmittedLine(this._indent));
+            }
         }
-        visit(visitor) {
-            return visitor.visitVariable(this);
+        removeEmptyLastLine() {
+            if (this.lineIsEmpty()) {
+                this._lines.pop();
+            }
         }
-    }
-    class Reference {
-        constructor(name, value, sourceSpan, keySpan, valueSpan) {
-            this.name = name;
-            this.value = value;
-            this.sourceSpan = sourceSpan;
-            this.keySpan = keySpan;
-            this.valueSpan = valueSpan;
+        incIndent() {
+            this._indent++;
+            if (this.lineIsEmpty()) {
+                this._currentLine.indent = this._indent;
+            }
         }
-        visit(visitor) {
-            return visitor.visitReference(this);
+        decIndent() {
+            this._indent--;
+            if (this.lineIsEmpty()) {
+                this._currentLine.indent = this._indent;
+            }
         }
-    }
-    class Icu {
-        constructor(vars, placeholders, sourceSpan, i18n) {
-            this.vars = vars;
-            this.placeholders = placeholders;
-            this.sourceSpan = sourceSpan;
-            this.i18n = i18n;
+        pushClass(clazz) {
+            this._classes.push(clazz);
         }
-        visit(visitor) {
-            return visitor.visitIcu(this);
+        popClass() {
+            return this._classes.pop();
         }
-    }
-    class RecursiveVisitor {
-        visitElement(element) {
-            visitAll(this, element.attributes);
-            visitAll(this, element.inputs);
-            visitAll(this, element.outputs);
-            visitAll(this, element.children);
-            visitAll(this, element.references);
+        get currentClass() {
+            return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null;
         }
-        visitTemplate(template) {
-            visitAll(this, template.attributes);
-            visitAll(this, template.inputs);
-            visitAll(this, template.outputs);
-            visitAll(this, template.children);
-            visitAll(this, template.references);
-            visitAll(this, template.variables);
+        toSource() {
+            return this.sourceLines
+                .map(l => l.parts.length > 0 ? _createIndent(l.indent) + l.parts.join('') : '')
+                .join('\n');
         }
-        visitContent(content) { }
-        visitVariable(variable) { }
-        visitReference(reference) { }
-        visitTextAttribute(attribute) { }
-        visitBoundAttribute(attribute) { }
-        visitBoundEvent(attribute) { }
-        visitText(text) { }
-        visitBoundText(text) { }
-        visitIcu(icu) { }
-    }
-    function visitAll(visitor, nodes) {
-        const result = [];
-        if (visitor.visit) {
-            for (const node of nodes) {
-                const newNode = visitor.visit(node) || node.visit(visitor);
+        toSourceMapGenerator(genFilePath, startsAtLine = 0) {
+            const map = new SourceMapGenerator(genFilePath);
+            let firstOffsetMapped = false;
+            const mapFirstOffsetIfNeeded = () => {
+                if (!firstOffsetMapped) {
+                    // Add a single space so that tools won't try to load the file from disk.
+                    // Note: We are using virtual urls like `ng:///`, so we have to
+                    // provide a content here.
+                    map.addSource(genFilePath, ' ').addMapping(0, genFilePath, 0, 0);
+                    firstOffsetMapped = true;
+                }
+            };
+            for (let i = 0; i < startsAtLine; i++) {
+                map.addLine();
+                mapFirstOffsetIfNeeded();
             }
+            this.sourceLines.forEach((line, lineIdx) => {
+                map.addLine();
+                const spans = line.srcSpans;
+                const parts = line.parts;
+                let col0 = line.indent * _INDENT_WITH.length;
+                let spanIdx = 0;
+                // skip leading parts without source spans
+                while (spanIdx < spans.length && !spans[spanIdx]) {
+                    col0 += parts[spanIdx].length;
+                    spanIdx++;
+                }
+                if (spanIdx < spans.length && lineIdx === 0 && col0 === 0) {
+                    firstOffsetMapped = true;
+                }
+                else {
+                    mapFirstOffsetIfNeeded();
+                }
+                while (spanIdx < spans.length) {
+                    const span = spans[spanIdx];
+                    const source = span.start.file;
+                    const sourceLine = span.start.line;
+                    const sourceCol = span.start.col;
+                    map.addSource(source.url, source.content)
+                        .addMapping(col0, source.url, sourceLine, sourceCol);
+                    col0 += parts[spanIdx].length;
+                    spanIdx++;
+                    // assign parts without span or the same span to the previous segment
+                    while (spanIdx < spans.length && (span === spans[spanIdx] || !spans[spanIdx])) {
+                        col0 += parts[spanIdx].length;
+                        spanIdx++;
+                    }
+                }
+            });
+            return map;
         }
-        else {
-            for (const node of nodes) {
-                const newNode = node.visit(visitor);
-                if (newNode) {
-                    result.push(newNode);
+        setPreambleLineCount(count) {
+            return this._preambleLineCount = count;
+        }
+        spanOf(line, column) {
+            const emittedLine = this._lines[line - this._preambleLineCount];
+            if (emittedLine) {
+                let columnsLeft = column - _createIndent(emittedLine.indent).length;
+                for (let partIndex = 0; partIndex < emittedLine.parts.length; partIndex++) {
+                    const part = emittedLine.parts[partIndex];
+                    if (part.length > columnsLeft) {
+                        return emittedLine.srcSpans[partIndex];
+                    }
+                    columnsLeft -= part.length;
                 }
             }
+            return null;
         }
-        return result;
-    }
-
-    /**
-     * @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
-     */
-    class Message {
         /**
-         * @param nodes message AST
-         * @param placeholders maps placeholder names to static content and their source spans
-         * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)
-         * @param meaning
-         * @param description
-         * @param customId
+         * @internal strip this from published d.ts files due to
+         * https://github.com/microsoft/TypeScript/issues/36216
          */
-        constructor(nodes, placeholders, placeholderToMessage, meaning, description, customId) {
-            this.nodes = nodes;
-            this.placeholders = placeholders;
-            this.placeholderToMessage = placeholderToMessage;
-            this.meaning = meaning;
-            this.description = description;
-            this.customId = customId;
-            this.id = this.customId;
-            /** The ids to use if there are no custom id and if `i18nLegacyMessageIdFormat` is not empty */
-            this.legacyIds = [];
-            if (nodes.length) {
-                this.sources = [{
-                        filePath: nodes[0].sourceSpan.start.file.url,
-                        startLine: nodes[0].sourceSpan.start.line + 1,
-                        startCol: nodes[0].sourceSpan.start.col + 1,
-                        endLine: nodes[nodes.length - 1].sourceSpan.end.line + 1,
-                        endCol: nodes[0].sourceSpan.start.col + 1
-                    }];
-            }
-            else {
-                this.sources = [];
+        get sourceLines() {
+            if (this._lines.length && this._lines[this._lines.length - 1].parts.length === 0) {
+                return this._lines.slice(0, -1);
             }
+            return this._lines;
         }
     }
-    class Text$1 {
-        constructor(value, sourceSpan) {
-            this.value = value;
-            this.sourceSpan = sourceSpan;
-        }
-        visit(visitor, context) {
-            return visitor.visitText(this, context);
+    class AbstractEmitterVisitor {
+        constructor(_escapeDollarInStrings) {
+            this._escapeDollarInStrings = _escapeDollarInStrings;
         }
-    }
-    // TODO(vicb): do we really need this node (vs an array) ?
-    class Container {
-        constructor(children, sourceSpan) {
-            this.children = children;
-            this.sourceSpan = sourceSpan;
+        printLeadingComments(stmt, ctx) {
+            if (stmt.leadingComments === undefined) {
+                return;
+            }
+            for (const comment of stmt.leadingComments) {
+                if (comment instanceof JSDocComment) {
+                    ctx.print(stmt, `/*${comment.toString()}*/`, comment.trailingNewline);
+                }
+                else {
+                    if (comment.multiline) {
+                        ctx.print(stmt, `/* ${comment.text} */`, comment.trailingNewline);
+                    }
+                    else {
+                        comment.text.split('\n').forEach((line) => {
+                            ctx.println(stmt, `// ${line}`);
+                        });
+                    }
+                }
+            }
         }
-        visit(visitor, context) {
-            return visitor.visitContainer(this, context);
+        visitExpressionStmt(stmt, ctx) {
+            this.printLeadingComments(stmt, ctx);
+            stmt.expr.visitExpression(this, ctx);
+            ctx.println(stmt, ';');
+            return null;
         }
-    }
-    class Icu$1 {
-        constructor(expression, type, cases, sourceSpan) {
-            this.expression = expression;
-            this.type = type;
-            this.cases = cases;
-            this.sourceSpan = sourceSpan;
+        visitReturnStmt(stmt, ctx) {
+            this.printLeadingComments(stmt, ctx);
+            ctx.print(stmt, `return `);
+            stmt.value.visitExpression(this, ctx);
+            ctx.println(stmt, ';');
+            return null;
         }
-        visit(visitor, context) {
-            return visitor.visitIcu(this, context);
+        visitIfStmt(stmt, ctx) {
+            this.printLeadingComments(stmt, ctx);
+            ctx.print(stmt, `if (`);
+            stmt.condition.visitExpression(this, ctx);
+            ctx.print(stmt, `) {`);
+            const hasElseCase = stmt.falseCase != null && stmt.falseCase.length > 0;
+            if (stmt.trueCase.length <= 1 && !hasElseCase) {
+                ctx.print(stmt, ` `);
+                this.visitAllStatements(stmt.trueCase, ctx);
+                ctx.removeEmptyLastLine();
+                ctx.print(stmt, ` `);
+            }
+            else {
+                ctx.println();
+                ctx.incIndent();
+                this.visitAllStatements(stmt.trueCase, ctx);
+                ctx.decIndent();
+                if (hasElseCase) {
+                    ctx.println(stmt, `} else {`);
+                    ctx.incIndent();
+                    this.visitAllStatements(stmt.falseCase, ctx);
+                    ctx.decIndent();
+                }
+            }
+            ctx.println(stmt, `}`);
+            return null;
         }
-    }
-    class TagPlaceholder {
-        constructor(tag, attrs, startName, closeName, children, isVoid, 
-        // TODO sourceSpan should cover all (we need a startSourceSpan and endSourceSpan)
-        sourceSpan, startSourceSpan, endSourceSpan) {
-            this.tag = tag;
-            this.attrs = attrs;
-            this.startName = startName;
-            this.closeName = closeName;
-            this.children = children;
-            this.isVoid = isVoid;
-            this.sourceSpan = sourceSpan;
-            this.startSourceSpan = startSourceSpan;
-            this.endSourceSpan = endSourceSpan;
+        visitThrowStmt(stmt, ctx) {
+            this.printLeadingComments(stmt, ctx);
+            ctx.print(stmt, `throw `);
+            stmt.error.visitExpression(this, ctx);
+            ctx.println(stmt, `;`);
+            return null;
         }
-        visit(visitor, context) {
-            return visitor.visitTagPlaceholder(this, context);
+        visitWriteVarExpr(expr, ctx) {
+            const lineWasEmpty = ctx.lineIsEmpty();
+            if (!lineWasEmpty) {
+                ctx.print(expr, '(');
+            }
+            ctx.print(expr, `${expr.name} = `);
+            expr.value.visitExpression(this, ctx);
+            if (!lineWasEmpty) {
+                ctx.print(expr, ')');
+            }
+            return null;
         }
-    }
-    class Placeholder {
-        constructor(value, name, sourceSpan) {
-            this.value = value;
-            this.name = name;
-            this.sourceSpan = sourceSpan;
+        visitWriteKeyExpr(expr, ctx) {
+            const lineWasEmpty = ctx.lineIsEmpty();
+            if (!lineWasEmpty) {
+                ctx.print(expr, '(');
+            }
+            expr.receiver.visitExpression(this, ctx);
+            ctx.print(expr, `[`);
+            expr.index.visitExpression(this, ctx);
+            ctx.print(expr, `] = `);
+            expr.value.visitExpression(this, ctx);
+            if (!lineWasEmpty) {
+                ctx.print(expr, ')');
+            }
+            return null;
         }
-        visit(visitor, context) {
-            return visitor.visitPlaceholder(this, context);
+        visitWritePropExpr(expr, ctx) {
+            const lineWasEmpty = ctx.lineIsEmpty();
+            if (!lineWasEmpty) {
+                ctx.print(expr, '(');
+            }
+            expr.receiver.visitExpression(this, ctx);
+            ctx.print(expr, `.${expr.name} = `);
+            expr.value.visitExpression(this, ctx);
+            if (!lineWasEmpty) {
+                ctx.print(expr, ')');
+            }
+            return null;
         }
-    }
-    class IcuPlaceholder {
-        constructor(value, name, sourceSpan) {
-            this.value = value;
-            this.name = name;
-            this.sourceSpan = sourceSpan;
+        visitInvokeMethodExpr(expr, ctx) {
+            expr.receiver.visitExpression(this, ctx);
+            let name = expr.name;
+            if (expr.builtin != null) {
+                name = this.getBuiltinMethodName(expr.builtin);
+                if (name == null) {
+                    // some builtins just mean to skip the call.
+                    return null;
+                }
+            }
+            ctx.print(expr, `.${name}(`);
+            this.visitAllExpressions(expr.args, ctx, `,`);
+            ctx.print(expr, `)`);
+            return null;
         }
-        visit(visitor, context) {
-            return visitor.visitIcuPlaceholder(this, context);
+        visitInvokeFunctionExpr(expr, ctx) {
+            expr.fn.visitExpression(this, ctx);
+            ctx.print(expr, `(`);
+            this.visitAllExpressions(expr.args, ctx, ',');
+            ctx.print(expr, `)`);
+            return null;
         }
-    }
-
-    /**
-     * @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
-     */
-    /**
-     * Represents a big integer using a buffer of its individual digits, with the least significant
-     * digit stored at the beginning of the array (little endian).
-     *
-     * For performance reasons, each instance is mutable. The addition operation can be done in-place
-     * to reduce memory pressure of allocation for the digits array.
-     */
-    class BigInteger {
-        /**
-         * Creates a big integer using its individual digits in little endian storage.
-         */
-        constructor(digits) {
-            this.digits = digits;
+        visitTaggedTemplateExpr(expr, ctx) {
+            expr.tag.visitExpression(this, ctx);
+            ctx.print(expr, '`' + expr.template.elements[0].rawText);
+            for (let i = 1; i < expr.template.elements.length; i++) {
+                ctx.print(expr, '${');
+                expr.template.expressions[i - 1].visitExpression(this, ctx);
+                ctx.print(expr, `}${expr.template.elements[i].rawText}`);
+            }
+            ctx.print(expr, '`');
+            return null;
         }
-        static zero() {
-            return new BigInteger([0]);
+        visitWrappedNodeExpr(ast, ctx) {
+            throw new Error('Abstract emitter cannot visit WrappedNodeExpr.');
         }
-        static one() {
-            return new BigInteger([1]);
+        visitTypeofExpr(expr, ctx) {
+            ctx.print(expr, 'typeof ');
+            expr.expr.visitExpression(this, ctx);
         }
-        /**
-         * Creates a clone of this instance.
-         */
-        clone() {
-            return new BigInteger(this.digits.slice());
+        visitReadVarExpr(ast, ctx) {
+            let varName = ast.name;
+            if (ast.builtin != null) {
+                switch (ast.builtin) {
+                    case BuiltinVar.Super:
+                        varName = 'super';
+                        break;
+                    case BuiltinVar.This:
+                        varName = 'this';
+                        break;
+                    case BuiltinVar.CatchError:
+                        varName = CATCH_ERROR_VAR$1.name;
+                        break;
+                    case BuiltinVar.CatchStack:
+                        varName = CATCH_STACK_VAR$1.name;
+                        break;
+                    default:
+                        throw new Error(`Unknown builtin variable ${ast.builtin}`);
+                }
+            }
+            ctx.print(ast, varName);
+            return null;
         }
-        /**
-         * Returns a new big integer with the sum of `this` and `other` as its value. This does not mutate
-         * `this` but instead returns a new instance, unlike `addToSelf`.
-         */
-        add(other) {
-            const result = this.clone();
-            result.addToSelf(other);
-            return result;
+        visitInstantiateExpr(ast, ctx) {
+            ctx.print(ast, `new `);
+            ast.classExpr.visitExpression(this, ctx);
+            ctx.print(ast, `(`);
+            this.visitAllExpressions(ast.args, ctx, ',');
+            ctx.print(ast, `)`);
+            return null;
         }
-        /**
-         * Adds `other` to the instance itself, thereby mutating its value.
-         */
-        addToSelf(other) {
-            const maxNrOfDigits = Math.max(this.digits.length, other.digits.length);
-            let carry = 0;
-            for (let i = 0; i < maxNrOfDigits; i++) {
-                let digitSum = carry;
-                if (i < this.digits.length) {
-                    digitSum += this.digits[i];
-                }
-                if (i < other.digits.length) {
-                    digitSum += other.digits[i];
-                }
-                if (digitSum >= 10) {
-                    this.digits[i] = digitSum - 10;
-                    carry = 1;
-                }
-                else {
-                    this.digits[i] = digitSum;
-                    carry = 0;
-                }
+        visitLiteralExpr(ast, ctx) {
+            const value = ast.value;
+            if (typeof value === 'string') {
+                ctx.print(ast, escapeIdentifier(value, this._escapeDollarInStrings));
             }
-            // Apply a remaining carry if needed.
-            if (carry > 0) {
-                this.digits[maxNrOfDigits] = 1;
+            else {
+                ctx.print(ast, `${value}`);
             }
+            return null;
         }
-        /**
-         * Builds the decimal string representation of the big integer. As this is stored in
-         * little endian, the digits are concatenated in reverse order.
-         */
-        toString() {
-            let res = '';
-            for (let i = this.digits.length - 1; i >= 0; i--) {
-                res += this.digits[i];
+        visitLocalizedString(ast, ctx) {
+            const head = ast.serializeI18nHead();
+            ctx.print(ast, '$localize `' + head.raw);
+            for (let i = 1; i < ast.messageParts.length; i++) {
+                ctx.print(ast, '${');
+                ast.expressions[i - 1].visitExpression(this, ctx);
+                ctx.print(ast, `}${ast.serializeI18nTemplatePart(i).raw}`);
             }
-            return res;
+            ctx.print(ast, '`');
+            return null;
         }
-    }
-    /**
-     * Represents a big integer which is optimized for multiplication operations, as its power-of-twos
-     * are memoized. See `multiplyBy()` for details on the multiplication algorithm.
-     */
-    class BigIntForMultiplication {
-        constructor(value) {
-            this.powerOfTwos = [value];
+        visitConditionalExpr(ast, ctx) {
+            ctx.print(ast, `(`);
+            ast.condition.visitExpression(this, ctx);
+            ctx.print(ast, '? ');
+            ast.trueCase.visitExpression(this, ctx);
+            ctx.print(ast, ': ');
+            ast.falseCase.visitExpression(this, ctx);
+            ctx.print(ast, `)`);
+            return null;
         }
-        /**
-         * Returns the big integer itself.
-         */
-        getValue() {
-            return this.powerOfTwos[0];
+        visitNotExpr(ast, ctx) {
+            ctx.print(ast, '!');
+            ast.condition.visitExpression(this, ctx);
+            return null;
         }
-        /**
-         * Computes the value for `num * b`, where `num` is a JS number and `b` is a big integer. The
-         * value for `b` is represented by a storage model that is optimized for this computation.
-         *
-         * This operation is implemented in N(log2(num)) by continuous halving of the number, where the
-         * least-significant bit (LSB) is tested in each iteration. If the bit is set, the bit's index is
-         * used as exponent into the power-of-two multiplication of `b`.
-         *
-         * As an example, consider the multiplication num=42, b=1337. In binary 42 is 0b00101010 and the
-         * algorithm unrolls into the following iterations:
-         *
-         *  Iteration | num        | LSB  | b * 2^iter | Add? | product
-         * -----------|------------|------|------------|------|--------
-         *  0         | 0b00101010 | 0    | 1337       | No   | 0
-         *  1         | 0b00010101 | 1    | 2674       | Yes  | 2674
-         *  2         | 0b00001010 | 0    | 5348       | No   | 2674
-         *  3         | 0b00000101 | 1    | 10696      | Yes  | 13370
-         *  4         | 0b00000010 | 0    | 21392      | No   | 13370
-         *  5         | 0b00000001 | 1    | 42784      | Yes  | 56154
-         *  6         | 0b00000000 | 0    | 85568      | No   | 56154
-         *
-         * The computed product of 56154 is indeed the correct result.
-         *
-         * The `BigIntForMultiplication` representation for a big integer provides memoized access to the
-         * power-of-two values to reduce the workload in computing those values.
-         */
-        multiplyBy(num) {
-            const product = BigInteger.zero();
-            this.multiplyByAndAddTo(num, product);
-            return product;
+        visitAssertNotNullExpr(ast, ctx) {
+            ast.condition.visitExpression(this, ctx);
+            return null;
         }
-        /**
-         * See `multiplyBy()` for details. This function allows for the computed product to be added
-         * directly to the provided result big integer.
-         */
-        multiplyByAndAddTo(num, result) {
-            for (let exponent = 0; num !== 0; num = num >>> 1, exponent++) {
-                if (num & 1) {
-                    const value = this.getMultipliedByPowerOfTwo(exponent);
-                    result.addToSelf(value);
-                }
+        visitUnaryOperatorExpr(ast, ctx) {
+            let opStr;
+            switch (ast.operator) {
+                case UnaryOperator.Plus:
+                    opStr = '+';
+                    break;
+                case UnaryOperator.Minus:
+                    opStr = '-';
+                    break;
+                default:
+                    throw new Error(`Unknown operator ${ast.operator}`);
             }
+            if (ast.parens)
+                ctx.print(ast, `(`);
+            ctx.print(ast, opStr);
+            ast.expr.visitExpression(this, ctx);
+            if (ast.parens)
+                ctx.print(ast, `)`);
+            return null;
         }
-        /**
-         * Computes and memoizes the big integer value for `this.number * 2^exponent`.
-         */
-        getMultipliedByPowerOfTwo(exponent) {
-            // Compute the powers up until the requested exponent, where each value is computed from its
-            // predecessor. This is simple as `this.number * 2^(exponent - 1)` only has to be doubled (i.e.
-            // added to itself) to reach `this.number * 2^exponent`.
-            for (let i = this.powerOfTwos.length; i <= exponent; i++) {
-                const previousPower = this.powerOfTwos[i - 1];
-                this.powerOfTwos[i] = previousPower.add(previousPower);
+        visitBinaryOperatorExpr(ast, ctx) {
+            let opStr;
+            switch (ast.operator) {
+                case BinaryOperator.Equals:
+                    opStr = '==';
+                    break;
+                case BinaryOperator.Identical:
+                    opStr = '===';
+                    break;
+                case BinaryOperator.NotEquals:
+                    opStr = '!=';
+                    break;
+                case BinaryOperator.NotIdentical:
+                    opStr = '!==';
+                    break;
+                case BinaryOperator.And:
+                    opStr = '&&';
+                    break;
+                case BinaryOperator.BitwiseAnd:
+                    opStr = '&';
+                    break;
+                case BinaryOperator.Or:
+                    opStr = '||';
+                    break;
+                case BinaryOperator.Plus:
+                    opStr = '+';
+                    break;
+                case BinaryOperator.Minus:
+                    opStr = '-';
+                    break;
+                case BinaryOperator.Divide:
+                    opStr = '/';
+                    break;
+                case BinaryOperator.Multiply:
+                    opStr = '*';
+                    break;
+                case BinaryOperator.Modulo:
+                    opStr = '%';
+                    break;
+                case BinaryOperator.Lower:
+                    opStr = '<';
+                    break;
+                case BinaryOperator.LowerEquals:
+                    opStr = '<=';
+                    break;
+                case BinaryOperator.Bigger:
+                    opStr = '>';
+                    break;
+                case BinaryOperator.BiggerEquals:
+                    opStr = '>=';
+                    break;
+                case BinaryOperator.NullishCoalesce:
+                    opStr = '??';
+                    break;
+                default:
+                    throw new Error(`Unknown operator ${ast.operator}`);
             }
-            return this.powerOfTwos[exponent];
+            if (ast.parens)
+                ctx.print(ast, `(`);
+            ast.lhs.visitExpression(this, ctx);
+            ctx.print(ast, ` ${opStr} `);
+            ast.rhs.visitExpression(this, ctx);
+            if (ast.parens)
+                ctx.print(ast, `)`);
+            return null;
         }
-    }
-    /**
-     * Represents an exponentiation operation for the provided base, of which exponents are computed and
-     * memoized. The results are represented by a `BigIntForMultiplication` which is tailored for
-     * multiplication operations by memoizing the power-of-twos. This effectively results in a matrix
-     * representation that is lazily computed upon request.
-     */
-    class BigIntExponentiation {
-        constructor(base) {
-            this.base = base;
-            this.exponents = [new BigIntForMultiplication(BigInteger.one())];
+        visitReadPropExpr(ast, ctx) {
+            ast.receiver.visitExpression(this, ctx);
+            ctx.print(ast, `.`);
+            ctx.print(ast, ast.name);
+            return null;
         }
-        /**
-         * Compute the value for `this.base^exponent`, resulting in a big integer that is optimized for
-         * further multiplication operations.
-         */
-        toThePowerOf(exponent) {
-            // Compute the results up until the requested exponent, where every value is computed from its
-            // predecessor. This is because `this.base^(exponent - 1)` only has to be multiplied by `base`
-            // to reach `this.base^exponent`.
-            for (let i = this.exponents.length; i <= exponent; i++) {
-                const value = this.exponents[i - 1].multiplyBy(this.base);
-                this.exponents[i] = new BigIntForMultiplication(value);
-            }
-            return this.exponents[exponent];
+        visitReadKeyExpr(ast, ctx) {
+            ast.receiver.visitExpression(this, ctx);
+            ctx.print(ast, `[`);
+            ast.index.visitExpression(this, ctx);
+            ctx.print(ast, `]`);
+            return null;
         }
-    }
-
-    /**
-     * @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
-     */
-    /**
-     * Compute the message id using the XLIFF1 digest.
-     */
-    function computeDigest(message) {
-        return sha1(serializeNodes(message.nodes).join('') + `[${message.meaning}]`);
-    }
-    /**
-     * Return the message id or compute it using the XLIFF2/XMB/$localize digest.
-     */
-    function decimalDigest(message) {
-        return message.id || computeDecimalDigest(message);
-    }
-    /**
-     * Compute the message id using the XLIFF2/XMB/$localize digest.
-     */
-    function computeDecimalDigest(message) {
-        const visitor = new _SerializerIgnoreIcuExpVisitor();
-        const parts = message.nodes.map(a => a.visit(visitor, null));
-        return computeMsgId(parts.join(''), message.meaning);
-    }
-    /**
-     * Serialize the i18n ast to something xml-like in order to generate an UID.
-     *
-     * The visitor is also used in the i18n parser tests
-     *
-     * @internal
-     */
-    class _SerializerVisitor {
-        visitText(text, context) {
-            return text.value;
+        visitLiteralArrayExpr(ast, ctx) {
+            ctx.print(ast, `[`);
+            this.visitAllExpressions(ast.entries, ctx, ',');
+            ctx.print(ast, `]`);
+            return null;
         }
-        visitContainer(container, context) {
-            return `[${container.children.map(child => child.visit(this)).join(', ')}]`;
+        visitLiteralMapExpr(ast, ctx) {
+            ctx.print(ast, `{`);
+            this.visitAllObjects(entry => {
+                ctx.print(ast, `${escapeIdentifier(entry.key, this._escapeDollarInStrings, entry.quoted)}:`);
+                entry.value.visitExpression(this, ctx);
+            }, ast.entries, ctx, ',');
+            ctx.print(ast, `}`);
+            return null;
         }
-        visitIcu(icu, context) {
-            const strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
-            return `{${icu.expression}, ${icu.type}, ${strCases.join(', ')}}`;
+        visitCommaExpr(ast, ctx) {
+            ctx.print(ast, '(');
+            this.visitAllExpressions(ast.parts, ctx, ',');
+            ctx.print(ast, ')');
+            return null;
         }
-        visitTagPlaceholder(ph, context) {
-            return ph.isVoid ?
-                `<ph tag name="${ph.startName}"/>` :
-                `<ph tag name="${ph.startName}">${ph.children.map(child => child.visit(this)).join(', ')}</ph name="${ph.closeName}">`;
+        visitAllExpressions(expressions, ctx, separator) {
+            this.visitAllObjects(expr => expr.visitExpression(this, ctx), expressions, ctx, separator);
         }
-        visitPlaceholder(ph, context) {
-            return ph.value ? `<ph name="${ph.name}">${ph.value}</ph>` : `<ph name="${ph.name}"/>`;
+        visitAllObjects(handler, expressions, ctx, separator) {
+            let incrementedIndent = false;
+            for (let i = 0; i < expressions.length; i++) {
+                if (i > 0) {
+                    if (ctx.lineLength() > 80) {
+                        ctx.print(null, separator, true);
+                        if (!incrementedIndent) {
+                            // continuation are marked with double indent.
+                            ctx.incIndent();
+                            ctx.incIndent();
+                            incrementedIndent = true;
+                        }
+                    }
+                    else {
+                        ctx.print(null, separator, false);
+                    }
+                }
+                handler(expressions[i]);
+            }
+            if (incrementedIndent) {
+                // continuation are marked with double indent.
+                ctx.decIndent();
+                ctx.decIndent();
+            }
         }
-        visitIcuPlaceholder(ph, context) {
-            return `<ph icu name="${ph.name}">${ph.value.visit(this)}</ph>`;
+        visitAllStatements(statements, ctx) {
+            statements.forEach((stmt) => stmt.visitStatement(this, ctx));
         }
     }
-    const serializerVisitor = new _SerializerVisitor();
-    function serializeNodes(nodes) {
-        return nodes.map(a => a.visit(serializerVisitor, null));
+    function escapeIdentifier(input, escapeDollar, alwaysQuote = true) {
+        if (input == null) {
+            return null;
+        }
+        const body = input.replace(_SINGLE_QUOTE_ESCAPE_STRING_RE, (...match) => {
+            if (match[0] == '$') {
+                return escapeDollar ? '\\$' : '$';
+            }
+            else if (match[0] == '\n') {
+                return '\\n';
+            }
+            else if (match[0] == '\r') {
+                return '\\r';
+            }
+            else {
+                return `\\${match[0]}`;
+            }
+        });
+        const requiresQuotes = alwaysQuote || !_LEGAL_IDENTIFIER_RE.test(body);
+        return requiresQuotes ? `'${body}'` : body;
     }
-    /**
-     * Serialize the i18n ast to something xml-like in order to generate an UID.
-     *
-     * Ignore the ICU expressions so that message IDs stays identical if only the expression changes.
-     *
-     * @internal
-     */
-    class _SerializerIgnoreIcuExpVisitor extends _SerializerVisitor {
-        visitIcu(icu, context) {
-            let strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
-            // Do not take the expression into account
-            return `{${icu.type}, ${strCases.join(', ')}}`;
+    function _createIndent(count) {
+        let res = '';
+        for (let i = 0; i < count; i++) {
+            res += _INDENT_WITH;
         }
+        return res;
     }
+
     /**
-     * Compute the SHA1 of the given string
-     *
-     * see https://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf
+     * @license
+     * Copyright Google LLC All Rights Reserved.
      *
-     * WARNING: this function has not been designed not tested with security in mind.
-     *          DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.
+     * 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
      */
-    function sha1(str) {
-        const utf8 = utf8Encode(str);
-        const words32 = bytesToWords32(utf8, Endian.Big);
-        const len = utf8.length * 8;
-        const w = newArray(80);
-        let a = 0x67452301, b = 0xefcdab89, c = 0x98badcfe, d = 0x10325476, e = 0xc3d2e1f0;
-        words32[len >> 5] |= 0x80 << (24 - len % 32);
-        words32[((len + 64 >> 9) << 4) + 15] = len;
-        for (let i = 0; i < words32.length; i += 16) {
-            const h0 = a, h1 = b, h2 = c, h3 = d, h4 = e;
-            for (let j = 0; j < 80; j++) {
-                if (j < 16) {
-                    w[j] = words32[i + j];
-                }
-                else {
-                    w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
-                }
-                const fkVal = fk(j, b, c, d);
-                const f = fkVal[0];
-                const k = fkVal[1];
-                const temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32);
-                e = d;
-                d = c;
-                c = rol32(b, 30);
-                b = a;
-                a = temp;
-            }
-            a = add32(a, h0);
-            b = add32(b, h1);
-            c = add32(c, h2);
-            d = add32(d, h3);
-            e = add32(e, h4);
-        }
-        return bytesToHexString(words32ToByteString([a, b, c, d, e]));
-    }
-    function fk(index, b, c, d) {
-        if (index < 20) {
-            return [(b & c) | (~b & d), 0x5a827999];
-        }
-        if (index < 40) {
-            return [b ^ c ^ d, 0x6ed9eba1];
+    function typeWithParameters(type, numParams) {
+        if (numParams === 0) {
+            return expressionType(type);
         }
-        if (index < 60) {
-            return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc];
+        const params = [];
+        for (let i = 0; i < numParams; i++) {
+            params.push(DYNAMIC_TYPE);
         }
-        return [b ^ c ^ d, 0xca62c1d6];
+        return expressionType(type, undefined, params);
+    }
+    const ANIMATE_SYMBOL_PREFIX = '@';
+    function prepareSyntheticPropertyName(name) {
+        return `${ANIMATE_SYMBOL_PREFIX}${name}`;
+    }
+    function prepareSyntheticListenerName(name, phase) {
+        return `${ANIMATE_SYMBOL_PREFIX}${name}.${phase}`;
+    }
+    function getSafePropertyAccessString(accessor, name) {
+        const escapedName = escapeIdentifier(name, false, false);
+        return escapedName !== name ? `${accessor}[${escapedName}]` : `${accessor}.${name}`;
+    }
+    function prepareSyntheticListenerFunctionName(name, phase) {
+        return `animation_${name}_${phase}`;
+    }
+    function jitOnlyGuardedExpression(expr) {
+        return guardedExpression('ngJitMode', expr);
+    }
+    function devOnlyGuardedExpression(expr) {
+        return guardedExpression('ngDevMode', expr);
+    }
+    function guardedExpression(guard, expr) {
+        const guardExpr = new ExternalExpr({ name: guard, moduleName: null });
+        const guardNotDefined = new BinaryOperatorExpr(BinaryOperator.Identical, new TypeofExpr(guardExpr), literal('undefined'));
+        const guardUndefinedOrTrue = new BinaryOperatorExpr(BinaryOperator.Or, guardNotDefined, guardExpr, /* type */ undefined, 
+        /* sourceSpan */ undefined, true);
+        return new BinaryOperatorExpr(BinaryOperator.And, guardUndefinedOrTrue, expr);
+    }
+    function wrapReference(value) {
+        const wrapped = new WrappedNodeExpr(value);
+        return { value: wrapped, type: wrapped };
+    }
+    function refsToArray(refs, shouldForwardDeclare) {
+        const values = literalArr(refs.map(ref => ref.value));
+        return shouldForwardDeclare ? fn([], [new ReturnStatement(values)]) : values;
+    }
+    function createMayBeForwardRefExpression(expression, forwardRef) {
+        return { expression, forwardRef };
     }
     /**
-     * Compute the fingerprint of the given string
+     * Convert a `MaybeForwardRefExpression` to an `Expression`, possibly wrapping its expression in a
+     * `forwardRef()` call.
      *
-     * The output is 64 bit number encoded as a decimal string
+     * If `MaybeForwardRefExpression.forwardRef` is `ForwardRefHandling.Unwrapped` then the expression
+     * was originally wrapped in a `forwardRef()` call to prevent the value from being eagerly evaluated
+     * in the code.
      *
-     * based on:
-     * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java
+     * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and
+     * `packages/compiler/src/jit_compiler_facade.ts` for more information.
      */
-    function fingerprint(str) {
-        const utf8 = utf8Encode(str);
-        let hi = hash32(utf8, 0);
-        let lo = hash32(utf8, 102072);
-        if (hi == 0 && (lo == 0 || lo == 1)) {
-            hi = hi ^ 0x130f9bef;
-            lo = lo ^ -0x6b5f56d8;
+    function convertFromMaybeForwardRefExpression({ expression, forwardRef }) {
+        switch (forwardRef) {
+            case 0 /* None */:
+            case 1 /* Wrapped */:
+                return expression;
+            case 2 /* Unwrapped */:
+                return generateForwardRef(expression);
         }
-        return [hi, lo];
     }
-    function computeMsgId(msg, meaning = '') {
-        let msgFingerprint = fingerprint(msg);
-        if (meaning) {
-            const meaningFingerprint = fingerprint(meaning);
-            msgFingerprint = add64(rol64(msgFingerprint, 1), meaningFingerprint);
-        }
-        const hi = msgFingerprint[0];
-        const lo = msgFingerprint[1];
-        return wordsToDecimalString(hi & 0x7fffffff, lo);
+    /**
+     * Generate an expression that has the given `expr` wrapped in the following form:
+     *
+     * ```
+     * forwardRef(() => expr)
+     * ```
+     */
+    function generateForwardRef(expr) {
+        return importExpr(Identifiers.forwardRef).callFn([fn([], [new ReturnStatement(expr)])]);
     }
-    function hash32(bytes, c) {
-        let a = 0x9e3779b9, b = 0x9e3779b9;
-        let i;
-        const len = bytes.length;
-        for (i = 0; i + 12 <= len; i += 12) {
-            a = add32(a, wordAt(bytes, i, Endian.Little));
-            b = add32(b, wordAt(bytes, i + 4, Endian.Little));
-            c = add32(c, wordAt(bytes, i + 8, Endian.Little));
-            const res = mix(a, b, c);
-            a = res[0], b = res[1], c = res[2];
+
+    var R3FactoryDelegateType;
+    (function (R3FactoryDelegateType) {
+        R3FactoryDelegateType[R3FactoryDelegateType["Class"] = 0] = "Class";
+        R3FactoryDelegateType[R3FactoryDelegateType["Function"] = 1] = "Function";
+    })(R3FactoryDelegateType || (R3FactoryDelegateType = {}));
+    var FactoryTarget;
+    (function (FactoryTarget) {
+        FactoryTarget[FactoryTarget["Directive"] = 0] = "Directive";
+        FactoryTarget[FactoryTarget["Component"] = 1] = "Component";
+        FactoryTarget[FactoryTarget["Injectable"] = 2] = "Injectable";
+        FactoryTarget[FactoryTarget["Pipe"] = 3] = "Pipe";
+        FactoryTarget[FactoryTarget["NgModule"] = 4] = "NgModule";
+    })(FactoryTarget || (FactoryTarget = {}));
+    /**
+     * Construct a factory function expression for the given `R3FactoryMetadata`.
+     */
+    function compileFactoryFunction(meta) {
+        const t = variable('t');
+        let baseFactoryVar = null;
+        // The type to instantiate via constructor invocation. If there is no delegated factory, meaning
+        // this type is always created by constructor invocation, then this is the type-to-create
+        // parameter provided by the user (t) if specified, or the current type if not. If there is a
+        // delegated factory (which is used to create the current type) then this is only the type-to-
+        // create parameter (t).
+        const typeForCtor = !isDelegatedFactoryMetadata(meta) ?
+            new BinaryOperatorExpr(BinaryOperator.Or, t, meta.internalType) :
+            t;
+        let ctorExpr = null;
+        if (meta.deps !== null) {
+            // There is a constructor (either explicitly or implicitly defined).
+            if (meta.deps !== 'invalid') {
+                ctorExpr = new InstantiateExpr(typeForCtor, injectDependencies(meta.deps, meta.target));
+            }
         }
-        a = add32(a, wordAt(bytes, i, Endian.Little));
-        b = add32(b, wordAt(bytes, i + 4, Endian.Little));
-        // the first byte of c is reserved for the length
-        c = add32(c, len);
-        c = add32(c, wordAt(bytes, i + 8, Endian.Little) << 8);
-        return mix(a, b, c)[2];
-    }
-    // clang-format off
-    function mix(a, b, c) {
-        a = sub32(a, b);
-        a = sub32(a, c);
-        a ^= c >>> 13;
-        b = sub32(b, c);
-        b = sub32(b, a);
-        b ^= a << 8;
-        c = sub32(c, a);
-        c = sub32(c, b);
-        c ^= b >>> 13;
-        a = sub32(a, b);
-        a = sub32(a, c);
-        a ^= c >>> 12;
-        b = sub32(b, c);
-        b = sub32(b, a);
-        b ^= a << 16;
-        c = sub32(c, a);
-        c = sub32(c, b);
-        c ^= b >>> 5;
-        a = sub32(a, b);
-        a = sub32(a, c);
-        a ^= c >>> 3;
-        b = sub32(b, c);
-        b = sub32(b, a);
-        b ^= a << 10;
-        c = sub32(c, a);
-        c = sub32(c, b);
-        c ^= b >>> 15;
-        return [a, b, c];
-    }
-    // clang-format on
-    // Utils
-    var Endian;
-    (function (Endian) {
-        Endian[Endian["Little"] = 0] = "Little";
-        Endian[Endian["Big"] = 1] = "Big";
-    })(Endian || (Endian = {}));
-    function add32(a, b) {
-        return add32to64(a, b)[1];
-    }
-    function add32to64(a, b) {
-        const low = (a & 0xffff) + (b & 0xffff);
-        const high = (a >>> 16) + (b >>> 16) + (low >>> 16);
-        return [high >>> 16, (high << 16) | (low & 0xffff)];
-    }
-    function add64(a, b) {
-        const ah = a[0], al = a[1];
-        const bh = b[0], bl = b[1];
-        const result = add32to64(al, bl);
-        const carry = result[0];
-        const l = result[1];
-        const h = add32(add32(ah, bh), carry);
-        return [h, l];
-    }
-    function sub32(a, b) {
-        const low = (a & 0xffff) - (b & 0xffff);
-        const high = (a >> 16) - (b >> 16) + (low >> 16);
-        return (high << 16) | (low & 0xffff);
+        else {
+            // There is no constructor, use the base class' factory to construct typeForCtor.
+            baseFactoryVar = variable(`ɵ${meta.name}_BaseFactory`);
+            ctorExpr = baseFactoryVar.callFn([typeForCtor]);
+        }
+        const body = [];
+        let retExpr = null;
+        function makeConditionalFactory(nonCtorExpr) {
+            const r = variable('r');
+            body.push(r.set(NULL_EXPR).toDeclStmt());
+            const ctorStmt = ctorExpr !== null ? r.set(ctorExpr).toStmt() :
+                importExpr(Identifiers.invalidFactory).callFn([]).toStmt();
+            body.push(ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()]));
+            return r;
+        }
+        if (isDelegatedFactoryMetadata(meta)) {
+            // This type is created with a delegated factory. If a type parameter is not specified, call
+            // the factory instead.
+            const delegateArgs = injectDependencies(meta.delegateDeps, meta.target);
+            // Either call `new delegate(...)` or `delegate(...)` depending on meta.delegateType.
+            const factoryExpr = new (meta.delegateType === R3FactoryDelegateType.Class ?
+                InstantiateExpr :
+                InvokeFunctionExpr)(meta.delegate, delegateArgs);
+            retExpr = makeConditionalFactory(factoryExpr);
+        }
+        else if (isExpressionFactoryMetadata(meta)) {
+            // TODO(alxhub): decide whether to lower the value here or in the caller
+            retExpr = makeConditionalFactory(meta.expression);
+        }
+        else {
+            retExpr = ctorExpr;
+        }
+        if (retExpr === null) {
+            // The expression cannot be formed so render an `ɵɵinvalidFactory()` call.
+            body.push(importExpr(Identifiers.invalidFactory).callFn([]).toStmt());
+        }
+        else if (baseFactoryVar !== null) {
+            // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it.
+            const getInheritedFactoryCall = importExpr(Identifiers.getInheritedFactory).callFn([meta.internalType]);
+            // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`
+            const baseFactory = new BinaryOperatorExpr(BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
+            body.push(new ReturnStatement(baseFactory.callFn([typeForCtor])));
+        }
+        else {
+            // This is straightforward factory, just return it.
+            body.push(new ReturnStatement(retExpr));
+        }
+        let factoryFn = fn([new FnParam('t', DYNAMIC_TYPE)], body, INFERRED_TYPE, undefined, `${meta.name}_Factory`);
+        if (baseFactoryVar !== null) {
+            // There is a base factory variable so wrap its declaration along with the factory function into
+            // an IIFE.
+            factoryFn = fn([], [
+                new DeclareVarStmt(baseFactoryVar.name), new ReturnStatement(factoryFn)
+            ]).callFn([], /* sourceSpan */ undefined, /* pure */ true);
+        }
+        return {
+            expression: factoryFn,
+            statements: [],
+            type: createFactoryType(meta),
+        };
     }
-    // Rotate a 32b number left `count` position
-    function rol32(a, count) {
-        return (a << count) | (a >>> (32 - count));
+    function createFactoryType(meta) {
+        const ctorDepsType = meta.deps !== null && meta.deps !== 'invalid' ? createCtorDepsType(meta.deps) : NONE_TYPE;
+        return expressionType(importExpr(Identifiers.FactoryDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount), ctorDepsType]));
     }
-    // Rotate a 64b number left `count` position
-    function rol64(num, count) {
-        const hi = num[0], lo = num[1];
-        const h = (hi << count) | (lo >>> (32 - count));
-        const l = (lo << count) | (hi >>> (32 - count));
-        return [h, l];
+    function injectDependencies(deps, target) {
+        return deps.map((dep, index) => compileInjectDependency(dep, target, index));
     }
-    function bytesToWords32(bytes, endian) {
-        const size = (bytes.length + 3) >>> 2;
-        const words32 = [];
-        for (let i = 0; i < size; i++) {
-            words32[i] = wordAt(bytes, i * 4, endian);
+    function compileInjectDependency(dep, target, index) {
+        // Interpret the dependency according to its resolved type.
+        if (dep.token === null) {
+            return importExpr(Identifiers.invalidFactoryDep).callFn([literal(index)]);
         }
-        return words32;
-    }
-    function byteAt(bytes, index) {
-        return index >= bytes.length ? 0 : bytes[index];
-    }
-    function wordAt(bytes, index, endian) {
-        let word = 0;
-        if (endian === Endian.Big) {
-            for (let i = 0; i < 4; i++) {
-                word += byteAt(bytes, index + i) << (24 - 8 * i);
+        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 === FactoryTarget.Pipe ? 16 /* 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;
+            // Build up the arguments to the injectFn call.
+            const injectArgs = [dep.token];
+            if (flagsParam) {
+                injectArgs.push(flagsParam);
             }
+            const injectFn = getInjectFn(target);
+            return importExpr(injectFn).callFn(injectArgs);
         }
         else {
-            for (let i = 0; i < 4; i++) {
-                word += byteAt(bytes, index + i) << 8 * i;
-            }
+            // The `dep.attributeTypeName` value is defined, which indicates that this is an `@Attribute()`
+            // type dependency. For the generated JS we still want to use the `dep.token` value in case the
+            // name given for the attribute is not a string literal. For example given `@Attribute(foo())`,
+            // we want to generate `ɵɵinjectAttribute(foo())`.
+            //
+            // The `dep.attributeTypeName` is only actually used (in `createCtorDepType()`) to generate
+            // typings.
+            return importExpr(Identifiers.injectAttribute).callFn([dep.token]);
         }
-        return word;
-    }
-    function words32ToByteString(words32) {
-        return words32.reduce((bytes, word) => bytes.concat(word32ToByteString(word)), []);
     }
-    function word32ToByteString(word) {
-        let bytes = [];
-        for (let i = 0; i < 4; i++) {
-            bytes.push((word >>> 8 * (3 - i)) & 0xff);
+    function createCtorDepsType(deps) {
+        let hasTypes = false;
+        const attributeTypes = deps.map(dep => {
+            const type = createCtorDepType(dep);
+            if (type !== null) {
+                hasTypes = true;
+                return type;
+            }
+            else {
+                return literal(null);
+            }
+        });
+        if (hasTypes) {
+            return expressionType(literalArr(attributeTypes));
         }
-        return bytes;
-    }
-    function bytesToHexString(bytes) {
-        let hex = '';
-        for (let i = 0; i < bytes.length; i++) {
-            const b = byteAt(bytes, i);
-            hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16);
+        else {
+            return NONE_TYPE;
         }
-        return hex.toLowerCase();
     }
-    /**
-     * Create a shared exponentiation pool for base-256 computations. This shared pool provides memoized
-     * power-of-256 results with memoized power-of-two computations for efficient multiplication.
-     *
-     * For our purposes, this can be safely stored as a global without memory concerns. The reason is
-     * that we encode two words, so only need the 0th (for the low word) and 4th (for the high word)
-     * exponent.
-     */
-    const base256 = new BigIntExponentiation(256);
-    /**
-     * Represents two 32-bit words as a single decimal number. This requires a big integer storage
-     * model as JS numbers are not accurate enough to represent the 64-bit number.
-     *
-     * Based on https://www.danvk.org/hex2dec.html
-     */
-    function wordsToDecimalString(hi, lo) {
-        // Encode the four bytes in lo in the lower digits of the decimal number.
-        // Note: the multiplication results in lo itself but represented by a big integer using its
-        // decimal digits.
-        const decimal = base256.toThePowerOf(0).multiplyBy(lo);
-        // Encode the four bytes in hi above the four lo bytes. lo is a maximum of (2^8)^4, which is why
-        // this multiplication factor is applied.
-        base256.toThePowerOf(4).multiplyByAndAddTo(hi, decimal);
-        return decimal.toString();
+    function createCtorDepType(dep) {
+        const entries = [];
+        if (dep.attributeNameType !== null) {
+            entries.push({ key: 'attribute', value: dep.attributeNameType, quoted: false });
+        }
+        if (dep.optional) {
+            entries.push({ key: 'optional', value: literal(true), quoted: false });
+        }
+        if (dep.host) {
+            entries.push({ key: 'host', value: literal(true), quoted: false });
+        }
+        if (dep.self) {
+            entries.push({ key: 'self', value: literal(true), quoted: false });
+        }
+        if (dep.skipSelf) {
+            entries.push({ key: 'skipSelf', value: literal(true), quoted: false });
+        }
+        return entries.length > 0 ? literalMap(entries) : null;
     }
-
-    /**
-     * @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
-     */
-    // XMB/XTB placeholders can only contain A-Z, 0-9 and _
-    function toPublicName(internalName) {
-        return internalName.toUpperCase().replace(/[^A-Z0-9_]/g, '_');
+    function isDelegatedFactoryMetadata(meta) {
+        return meta.delegateType !== undefined;
+    }
+    function isExpressionFactoryMetadata(meta) {
+        return meta.expression !== undefined;
+    }
+    function getInjectFn(target) {
+        switch (target) {
+            case FactoryTarget.Component:
+            case FactoryTarget.Directive:
+            case FactoryTarget.Pipe:
+                return Identifiers.directiveInject;
+            case FactoryTarget.NgModule:
+            case FactoryTarget.Injectable:
+            default:
+                return Identifiers.inject;
+        }
     }
 
     /**
@@ -3536,350 +3684,229 @@ 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
      */
-    /* Closure variables holding messages must be named `MSG_[A-Z0-9]+` */
-    const CLOSURE_TRANSLATION_VAR_PREFIX = 'MSG_';
     /**
-     * Prefix for non-`goog.getMsg` i18n-related vars.
-     * Note: the prefix uses lowercase characters intentionally due to a Closure behavior that
-     * considers variables like `I18N_0` as constants and throws an error when their value changes.
+     * This is an R3 `Node`-like wrapper for a raw `html.Comment` node. We do not currently
+     * require the implementation of a visitor for Comments as they are only collected at
+     * the top-level of the R3 AST, and only if `Render3ParseOptions['collectCommentNodes']`
+     * is true.
      */
-    const TRANSLATION_VAR_PREFIX = 'i18n_';
-    /** Name of the i18n attributes **/
-    const I18N_ATTR = 'i18n';
-    const I18N_ATTR_PREFIX = 'i18n-';
-    /** Prefix of var expressions used in ICUs */
-    const I18N_ICU_VAR_PREFIX = 'VAR_';
-    /** Prefix of ICU expressions for post processing */
-    const I18N_ICU_MAPPING_PREFIX = 'I18N_EXP_';
-    /** Placeholder wrapper for i18n expressions **/
-    const I18N_PLACEHOLDER_SYMBOL = '�';
-    function isI18nAttribute(name) {
-        return name === I18N_ATTR || name.startsWith(I18N_ATTR_PREFIX);
-    }
-    function isI18nRootNode(meta) {
-        return meta instanceof Message;
-    }
-    function isSingleI18nIcu(meta) {
-        return isI18nRootNode(meta) && meta.nodes.length === 1 && meta.nodes[0] instanceof Icu$1;
-    }
-    function hasI18nMeta(node) {
-        return !!node.i18n;
-    }
-    function hasI18nAttrs(element) {
-        return element.attrs.some((attr) => isI18nAttribute(attr.name));
-    }
-    function icuFromI18nMessage(message) {
-        return message.nodes[0];
-    }
-    function wrapI18nPlaceholder(content, contextId = 0) {
-        const blockId = contextId > 0 ? `:${contextId}` : '';
-        return `${I18N_PLACEHOLDER_SYMBOL}${content}${blockId}${I18N_PLACEHOLDER_SYMBOL}`;
-    }
-    function assembleI18nBoundString(strings, bindingStartIndex = 0, contextId = 0) {
-        if (!strings.length)
-            return '';
-        let acc = '';
-        const lastIdx = strings.length - 1;
-        for (let i = 0; i < lastIdx; i++) {
-            acc += `${strings[i]}${wrapI18nPlaceholder(bindingStartIndex + i, contextId)}`;
+    class Comment {
+        constructor(value, sourceSpan) {
+            this.value = value;
+            this.sourceSpan = sourceSpan;
+        }
+        visit(_visitor) {
+            throw new Error('visit() not implemented for Comment');
         }
-        acc += strings[lastIdx];
-        return acc;
-    }
-    function getSeqNumberGenerator(startsAt = 0) {
-        let current = startsAt;
-        return () => current++;
-    }
-    function placeholdersToParams(placeholders) {
-        const params = {};
-        placeholders.forEach((values, key) => {
-            params[key] = literal(values.length > 1 ? `[${values.join('|')}]` : values[0]);
-        });
-        return params;
-    }
-    function updatePlaceholderMap(map, name, ...values) {
-        const current = map.get(name) || [];
-        current.push(...values);
-        map.set(name, current);
     }
-    function assembleBoundTextPlaceholders(meta, bindingStartIndex = 0, contextId = 0) {
-        const startIdx = bindingStartIndex;
-        const placeholders = new Map();
-        const node = meta instanceof Message ? meta.nodes.find(node => node instanceof Container) : meta;
-        if (node) {
-            node
-                .children
-                .filter((child) => child instanceof Placeholder)
-                .forEach((child, idx) => {
-                const content = wrapI18nPlaceholder(startIdx + idx, contextId);
-                updatePlaceholderMap(placeholders, child.name, content);
-            });
+    class Text {
+        constructor(value, sourceSpan) {
+            this.value = value;
+            this.sourceSpan = sourceSpan;
+        }
+        visit(visitor) {
+            return visitor.visitText(this);
         }
-        return placeholders;
     }
-    /**
-     * Format the placeholder names in a map of placeholders to expressions.
-     *
-     * The placeholder names are converted from "internal" format (e.g. `START_TAG_DIV_1`) to "external"
-     * format (e.g. `startTagDiv_1`).
-     *
-     * @param params A map of placeholder names to expressions.
-     * @param useCamelCase whether to camelCase the placeholder name when formatting.
-     * @returns A new map of formatted placeholder names to expressions.
-     */
-    function i18nFormatPlaceholderNames(params = {}, useCamelCase) {
-        const _params = {};
-        if (params && Object.keys(params).length) {
-            Object.keys(params).forEach(key => _params[formatI18nPlaceholderName(key, useCamelCase)] = params[key]);
+    class BoundText {
+        constructor(value, sourceSpan, i18n) {
+            this.value = value;
+            this.sourceSpan = sourceSpan;
+            this.i18n = i18n;
+        }
+        visit(visitor) {
+            return visitor.visitBoundText(this);
         }
-        return _params;
     }
     /**
-     * Converts internal placeholder names to public-facing format
-     * (for example to use in goog.getMsg call).
-     * Example: `START_TAG_DIV_1` is converted to `startTagDiv_1`.
+     * Represents a text attribute in the template.
      *
-     * @param name The placeholder name that should be formatted
-     * @returns Formatted placeholder name
+     * `valueSpan` may not be present in cases where there is no value `<div a></div>`.
+     * `keySpan` may also not be present for synthetic attributes from ICU expansions.
      */
-    function formatI18nPlaceholderName(name, useCamelCase = true) {
-        const publicName = toPublicName(name);
-        if (!useCamelCase) {
-            return publicName;
+    class TextAttribute {
+        constructor(name, value, sourceSpan, keySpan, valueSpan, i18n) {
+            this.name = name;
+            this.value = value;
+            this.sourceSpan = sourceSpan;
+            this.keySpan = keySpan;
+            this.valueSpan = valueSpan;
+            this.i18n = i18n;
         }
-        const chunks = publicName.split('_');
-        if (chunks.length === 1) {
-            // if no "_" found - just lowercase the value
-            return name.toLowerCase();
+        visit(visitor) {
+            return visitor.visitTextAttribute(this);
         }
-        let postfix;
-        // eject last element if it's a number
-        if (/^\d+$/.test(chunks[chunks.length - 1])) {
-            postfix = chunks.pop();
+    }
+    class BoundAttribute {
+        constructor(name, type, securityContext, value, unit, sourceSpan, keySpan, valueSpan, i18n) {
+            this.name = name;
+            this.type = type;
+            this.securityContext = securityContext;
+            this.value = value;
+            this.unit = unit;
+            this.sourceSpan = sourceSpan;
+            this.keySpan = keySpan;
+            this.valueSpan = valueSpan;
+            this.i18n = i18n;
         }
-        let raw = chunks.shift().toLowerCase();
-        if (chunks.length) {
-            raw += chunks.map(c => c.charAt(0).toUpperCase() + c.slice(1).toLowerCase()).join('');
+        static fromBoundElementProperty(prop, i18n) {
+            if (prop.keySpan === undefined) {
+                throw new Error(`Unexpected state: keySpan must be defined for bound attributes but was not for ${prop.name}: ${prop.sourceSpan}`);
+            }
+            return new BoundAttribute(prop.name, prop.type, prop.securityContext, prop.value, prop.unit, prop.sourceSpan, prop.keySpan, prop.valueSpan, i18n);
+        }
+        visit(visitor) {
+            return visitor.visitBoundAttribute(this);
         }
-        return postfix ? `${raw}_${postfix}` : raw;
-    }
-    /**
-     * Generates a prefix for translation const name.
-     *
-     * @param extra Additional local prefix that should be injected into translation var name
-     * @returns Complete translation const prefix
-     */
-    function getTranslationConstPrefix(extra) {
-        return `${CLOSURE_TRANSLATION_VAR_PREFIX}${extra}`.toUpperCase();
     }
-    /**
-     * Generate AST to declare a variable. E.g. `var I18N_1;`.
-     * @param variable the name of the variable to declare.
-     */
-    function declareI18nVariable(variable) {
-        return new DeclareVarStmt(variable.name, undefined, INFERRED_TYPE, undefined, variable.sourceSpan);
-    }
-
-    /**
-     * @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
-     */
-    /**
-     * Checks whether an object key contains potentially unsafe chars, thus the key should be wrapped in
-     * quotes. Note: we do not wrap all keys into quotes, as it may have impact on minification and may
-     * bot work in some cases when object keys are mangled by minifier.
-     *
-     * TODO(FW-1136): this is a temporary solution, we need to come up with a better way of working with
-     * inputs that contain potentially unsafe chars.
-     */
-    const UNSAFE_OBJECT_KEY_NAME_REGEXP = /[-.]/;
-    /** Name of the temporary to use during data binding */
-    const TEMPORARY_NAME = '_t';
-    /** Name of the context parameter passed into a template function */
-    const CONTEXT_NAME = 'ctx';
-    /** Name of the RenderFlag passed into a template function */
-    const RENDER_FLAGS = 'rf';
-    /** The prefix reference variables */
-    const REFERENCE_PREFIX = '_r';
-    /** The name of the implicit context reference */
-    const IMPLICIT_REFERENCE = '$implicit';
-    /** Non bindable attribute name **/
-    const NON_BINDABLE_ATTR = 'ngNonBindable';
-    /** Name for the variable keeping track of the context returned by `ɵɵrestoreView`. */
-    const RESTORED_VIEW_CONTEXT_NAME = 'restoredCtx';
-    /**
-     * Creates an allocator for a temporary variable.
-     *
-     * A variable declaration is added to the statements the first time the allocator is invoked.
-     */
-    function temporaryAllocator(statements, name) {
-        let temp = null;
-        return () => {
-            if (!temp) {
-                statements.push(new DeclareVarStmt(TEMPORARY_NAME, undefined, DYNAMIC_TYPE));
-                temp = variable(name);
+    class BoundEvent {
+        constructor(name, type, handler, target, phase, sourceSpan, handlerSpan, keySpan) {
+            this.name = name;
+            this.type = type;
+            this.handler = handler;
+            this.target = target;
+            this.phase = phase;
+            this.sourceSpan = sourceSpan;
+            this.handlerSpan = handlerSpan;
+            this.keySpan = keySpan;
+        }
+        static fromParsedEvent(event) {
+            const target = event.type === 0 /* Regular */ ? event.targetOrPhase : null;
+            const phase = event.type === 1 /* 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}`);
             }
-            return temp;
-        };
-    }
-    function unsupported(feature) {
-        if (this) {
-            throw new Error(`Builder ${this.constructor.name} doesn't support ${feature} yet`);
+            return new BoundEvent(event.name, event.type, event.handler, target, phase, event.sourceSpan, event.handlerSpan, event.keySpan);
         }
-        throw new Error(`Feature ${feature} is not supported yet`);
-    }
-    function invalid$1(arg) {
-        throw new Error(`Invalid state: Visitor ${this.constructor.name} doesn't handle ${arg.constructor.name}`);
-    }
-    function asLiteral(value) {
-        if (Array.isArray(value)) {
-            return literalArr(value.map(asLiteral));
+        visit(visitor) {
+            return visitor.visitBoundEvent(this);
         }
-        return literal(value, INFERRED_TYPE);
     }
-    function conditionallyCreateMapObjectLiteral(keys, keepDeclared) {
-        if (Object.getOwnPropertyNames(keys).length > 0) {
-            return mapToExpression(keys, keepDeclared);
+    class Element {
+        constructor(name, attributes, inputs, outputs, children, references, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
+            this.name = name;
+            this.attributes = attributes;
+            this.inputs = inputs;
+            this.outputs = outputs;
+            this.children = children;
+            this.references = references;
+            this.sourceSpan = sourceSpan;
+            this.startSourceSpan = startSourceSpan;
+            this.endSourceSpan = endSourceSpan;
+            this.i18n = i18n;
         }
-        return null;
-    }
-    function mapToExpression(map, keepDeclared) {
-        return literalMap(Object.getOwnPropertyNames(map).map(key => {
-            // canonical syntax: `dirProp: publicProp`
-            // if there is no `:`, use dirProp = elProp
-            const value = map[key];
-            let declaredName;
-            let publicName;
-            let minifiedName;
-            let needsDeclaredName;
-            if (Array.isArray(value)) {
-                [publicName, declaredName] = value;
-                minifiedName = key;
-                needsDeclaredName = publicName !== declaredName;
-            }
-            else {
-                [declaredName, publicName] = splitAtColon(key, [key, value]);
-                minifiedName = declaredName;
-                // Only include the declared name if extracted from the key, i.e. the key contains a colon.
-                // Otherwise the declared name should be omitted even if it is different from the public name,
-                // as it may have already been minified.
-                needsDeclaredName = publicName !== declaredName && key.includes(':');
-            }
-            return {
-                key: minifiedName,
-                // put quotes around keys that contain potentially unsafe characters
-                quoted: UNSAFE_OBJECT_KEY_NAME_REGEXP.test(minifiedName),
-                value: (keepDeclared && needsDeclaredName) ?
-                    literalArr([asLiteral(publicName), asLiteral(declaredName)]) :
-                    asLiteral(publicName)
-            };
-        }));
-    }
-    /**
-     *  Remove trailing null nodes as they are implied.
-     */
-    function trimTrailingNulls(parameters) {
-        while (isNull(parameters[parameters.length - 1])) {
-            parameters.pop();
+        visit(visitor) {
+            return visitor.visitElement(this);
         }
-        return parameters;
     }
-    function getQueryPredicate(query, constantPool) {
-        if (Array.isArray(query.predicate)) {
-            let predicate = [];
-            query.predicate.forEach((selector) => {
-                // Each item in predicates array may contain strings with comma-separated refs
-                // (for ex. 'ref, ref1, ..., refN'), thus we extract individual refs and store them
-                // as separate array entities
-                const selectors = selector.split(',').map(token => literal(token.trim()));
-                predicate.push(...selectors);
-            });
-            return constantPool.getConstLiteral(literalArr(predicate), true);
+    class Template {
+        constructor(tagName, attributes, inputs, outputs, templateAttrs, children, references, variables, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
+            this.tagName = tagName;
+            this.attributes = attributes;
+            this.inputs = inputs;
+            this.outputs = outputs;
+            this.templateAttrs = templateAttrs;
+            this.children = children;
+            this.references = references;
+            this.variables = variables;
+            this.sourceSpan = sourceSpan;
+            this.startSourceSpan = startSourceSpan;
+            this.endSourceSpan = endSourceSpan;
+            this.i18n = i18n;
         }
-        else {
-            return query.predicate;
+        visit(visitor) {
+            return visitor.visitTemplate(this);
         }
     }
-    /**
-     * A representation for an object literal used during codegen of definition objects. The generic
-     * type `T` allows to reference a documented type of the generated structure, such that the
-     * property names that are set can be resolved to their documented declaration.
-     */
-    class DefinitionMap {
-        constructor() {
-            this.values = [];
+    class Content {
+        constructor(selector, attributes, sourceSpan, i18n) {
+            this.selector = selector;
+            this.attributes = attributes;
+            this.sourceSpan = sourceSpan;
+            this.i18n = i18n;
+            this.name = 'ng-content';
         }
-        set(key, value) {
-            if (value) {
-                this.values.push({ key: key, value, quoted: false });
-            }
+        visit(visitor) {
+            return visitor.visitContent(this);
         }
-        toLiteralMap() {
-            return literalMap(this.values);
+    }
+    class Variable {
+        constructor(name, value, sourceSpan, keySpan, valueSpan) {
+            this.name = name;
+            this.value = value;
+            this.sourceSpan = sourceSpan;
+            this.keySpan = keySpan;
+            this.valueSpan = valueSpan;
+        }
+        visit(visitor) {
+            return visitor.visitVariable(this);
         }
     }
-    /**
-     * Extract a map of properties to values for a given element or template node, which can be used
-     * by the directive matching machinery.
-     *
-     * @param elOrTpl the element or template in question
-     * @return an object set up for directive matching. For attributes on the element/template, this
-     * object maps a property name to its (static) value. For any bindings, this map simply maps the
-     * property name to an empty string.
-     */
-    function getAttrsForDirectiveMatching(elOrTpl) {
-        const attributesMap = {};
-        if (elOrTpl instanceof Template && elOrTpl.tagName !== 'ng-template') {
-            elOrTpl.templateAttrs.forEach(a => attributesMap[a.name] = '');
+    class Reference {
+        constructor(name, value, sourceSpan, keySpan, valueSpan) {
+            this.name = name;
+            this.value = value;
+            this.sourceSpan = sourceSpan;
+            this.keySpan = keySpan;
+            this.valueSpan = valueSpan;
         }
-        else {
-            elOrTpl.attributes.forEach(a => {
-                if (!isI18nAttribute(a.name)) {
-                    attributesMap[a.name] = a.value;
-                }
-            });
-            elOrTpl.inputs.forEach(i => {
-                attributesMap[i.name] = '';
-            });
-            elOrTpl.outputs.forEach(o => {
-                attributesMap[o.name] = '';
-            });
+        visit(visitor) {
+            return visitor.visitReference(this);
         }
-        return attributesMap;
     }
-    /** Returns a call expression to a chained instruction, e.g. `property(params[0])(params[1])`. */
-    function chainedInstruction(reference, calls, span) {
-        let expression = importExpr(reference, null, span);
-        if (calls.length > 0) {
-            for (let i = 0; i < calls.length; i++) {
-                expression = expression.callFn(calls[i], span);
-            }
+    class Icu {
+        constructor(vars, placeholders, sourceSpan, i18n) {
+            this.vars = vars;
+            this.placeholders = placeholders;
+            this.sourceSpan = sourceSpan;
+            this.i18n = i18n;
         }
-        else {
-            // Add a blank invocation, in case the `calls` array is empty.
-            expression = expression.callFn([], span);
+        visit(visitor) {
+            return visitor.visitIcu(this);
         }
-        return expression;
     }
-    /**
-     * Gets the number of arguments expected to be passed to a generated instruction in the case of
-     * interpolation instructions.
-     * @param interpolation An interpolation ast
-     */
-    function getInterpolationArgsLength(interpolation) {
-        const { expressions, strings } = interpolation;
-        if (expressions.length === 1 && strings.length === 2 && strings[0] === '' && strings[1] === '') {
-            // If the interpolation has one interpolated value, but the prefix and suffix are both empty
-            // strings, we only pass one argument, to a special instruction like `propertyInterpolate` or
-            // `textInterpolate`.
-            return 1;
+    class RecursiveVisitor {
+        visitElement(element) {
+            visitAll(this, element.attributes);
+            visitAll(this, element.inputs);
+            visitAll(this, element.outputs);
+            visitAll(this, element.children);
+            visitAll(this, element.references);
+        }
+        visitTemplate(template) {
+            visitAll(this, template.attributes);
+            visitAll(this, template.inputs);
+            visitAll(this, template.outputs);
+            visitAll(this, template.children);
+            visitAll(this, template.references);
+            visitAll(this, template.variables);
+        }
+        visitContent(content) { }
+        visitVariable(variable) { }
+        visitReference(reference) { }
+        visitTextAttribute(attribute) { }
+        visitBoundAttribute(attribute) { }
+        visitBoundEvent(attribute) { }
+        visitText(text) { }
+        visitBoundText(text) { }
+        visitIcu(icu) { }
+    }
+    function visitAll(visitor, nodes) {
+        const result = [];
+        if (visitor.visit) {
+            for (const node of nodes) {
+                const newNode = visitor.visit(node) || node.visit(visitor);
+            }
         }
         else {
-            return expressions.length + strings.length;
+            for (const node of nodes) {
+                const newNode = node.visit(visitor);
+                if (newNode) {
+                    result.push(newNode);
+                }
+            }
         }
+        return result;
     }
 
     /**
@@ -3889,84 +3916,106 @@ 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
      */
-    /**
-     * Creates an array literal expression from the given array, mapping all values to an expression
-     * using the provided mapping function. If the array is empty or null, then null is returned.
-     *
-     * @param values The array to transfer into literal array expression.
-     * @param mapper The logic to use for creating an expression for the array's values.
-     * @returns An array literal expression representing `values`, or null if `values` is empty or
-     * is itself null.
-     */
-    function toOptionalLiteralArray(values, mapper) {
-        if (values === null || values.length === 0) {
-            return null;
+    class Message {
+        /**
+         * @param nodes message AST
+         * @param placeholders maps placeholder names to static content and their source spans
+         * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)
+         * @param meaning
+         * @param description
+         * @param customId
+         */
+        constructor(nodes, placeholders, placeholderToMessage, meaning, description, customId) {
+            this.nodes = nodes;
+            this.placeholders = placeholders;
+            this.placeholderToMessage = placeholderToMessage;
+            this.meaning = meaning;
+            this.description = description;
+            this.customId = customId;
+            this.id = this.customId;
+            /** The ids to use if there are no custom id and if `i18nLegacyMessageIdFormat` is not empty */
+            this.legacyIds = [];
+            if (nodes.length) {
+                this.sources = [{
+                        filePath: nodes[0].sourceSpan.start.file.url,
+                        startLine: nodes[0].sourceSpan.start.line + 1,
+                        startCol: nodes[0].sourceSpan.start.col + 1,
+                        endLine: nodes[nodes.length - 1].sourceSpan.end.line + 1,
+                        endCol: nodes[0].sourceSpan.start.col + 1
+                    }];
+            }
+            else {
+                this.sources = [];
+            }
         }
-        return literalArr(values.map(value => mapper(value)));
     }
-    /**
-     * Creates an object literal expression from the given object, mapping all values to an expression
-     * using the provided mapping function. If the object has no keys, then null is returned.
-     *
-     * @param object The object to transfer into an object literal expression.
-     * @param mapper The logic to use for creating an expression for the object's values.
-     * @returns An object literal expression representing `object`, or null if `object` does not have
-     * any keys.
-     */
-    function toOptionalLiteralMap(object, mapper) {
-        const entries = Object.keys(object).map(key => {
-            const value = object[key];
-            return { key, value: mapper(value), quoted: true };
-        });
-        if (entries.length > 0) {
-            return literalMap(entries);
+    class Text$1 {
+        constructor(value, sourceSpan) {
+            this.value = value;
+            this.sourceSpan = sourceSpan;
         }
-        else {
-            return null;
+        visit(visitor, context) {
+            return visitor.visitText(this, context);
         }
     }
-    function compileDependencies(deps) {
-        if (deps === 'invalid') {
-            // The `deps` can be set to the string "invalid"  by the `unwrapConstructorDependencies()`
-            // function, which tries to convert `ConstructorDeps` into `R3DependencyMetadata[]`.
-            return literal('invalid');
-        }
-        else if (deps === null) {
-            return literal(null);
+    // TODO(vicb): do we really need this node (vs an array) ?
+    class Container {
+        constructor(children, sourceSpan) {
+            this.children = children;
+            this.sourceSpan = sourceSpan;
         }
-        else {
-            return literalArr(deps.map(compileDependency));
+        visit(visitor, context) {
+            return visitor.visitContainer(this, context);
         }
     }
-    function compileDependency(dep) {
-        const depMeta = new DefinitionMap();
-        depMeta.set('token', dep.token);
-        if (dep.attributeNameType !== null) {
-            depMeta.set('attribute', literal(true));
+    class Icu$1 {
+        constructor(expression, type, cases, sourceSpan) {
+            this.expression = expression;
+            this.type = type;
+            this.cases = cases;
+            this.sourceSpan = sourceSpan;
         }
-        if (dep.host) {
-            depMeta.set('host', literal(true));
+        visit(visitor, context) {
+            return visitor.visitIcu(this, context);
         }
-        if (dep.optional) {
-            depMeta.set('optional', literal(true));
+    }
+    class TagPlaceholder {
+        constructor(tag, attrs, startName, closeName, children, isVoid, 
+        // TODO sourceSpan should cover all (we need a startSourceSpan and endSourceSpan)
+        sourceSpan, startSourceSpan, endSourceSpan) {
+            this.tag = tag;
+            this.attrs = attrs;
+            this.startName = startName;
+            this.closeName = closeName;
+            this.children = children;
+            this.isVoid = isVoid;
+            this.sourceSpan = sourceSpan;
+            this.startSourceSpan = startSourceSpan;
+            this.endSourceSpan = endSourceSpan;
         }
-        if (dep.self) {
-            depMeta.set('self', literal(true));
+        visit(visitor, context) {
+            return visitor.visitTagPlaceholder(this, context);
         }
-        if (dep.skipSelf) {
-            depMeta.set('skipSelf', literal(true));
+    }
+    class Placeholder {
+        constructor(value, name, sourceSpan) {
+            this.value = value;
+            this.name = name;
+            this.sourceSpan = sourceSpan;
+        }
+        visit(visitor, context) {
+            return visitor.visitPlaceholder(this, context);
         }
-        return depMeta.toLiteralMap();
     }
-    /**
-     * Generate an expression that has the given `expr` wrapped in the following form:
-     *
-     * ```
-     * forwardRef(() => expr)
-     * ```
-     */
-    function generateForwardRef(expr) {
-        return importExpr(Identifiers.forwardRef).callFn([fn([], [new ReturnStatement(expr)])]);
+    class IcuPlaceholder {
+        constructor(value, name, sourceSpan) {
+            this.value = value;
+            this.name = name;
+            this.sourceSpan = sourceSpan;
+        }
+        visit(visitor, context) {
+            return visitor.visitIcuPlaceholder(this, context);
+        }
     }
 
     /**
@@ -3976,146 +4025,177 @@ 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
      */
-    // https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
-    const VERSION = 3;
-    const JS_B64_PREFIX = '# sourceMappingURL=data:application/json;base64,';
-    class SourceMapGenerator {
-        constructor(file = null) {
-            this.file = file;
-            this.sourcesContent = new Map();
-            this.lines = [];
-            this.lastCol0 = 0;
-            this.hasMappings = false;
-        }
-        // The content is `null` when the content is expected to be loaded using the URL
-        addSource(url, content = null) {
-            if (!this.sourcesContent.has(url)) {
-                this.sourcesContent.set(url, content);
-            }
-            return this;
+    /**
+     * Represents a big integer using a buffer of its individual digits, with the least significant
+     * digit stored at the beginning of the array (little endian).
+     *
+     * For performance reasons, each instance is mutable. The addition operation can be done in-place
+     * to reduce memory pressure of allocation for the digits array.
+     */
+    class BigInteger {
+        /**
+         * Creates a big integer using its individual digits in little endian storage.
+         */
+        constructor(digits) {
+            this.digits = digits;
         }
-        addLine() {
-            this.lines.push([]);
-            this.lastCol0 = 0;
-            return this;
+        static zero() {
+            return new BigInteger([0]);
         }
-        addMapping(col0, sourceUrl, sourceLine0, sourceCol0) {
-            if (!this.currentLine) {
-                throw new Error(`A line must be added before mappings can be added`);
-            }
-            if (sourceUrl != null && !this.sourcesContent.has(sourceUrl)) {
-                throw new Error(`Unknown source file "${sourceUrl}"`);
-            }
-            if (col0 == null) {
-                throw new Error(`The column in the generated code must be provided`);
-            }
-            if (col0 < this.lastCol0) {
-                throw new Error(`Mapping should be added in output order`);
-            }
-            if (sourceUrl && (sourceLine0 == null || sourceCol0 == null)) {
-                throw new Error(`The source location must be provided when a source url is provided`);
-            }
-            this.hasMappings = true;
-            this.lastCol0 = col0;
-            this.currentLine.push({ col0, sourceUrl, sourceLine0, sourceCol0 });
-            return this;
+        static one() {
+            return new BigInteger([1]);
         }
         /**
-         * @internal strip this from published d.ts files due to
-         * https://github.com/microsoft/TypeScript/issues/36216
+         * Creates a clone of this instance.
          */
-        get currentLine() {
-            return this.lines.slice(-1)[0];
+        clone() {
+            return new BigInteger(this.digits.slice());
         }
-        toJSON() {
-            if (!this.hasMappings) {
-                return null;
+        /**
+         * Returns a new big integer with the sum of `this` and `other` as its value. This does not mutate
+         * `this` but instead returns a new instance, unlike `addToSelf`.
+         */
+        add(other) {
+            const result = this.clone();
+            result.addToSelf(other);
+            return result;
+        }
+        /**
+         * Adds `other` to the instance itself, thereby mutating its value.
+         */
+        addToSelf(other) {
+            const maxNrOfDigits = Math.max(this.digits.length, other.digits.length);
+            let carry = 0;
+            for (let i = 0; i < maxNrOfDigits; i++) {
+                let digitSum = carry;
+                if (i < this.digits.length) {
+                    digitSum += this.digits[i];
+                }
+                if (i < other.digits.length) {
+                    digitSum += other.digits[i];
+                }
+                if (digitSum >= 10) {
+                    this.digits[i] = digitSum - 10;
+                    carry = 1;
+                }
+                else {
+                    this.digits[i] = digitSum;
+                    carry = 0;
+                }
+            }
+            // Apply a remaining carry if needed.
+            if (carry > 0) {
+                this.digits[maxNrOfDigits] = 1;
             }
-            const sourcesIndex = new Map();
-            const sources = [];
-            const sourcesContent = [];
-            Array.from(this.sourcesContent.keys()).forEach((url, i) => {
-                sourcesIndex.set(url, i);
-                sources.push(url);
-                sourcesContent.push(this.sourcesContent.get(url) || null);
-            });
-            let mappings = '';
-            let lastCol0 = 0;
-            let lastSourceIndex = 0;
-            let lastSourceLine0 = 0;
-            let lastSourceCol0 = 0;
-            this.lines.forEach(segments => {
-                lastCol0 = 0;
-                mappings += segments
-                    .map(segment => {
-                    // zero-based starting column of the line in the generated code
-                    let segAsStr = toBase64VLQ(segment.col0 - lastCol0);
-                    lastCol0 = segment.col0;
-                    if (segment.sourceUrl != null) {
-                        // zero-based index into the “sources” list
-                        segAsStr +=
-                            toBase64VLQ(sourcesIndex.get(segment.sourceUrl) - lastSourceIndex);
-                        lastSourceIndex = sourcesIndex.get(segment.sourceUrl);
-                        // the zero-based starting line in the original source
-                        segAsStr += toBase64VLQ(segment.sourceLine0 - lastSourceLine0);
-                        lastSourceLine0 = segment.sourceLine0;
-                        // the zero-based starting column in the original source
-                        segAsStr += toBase64VLQ(segment.sourceCol0 - lastSourceCol0);
-                        lastSourceCol0 = segment.sourceCol0;
-                    }
-                    return segAsStr;
-                })
-                    .join(',');
-                mappings += ';';
-            });
-            mappings = mappings.slice(0, -1);
-            return {
-                'file': this.file || '',
-                'version': VERSION,
-                'sourceRoot': '',
-                'sources': sources,
-                'sourcesContent': sourcesContent,
-                'mappings': mappings,
-            };
         }
-        toJsComment() {
-            return this.hasMappings ? '//' + JS_B64_PREFIX + toBase64String(JSON.stringify(this, null, 0)) :
-                '';
+        /**
+         * Builds the decimal string representation of the big integer. As this is stored in
+         * little endian, the digits are concatenated in reverse order.
+         */
+        toString() {
+            let res = '';
+            for (let i = this.digits.length - 1; i >= 0; i--) {
+                res += this.digits[i];
+            }
+            return res;
         }
     }
-    function toBase64String(value) {
-        let b64 = '';
-        const encoded = utf8Encode(value);
-        for (let i = 0; i < encoded.length;) {
-            const i1 = encoded[i++];
-            const i2 = i < encoded.length ? encoded[i++] : null;
-            const i3 = i < encoded.length ? encoded[i++] : null;
-            b64 += toBase64Digit(i1 >> 2);
-            b64 += toBase64Digit(((i1 & 3) << 4) | (i2 === null ? 0 : i2 >> 4));
-            b64 += i2 === null ? '=' : toBase64Digit(((i2 & 15) << 2) | (i3 === null ? 0 : i3 >> 6));
-            b64 += i2 === null || i3 === null ? '=' : toBase64Digit(i3 & 63);
+    /**
+     * Represents a big integer which is optimized for multiplication operations, as its power-of-twos
+     * are memoized. See `multiplyBy()` for details on the multiplication algorithm.
+     */
+    class BigIntForMultiplication {
+        constructor(value) {
+            this.powerOfTwos = [value];
         }
-        return b64;
-    }
-    function toBase64VLQ(value) {
-        value = value < 0 ? ((-value) << 1) + 1 : value << 1;
-        let out = '';
-        do {
-            let digit = value & 31;
-            value = value >> 5;
-            if (value > 0) {
-                digit = digit | 32;
+        /**
+         * Returns the big integer itself.
+         */
+        getValue() {
+            return this.powerOfTwos[0];
+        }
+        /**
+         * Computes the value for `num * b`, where `num` is a JS number and `b` is a big integer. The
+         * value for `b` is represented by a storage model that is optimized for this computation.
+         *
+         * This operation is implemented in N(log2(num)) by continuous halving of the number, where the
+         * least-significant bit (LSB) is tested in each iteration. If the bit is set, the bit's index is
+         * used as exponent into the power-of-two multiplication of `b`.
+         *
+         * As an example, consider the multiplication num=42, b=1337. In binary 42 is 0b00101010 and the
+         * algorithm unrolls into the following iterations:
+         *
+         *  Iteration | num        | LSB  | b * 2^iter | Add? | product
+         * -----------|------------|------|------------|------|--------
+         *  0         | 0b00101010 | 0    | 1337       | No   | 0
+         *  1         | 0b00010101 | 1    | 2674       | Yes  | 2674
+         *  2         | 0b00001010 | 0    | 5348       | No   | 2674
+         *  3         | 0b00000101 | 1    | 10696      | Yes  | 13370
+         *  4         | 0b00000010 | 0    | 21392      | No   | 13370
+         *  5         | 0b00000001 | 1    | 42784      | Yes  | 56154
+         *  6         | 0b00000000 | 0    | 85568      | No   | 56154
+         *
+         * The computed product of 56154 is indeed the correct result.
+         *
+         * The `BigIntForMultiplication` representation for a big integer provides memoized access to the
+         * power-of-two values to reduce the workload in computing those values.
+         */
+        multiplyBy(num) {
+            const product = BigInteger.zero();
+            this.multiplyByAndAddTo(num, product);
+            return product;
+        }
+        /**
+         * See `multiplyBy()` for details. This function allows for the computed product to be added
+         * directly to the provided result big integer.
+         */
+        multiplyByAndAddTo(num, result) {
+            for (let exponent = 0; num !== 0; num = num >>> 1, exponent++) {
+                if (num & 1) {
+                    const value = this.getMultipliedByPowerOfTwo(exponent);
+                    result.addToSelf(value);
+                }
             }
-            out += toBase64Digit(digit);
-        } while (value > 0);
-        return out;
+        }
+        /**
+         * Computes and memoizes the big integer value for `this.number * 2^exponent`.
+         */
+        getMultipliedByPowerOfTwo(exponent) {
+            // Compute the powers up until the requested exponent, where each value is computed from its
+            // predecessor. This is simple as `this.number * 2^(exponent - 1)` only has to be doubled (i.e.
+            // added to itself) to reach `this.number * 2^exponent`.
+            for (let i = this.powerOfTwos.length; i <= exponent; i++) {
+                const previousPower = this.powerOfTwos[i - 1];
+                this.powerOfTwos[i] = previousPower.add(previousPower);
+            }
+            return this.powerOfTwos[exponent];
+        }
     }
-    const B64_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-    function toBase64Digit(value) {
-        if (value < 0 || value >= 64) {
-            throw new Error(`Can only encode value in the range [0, 63]`);
+    /**
+     * Represents an exponentiation operation for the provided base, of which exponents are computed and
+     * memoized. The results are represented by a `BigIntForMultiplication` which is tailored for
+     * multiplication operations by memoizing the power-of-twos. This effectively results in a matrix
+     * representation that is lazily computed upon request.
+     */
+    class BigIntExponentiation {
+        constructor(base) {
+            this.base = base;
+            this.exponents = [new BigIntForMultiplication(BigInteger.one())];
+        }
+        /**
+         * Compute the value for `this.base^exponent`, resulting in a big integer that is optimized for
+         * further multiplication operations.
+         */
+        toThePowerOf(exponent) {
+            // Compute the results up until the requested exponent, where every value is computed from its
+            // predecessor. This is because `this.base^(exponent - 1)` only has to be multiplied by `base`
+            // to reach `this.base^exponent`.
+            for (let i = this.exponents.length; i <= exponent; i++) {
+                const value = this.exponents[i - 1].multiplyBy(this.base);
+                this.exponents[i] = new BigIntForMultiplication(value);
+            }
+            return this.exponents[exponent];
         }
-        return B64_DIGITS[value];
     }
 
     /**
@@ -4125,566 +4205,476 @@ 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 _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\|\n|\r|\$/g;
-    const _LEGAL_IDENTIFIER_RE = /^[$A-Z_][0-9A-Z_$]*$/i;
-    const _INDENT_WITH = '  ';
-    const CATCH_ERROR_VAR$1 = variable('error', null, null);
-    const CATCH_STACK_VAR$1 = variable('stack', null, null);
-    class _EmittedLine {
-        constructor(indent) {
-            this.indent = indent;
-            this.partsLength = 0;
-            this.parts = [];
-            this.srcSpans = [];
-        }
+    /**
+     * Compute the message id using the XLIFF1 digest.
+     */
+    function computeDigest(message) {
+        return sha1(serializeNodes(message.nodes).join('') + `[${message.meaning}]`);
     }
-    class EmitterVisitorContext {
-        constructor(_indent) {
-            this._indent = _indent;
-            this._classes = [];
-            this._preambleLineCount = 0;
-            this._lines = [new _EmittedLine(_indent)];
-        }
-        static createRoot() {
-            return new EmitterVisitorContext(0);
-        }
-        /**
-         * @internal strip this from published d.ts files due to
-         * https://github.com/microsoft/TypeScript/issues/36216
-         */
-        get _currentLine() {
-            return this._lines[this._lines.length - 1];
-        }
-        println(from, lastPart = '') {
-            this.print(from || null, lastPart, true);
-        }
-        lineIsEmpty() {
-            return this._currentLine.parts.length === 0;
-        }
-        lineLength() {
-            return this._currentLine.indent * _INDENT_WITH.length + this._currentLine.partsLength;
-        }
-        print(from, part, newLine = false) {
-            if (part.length > 0) {
-                this._currentLine.parts.push(part);
-                this._currentLine.partsLength += part.length;
-                this._currentLine.srcSpans.push(from && from.sourceSpan || null);
-            }
-            if (newLine) {
-                this._lines.push(new _EmittedLine(this._indent));
-            }
-        }
-        removeEmptyLastLine() {
-            if (this.lineIsEmpty()) {
-                this._lines.pop();
-            }
+    /**
+     * Return the message id or compute it using the XLIFF2/XMB/$localize digest.
+     */
+    function decimalDigest(message) {
+        return message.id || computeDecimalDigest(message);
+    }
+    /**
+     * Compute the message id using the XLIFF2/XMB/$localize digest.
+     */
+    function computeDecimalDigest(message) {
+        const visitor = new _SerializerIgnoreIcuExpVisitor();
+        const parts = message.nodes.map(a => a.visit(visitor, null));
+        return computeMsgId(parts.join(''), message.meaning);
+    }
+    /**
+     * Serialize the i18n ast to something xml-like in order to generate an UID.
+     *
+     * The visitor is also used in the i18n parser tests
+     *
+     * @internal
+     */
+    class _SerializerVisitor {
+        visitText(text, context) {
+            return text.value;
         }
-        incIndent() {
-            this._indent++;
-            if (this.lineIsEmpty()) {
-                this._currentLine.indent = this._indent;
-            }
+        visitContainer(container, context) {
+            return `[${container.children.map(child => child.visit(this)).join(', ')}]`;
         }
-        decIndent() {
-            this._indent--;
-            if (this.lineIsEmpty()) {
-                this._currentLine.indent = this._indent;
-            }
+        visitIcu(icu, context) {
+            const strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
+            return `{${icu.expression}, ${icu.type}, ${strCases.join(', ')}}`;
         }
-        pushClass(clazz) {
-            this._classes.push(clazz);
+        visitTagPlaceholder(ph, context) {
+            return ph.isVoid ?
+                `<ph tag name="${ph.startName}"/>` :
+                `<ph tag name="${ph.startName}">${ph.children.map(child => child.visit(this)).join(', ')}</ph name="${ph.closeName}">`;
         }
-        popClass() {
-            return this._classes.pop();
+        visitPlaceholder(ph, context) {
+            return ph.value ? `<ph name="${ph.name}">${ph.value}</ph>` : `<ph name="${ph.name}"/>`;
         }
-        get currentClass() {
-            return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null;
+        visitIcuPlaceholder(ph, context) {
+            return `<ph icu name="${ph.name}">${ph.value.visit(this)}</ph>`;
         }
-        toSource() {
-            return this.sourceLines
-                .map(l => l.parts.length > 0 ? _createIndent(l.indent) + l.parts.join('') : '')
-                .join('\n');
+    }
+    const serializerVisitor = new _SerializerVisitor();
+    function serializeNodes(nodes) {
+        return nodes.map(a => a.visit(serializerVisitor, null));
+    }
+    /**
+     * Serialize the i18n ast to something xml-like in order to generate an UID.
+     *
+     * Ignore the ICU expressions so that message IDs stays identical if only the expression changes.
+     *
+     * @internal
+     */
+    class _SerializerIgnoreIcuExpVisitor extends _SerializerVisitor {
+        visitIcu(icu, context) {
+            let strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
+            // Do not take the expression into account
+            return `{${icu.type}, ${strCases.join(', ')}}`;
         }
-        toSourceMapGenerator(genFilePath, startsAtLine = 0) {
-            const map = new SourceMapGenerator(genFilePath);
-            let firstOffsetMapped = false;
-            const mapFirstOffsetIfNeeded = () => {
-                if (!firstOffsetMapped) {
-                    // Add a single space so that tools won't try to load the file from disk.
-                    // Note: We are using virtual urls like `ng:///`, so we have to
-                    // provide a content here.
-                    map.addSource(genFilePath, ' ').addMapping(0, genFilePath, 0, 0);
-                    firstOffsetMapped = true;
-                }
-            };
-            for (let i = 0; i < startsAtLine; i++) {
-                map.addLine();
-                mapFirstOffsetIfNeeded();
-            }
-            this.sourceLines.forEach((line, lineIdx) => {
-                map.addLine();
-                const spans = line.srcSpans;
-                const parts = line.parts;
-                let col0 = line.indent * _INDENT_WITH.length;
-                let spanIdx = 0;
-                // skip leading parts without source spans
-                while (spanIdx < spans.length && !spans[spanIdx]) {
-                    col0 += parts[spanIdx].length;
-                    spanIdx++;
-                }
-                if (spanIdx < spans.length && lineIdx === 0 && col0 === 0) {
-                    firstOffsetMapped = true;
+    }
+    /**
+     * Compute the SHA1 of the given string
+     *
+     * see https://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf
+     *
+     * WARNING: this function has not been designed not tested with security in mind.
+     *          DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.
+     */
+    function sha1(str) {
+        const utf8 = utf8Encode(str);
+        const words32 = bytesToWords32(utf8, Endian.Big);
+        const len = utf8.length * 8;
+        const w = newArray(80);
+        let a = 0x67452301, b = 0xefcdab89, c = 0x98badcfe, d = 0x10325476, e = 0xc3d2e1f0;
+        words32[len >> 5] |= 0x80 << (24 - len % 32);
+        words32[((len + 64 >> 9) << 4) + 15] = len;
+        for (let i = 0; i < words32.length; i += 16) {
+            const h0 = a, h1 = b, h2 = c, h3 = d, h4 = e;
+            for (let j = 0; j < 80; j++) {
+                if (j < 16) {
+                    w[j] = words32[i + j];
                 }
                 else {
-                    mapFirstOffsetIfNeeded();
-                }
-                while (spanIdx < spans.length) {
-                    const span = spans[spanIdx];
-                    const source = span.start.file;
-                    const sourceLine = span.start.line;
-                    const sourceCol = span.start.col;
-                    map.addSource(source.url, source.content)
-                        .addMapping(col0, source.url, sourceLine, sourceCol);
-                    col0 += parts[spanIdx].length;
-                    spanIdx++;
-                    // assign parts without span or the same span to the previous segment
-                    while (spanIdx < spans.length && (span === spans[spanIdx] || !spans[spanIdx])) {
-                        col0 += parts[spanIdx].length;
-                        spanIdx++;
-                    }
-                }
-            });
-            return map;
-        }
-        setPreambleLineCount(count) {
-            return this._preambleLineCount = count;
-        }
-        spanOf(line, column) {
-            const emittedLine = this._lines[line - this._preambleLineCount];
-            if (emittedLine) {
-                let columnsLeft = column - _createIndent(emittedLine.indent).length;
-                for (let partIndex = 0; partIndex < emittedLine.parts.length; partIndex++) {
-                    const part = emittedLine.parts[partIndex];
-                    if (part.length > columnsLeft) {
-                        return emittedLine.srcSpans[partIndex];
-                    }
-                    columnsLeft -= part.length;
+                    w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
                 }
+                const fkVal = fk(j, b, c, d);
+                const f = fkVal[0];
+                const k = fkVal[1];
+                const temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32);
+                e = d;
+                d = c;
+                c = rol32(b, 30);
+                b = a;
+                a = temp;
             }
-            return null;
-        }
-        /**
-         * @internal strip this from published d.ts files due to
-         * https://github.com/microsoft/TypeScript/issues/36216
-         */
-        get sourceLines() {
-            if (this._lines.length && this._lines[this._lines.length - 1].parts.length === 0) {
-                return this._lines.slice(0, -1);
-            }
-            return this._lines;
+            a = add32(a, h0);
+            b = add32(b, h1);
+            c = add32(c, h2);
+            d = add32(d, h3);
+            e = add32(e, h4);
         }
+        return bytesToHexString(words32ToByteString([a, b, c, d, e]));
     }
-    class AbstractEmitterVisitor {
-        constructor(_escapeDollarInStrings) {
-            this._escapeDollarInStrings = _escapeDollarInStrings;
-        }
-        printLeadingComments(stmt, ctx) {
-            if (stmt.leadingComments === undefined) {
-                return;
-            }
-            for (const comment of stmt.leadingComments) {
-                if (comment instanceof JSDocComment) {
-                    ctx.print(stmt, `/*${comment.toString()}*/`, comment.trailingNewline);
-                }
-                else {
-                    if (comment.multiline) {
-                        ctx.print(stmt, `/* ${comment.text} */`, comment.trailingNewline);
-                    }
-                    else {
-                        comment.text.split('\n').forEach((line) => {
-                            ctx.println(stmt, `// ${line}`);
-                        });
-                    }
-                }
-            }
+    function fk(index, b, c, d) {
+        if (index < 20) {
+            return [(b & c) | (~b & d), 0x5a827999];
         }
-        visitExpressionStmt(stmt, ctx) {
-            this.printLeadingComments(stmt, ctx);
-            stmt.expr.visitExpression(this, ctx);
-            ctx.println(stmt, ';');
-            return null;
+        if (index < 40) {
+            return [b ^ c ^ d, 0x6ed9eba1];
         }
-        visitReturnStmt(stmt, ctx) {
-            this.printLeadingComments(stmt, ctx);
-            ctx.print(stmt, `return `);
-            stmt.value.visitExpression(this, ctx);
-            ctx.println(stmt, ';');
-            return null;
+        if (index < 60) {
+            return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc];
         }
-        visitIfStmt(stmt, ctx) {
-            this.printLeadingComments(stmt, ctx);
-            ctx.print(stmt, `if (`);
-            stmt.condition.visitExpression(this, ctx);
-            ctx.print(stmt, `) {`);
-            const hasElseCase = stmt.falseCase != null && stmt.falseCase.length > 0;
-            if (stmt.trueCase.length <= 1 && !hasElseCase) {
-                ctx.print(stmt, ` `);
-                this.visitAllStatements(stmt.trueCase, ctx);
-                ctx.removeEmptyLastLine();
-                ctx.print(stmt, ` `);
-            }
-            else {
-                ctx.println();
-                ctx.incIndent();
-                this.visitAllStatements(stmt.trueCase, ctx);
-                ctx.decIndent();
-                if (hasElseCase) {
-                    ctx.println(stmt, `} else {`);
-                    ctx.incIndent();
-                    this.visitAllStatements(stmt.falseCase, ctx);
-                    ctx.decIndent();
-                }
-            }
-            ctx.println(stmt, `}`);
-            return null;
-        }
-        visitThrowStmt(stmt, ctx) {
-            this.printLeadingComments(stmt, ctx);
-            ctx.print(stmt, `throw `);
-            stmt.error.visitExpression(this, ctx);
-            ctx.println(stmt, `;`);
-            return null;
-        }
-        visitWriteVarExpr(expr, ctx) {
-            const lineWasEmpty = ctx.lineIsEmpty();
-            if (!lineWasEmpty) {
-                ctx.print(expr, '(');
-            }
-            ctx.print(expr, `${expr.name} = `);
-            expr.value.visitExpression(this, ctx);
-            if (!lineWasEmpty) {
-                ctx.print(expr, ')');
-            }
-            return null;
-        }
-        visitWriteKeyExpr(expr, ctx) {
-            const lineWasEmpty = ctx.lineIsEmpty();
-            if (!lineWasEmpty) {
-                ctx.print(expr, '(');
-            }
-            expr.receiver.visitExpression(this, ctx);
-            ctx.print(expr, `[`);
-            expr.index.visitExpression(this, ctx);
-            ctx.print(expr, `] = `);
-            expr.value.visitExpression(this, ctx);
-            if (!lineWasEmpty) {
-                ctx.print(expr, ')');
-            }
-            return null;
-        }
-        visitWritePropExpr(expr, ctx) {
-            const lineWasEmpty = ctx.lineIsEmpty();
-            if (!lineWasEmpty) {
-                ctx.print(expr, '(');
-            }
-            expr.receiver.visitExpression(this, ctx);
-            ctx.print(expr, `.${expr.name} = `);
-            expr.value.visitExpression(this, ctx);
-            if (!lineWasEmpty) {
-                ctx.print(expr, ')');
-            }
-            return null;
-        }
-        visitInvokeMethodExpr(expr, ctx) {
-            expr.receiver.visitExpression(this, ctx);
-            let name = expr.name;
-            if (expr.builtin != null) {
-                name = this.getBuiltinMethodName(expr.builtin);
-                if (name == null) {
-                    // some builtins just mean to skip the call.
-                    return null;
-                }
-            }
-            ctx.print(expr, `.${name}(`);
-            this.visitAllExpressions(expr.args, ctx, `,`);
-            ctx.print(expr, `)`);
-            return null;
-        }
-        visitInvokeFunctionExpr(expr, ctx) {
-            expr.fn.visitExpression(this, ctx);
-            ctx.print(expr, `(`);
-            this.visitAllExpressions(expr.args, ctx, ',');
-            ctx.print(expr, `)`);
-            return null;
-        }
-        visitTaggedTemplateExpr(expr, ctx) {
-            expr.tag.visitExpression(this, ctx);
-            ctx.print(expr, '`' + expr.template.elements[0].rawText);
-            for (let i = 1; i < expr.template.elements.length; i++) {
-                ctx.print(expr, '${');
-                expr.template.expressions[i - 1].visitExpression(this, ctx);
-                ctx.print(expr, `}${expr.template.elements[i].rawText}`);
-            }
-            ctx.print(expr, '`');
-            return null;
-        }
-        visitWrappedNodeExpr(ast, ctx) {
-            throw new Error('Abstract emitter cannot visit WrappedNodeExpr.');
-        }
-        visitTypeofExpr(expr, ctx) {
-            ctx.print(expr, 'typeof ');
-            expr.expr.visitExpression(this, ctx);
-        }
-        visitReadVarExpr(ast, ctx) {
-            let varName = ast.name;
-            if (ast.builtin != null) {
-                switch (ast.builtin) {
-                    case BuiltinVar.Super:
-                        varName = 'super';
-                        break;
-                    case BuiltinVar.This:
-                        varName = 'this';
-                        break;
-                    case BuiltinVar.CatchError:
-                        varName = CATCH_ERROR_VAR$1.name;
-                        break;
-                    case BuiltinVar.CatchStack:
-                        varName = CATCH_STACK_VAR$1.name;
-                        break;
-                    default:
-                        throw new Error(`Unknown builtin variable ${ast.builtin}`);
-                }
-            }
-            ctx.print(ast, varName);
-            return null;
-        }
-        visitInstantiateExpr(ast, ctx) {
-            ctx.print(ast, `new `);
-            ast.classExpr.visitExpression(this, ctx);
-            ctx.print(ast, `(`);
-            this.visitAllExpressions(ast.args, ctx, ',');
-            ctx.print(ast, `)`);
-            return null;
-        }
-        visitLiteralExpr(ast, ctx) {
-            const value = ast.value;
-            if (typeof value === 'string') {
-                ctx.print(ast, escapeIdentifier(value, this._escapeDollarInStrings));
-            }
-            else {
-                ctx.print(ast, `${value}`);
-            }
-            return null;
-        }
-        visitLocalizedString(ast, ctx) {
-            const head = ast.serializeI18nHead();
-            ctx.print(ast, '$localize `' + head.raw);
-            for (let i = 1; i < ast.messageParts.length; i++) {
-                ctx.print(ast, '${');
-                ast.expressions[i - 1].visitExpression(this, ctx);
-                ctx.print(ast, `}${ast.serializeI18nTemplatePart(i).raw}`);
-            }
-            ctx.print(ast, '`');
-            return null;
-        }
-        visitConditionalExpr(ast, ctx) {
-            ctx.print(ast, `(`);
-            ast.condition.visitExpression(this, ctx);
-            ctx.print(ast, '? ');
-            ast.trueCase.visitExpression(this, ctx);
-            ctx.print(ast, ': ');
-            ast.falseCase.visitExpression(this, ctx);
-            ctx.print(ast, `)`);
-            return null;
-        }
-        visitNotExpr(ast, ctx) {
-            ctx.print(ast, '!');
-            ast.condition.visitExpression(this, ctx);
-            return null;
-        }
-        visitAssertNotNullExpr(ast, ctx) {
-            ast.condition.visitExpression(this, ctx);
-            return null;
-        }
-        visitUnaryOperatorExpr(ast, ctx) {
-            let opStr;
-            switch (ast.operator) {
-                case UnaryOperator.Plus:
-                    opStr = '+';
-                    break;
-                case UnaryOperator.Minus:
-                    opStr = '-';
-                    break;
-                default:
-                    throw new Error(`Unknown operator ${ast.operator}`);
-            }
-            if (ast.parens)
-                ctx.print(ast, `(`);
-            ctx.print(ast, opStr);
-            ast.expr.visitExpression(this, ctx);
-            if (ast.parens)
-                ctx.print(ast, `)`);
-            return null;
-        }
-        visitBinaryOperatorExpr(ast, ctx) {
-            let opStr;
-            switch (ast.operator) {
-                case BinaryOperator.Equals:
-                    opStr = '==';
-                    break;
-                case BinaryOperator.Identical:
-                    opStr = '===';
-                    break;
-                case BinaryOperator.NotEquals:
-                    opStr = '!=';
-                    break;
-                case BinaryOperator.NotIdentical:
-                    opStr = '!==';
-                    break;
-                case BinaryOperator.And:
-                    opStr = '&&';
-                    break;
-                case BinaryOperator.BitwiseAnd:
-                    opStr = '&';
-                    break;
-                case BinaryOperator.Or:
-                    opStr = '||';
-                    break;
-                case BinaryOperator.Plus:
-                    opStr = '+';
-                    break;
-                case BinaryOperator.Minus:
-                    opStr = '-';
-                    break;
-                case BinaryOperator.Divide:
-                    opStr = '/';
-                    break;
-                case BinaryOperator.Multiply:
-                    opStr = '*';
-                    break;
-                case BinaryOperator.Modulo:
-                    opStr = '%';
-                    break;
-                case BinaryOperator.Lower:
-                    opStr = '<';
-                    break;
-                case BinaryOperator.LowerEquals:
-                    opStr = '<=';
-                    break;
-                case BinaryOperator.Bigger:
-                    opStr = '>';
-                    break;
-                case BinaryOperator.BiggerEquals:
-                    opStr = '>=';
-                    break;
-                case BinaryOperator.NullishCoalesce:
-                    opStr = '??';
-                    break;
-                default:
-                    throw new Error(`Unknown operator ${ast.operator}`);
-            }
-            if (ast.parens)
-                ctx.print(ast, `(`);
-            ast.lhs.visitExpression(this, ctx);
-            ctx.print(ast, ` ${opStr} `);
-            ast.rhs.visitExpression(this, ctx);
-            if (ast.parens)
-                ctx.print(ast, `)`);
-            return null;
-        }
-        visitReadPropExpr(ast, ctx) {
-            ast.receiver.visitExpression(this, ctx);
-            ctx.print(ast, `.`);
-            ctx.print(ast, ast.name);
-            return null;
-        }
-        visitReadKeyExpr(ast, ctx) {
-            ast.receiver.visitExpression(this, ctx);
-            ctx.print(ast, `[`);
-            ast.index.visitExpression(this, ctx);
-            ctx.print(ast, `]`);
-            return null;
-        }
-        visitLiteralArrayExpr(ast, ctx) {
-            ctx.print(ast, `[`);
-            this.visitAllExpressions(ast.entries, ctx, ',');
-            ctx.print(ast, `]`);
-            return null;
+        return [b ^ c ^ d, 0xca62c1d6];
+    }
+    /**
+     * Compute the fingerprint of the given string
+     *
+     * The output is 64 bit number encoded as a decimal string
+     *
+     * based on:
+     * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java
+     */
+    function fingerprint(str) {
+        const utf8 = utf8Encode(str);
+        let hi = hash32(utf8, 0);
+        let lo = hash32(utf8, 102072);
+        if (hi == 0 && (lo == 0 || lo == 1)) {
+            hi = hi ^ 0x130f9bef;
+            lo = lo ^ -0x6b5f56d8;
         }
-        visitLiteralMapExpr(ast, ctx) {
-            ctx.print(ast, `{`);
-            this.visitAllObjects(entry => {
-                ctx.print(ast, `${escapeIdentifier(entry.key, this._escapeDollarInStrings, entry.quoted)}:`);
-                entry.value.visitExpression(this, ctx);
-            }, ast.entries, ctx, ',');
-            ctx.print(ast, `}`);
-            return null;
+        return [hi, lo];
+    }
+    function computeMsgId(msg, meaning = '') {
+        let msgFingerprint = fingerprint(msg);
+        if (meaning) {
+            const meaningFingerprint = fingerprint(meaning);
+            msgFingerprint = add64(rol64(msgFingerprint, 1), meaningFingerprint);
         }
-        visitCommaExpr(ast, ctx) {
-            ctx.print(ast, '(');
-            this.visitAllExpressions(ast.parts, ctx, ',');
-            ctx.print(ast, ')');
-            return null;
+        const hi = msgFingerprint[0];
+        const lo = msgFingerprint[1];
+        return wordsToDecimalString(hi & 0x7fffffff, lo);
+    }
+    function hash32(bytes, c) {
+        let a = 0x9e3779b9, b = 0x9e3779b9;
+        let i;
+        const len = bytes.length;
+        for (i = 0; i + 12 <= len; i += 12) {
+            a = add32(a, wordAt(bytes, i, Endian.Little));
+            b = add32(b, wordAt(bytes, i + 4, Endian.Little));
+            c = add32(c, wordAt(bytes, i + 8, Endian.Little));
+            const res = mix(a, b, c);
+            a = res[0], b = res[1], c = res[2];
         }
-        visitAllExpressions(expressions, ctx, separator) {
-            this.visitAllObjects(expr => expr.visitExpression(this, ctx), expressions, ctx, separator);
+        a = add32(a, wordAt(bytes, i, Endian.Little));
+        b = add32(b, wordAt(bytes, i + 4, Endian.Little));
+        // the first byte of c is reserved for the length
+        c = add32(c, len);
+        c = add32(c, wordAt(bytes, i + 8, Endian.Little) << 8);
+        return mix(a, b, c)[2];
+    }
+    // clang-format off
+    function mix(a, b, c) {
+        a = sub32(a, b);
+        a = sub32(a, c);
+        a ^= c >>> 13;
+        b = sub32(b, c);
+        b = sub32(b, a);
+        b ^= a << 8;
+        c = sub32(c, a);
+        c = sub32(c, b);
+        c ^= b >>> 13;
+        a = sub32(a, b);
+        a = sub32(a, c);
+        a ^= c >>> 12;
+        b = sub32(b, c);
+        b = sub32(b, a);
+        b ^= a << 16;
+        c = sub32(c, a);
+        c = sub32(c, b);
+        c ^= b >>> 5;
+        a = sub32(a, b);
+        a = sub32(a, c);
+        a ^= c >>> 3;
+        b = sub32(b, c);
+        b = sub32(b, a);
+        b ^= a << 10;
+        c = sub32(c, a);
+        c = sub32(c, b);
+        c ^= b >>> 15;
+        return [a, b, c];
+    }
+    // clang-format on
+    // Utils
+    var Endian;
+    (function (Endian) {
+        Endian[Endian["Little"] = 0] = "Little";
+        Endian[Endian["Big"] = 1] = "Big";
+    })(Endian || (Endian = {}));
+    function add32(a, b) {
+        return add32to64(a, b)[1];
+    }
+    function add32to64(a, b) {
+        const low = (a & 0xffff) + (b & 0xffff);
+        const high = (a >>> 16) + (b >>> 16) + (low >>> 16);
+        return [high >>> 16, (high << 16) | (low & 0xffff)];
+    }
+    function add64(a, b) {
+        const ah = a[0], al = a[1];
+        const bh = b[0], bl = b[1];
+        const result = add32to64(al, bl);
+        const carry = result[0];
+        const l = result[1];
+        const h = add32(add32(ah, bh), carry);
+        return [h, l];
+    }
+    function sub32(a, b) {
+        const low = (a & 0xffff) - (b & 0xffff);
+        const high = (a >> 16) - (b >> 16) + (low >> 16);
+        return (high << 16) | (low & 0xffff);
+    }
+    // Rotate a 32b number left `count` position
+    function rol32(a, count) {
+        return (a << count) | (a >>> (32 - count));
+    }
+    // Rotate a 64b number left `count` position
+    function rol64(num, count) {
+        const hi = num[0], lo = num[1];
+        const h = (hi << count) | (lo >>> (32 - count));
+        const l = (lo << count) | (hi >>> (32 - count));
+        return [h, l];
+    }
+    function bytesToWords32(bytes, endian) {
+        const size = (bytes.length + 3) >>> 2;
+        const words32 = [];
+        for (let i = 0; i < size; i++) {
+            words32[i] = wordAt(bytes, i * 4, endian);
         }
-        visitAllObjects(handler, expressions, ctx, separator) {
-            let incrementedIndent = false;
-            for (let i = 0; i < expressions.length; i++) {
-                if (i > 0) {
-                    if (ctx.lineLength() > 80) {
-                        ctx.print(null, separator, true);
-                        if (!incrementedIndent) {
-                            // continuation are marked with double indent.
-                            ctx.incIndent();
-                            ctx.incIndent();
-                            incrementedIndent = true;
-                        }
-                    }
-                    else {
-                        ctx.print(null, separator, false);
-                    }
-                }
-                handler(expressions[i]);
+        return words32;
+    }
+    function byteAt(bytes, index) {
+        return index >= bytes.length ? 0 : bytes[index];
+    }
+    function wordAt(bytes, index, endian) {
+        let word = 0;
+        if (endian === Endian.Big) {
+            for (let i = 0; i < 4; i++) {
+                word += byteAt(bytes, index + i) << (24 - 8 * i);
             }
-            if (incrementedIndent) {
-                // continuation are marked with double indent.
-                ctx.decIndent();
-                ctx.decIndent();
+        }
+        else {
+            for (let i = 0; i < 4; i++) {
+                word += byteAt(bytes, index + i) << 8 * i;
             }
         }
-        visitAllStatements(statements, ctx) {
-            statements.forEach((stmt) => stmt.visitStatement(this, ctx));
+        return word;
+    }
+    function words32ToByteString(words32) {
+        return words32.reduce((bytes, word) => bytes.concat(word32ToByteString(word)), []);
+    }
+    function word32ToByteString(word) {
+        let bytes = [];
+        for (let i = 0; i < 4; i++) {
+            bytes.push((word >>> 8 * (3 - i)) & 0xff);
         }
+        return bytes;
     }
-    function escapeIdentifier(input, escapeDollar, alwaysQuote = true) {
-        if (input == null) {
-            return null;
+    function bytesToHexString(bytes) {
+        let hex = '';
+        for (let i = 0; i < bytes.length; i++) {
+            const b = byteAt(bytes, i);
+            hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16);
         }
-        const body = input.replace(_SINGLE_QUOTE_ESCAPE_STRING_RE, (...match) => {
-            if (match[0] == '$') {
-                return escapeDollar ? '\\$' : '$';
-            }
-            else if (match[0] == '\n') {
-                return '\\n';
-            }
-            else if (match[0] == '\r') {
-                return '\\r';
-            }
-            else {
-                return `\\${match[0]}`;
-            }
+        return hex.toLowerCase();
+    }
+    /**
+     * Create a shared exponentiation pool for base-256 computations. This shared pool provides memoized
+     * power-of-256 results with memoized power-of-two computations for efficient multiplication.
+     *
+     * For our purposes, this can be safely stored as a global without memory concerns. The reason is
+     * that we encode two words, so only need the 0th (for the low word) and 4th (for the high word)
+     * exponent.
+     */
+    const base256 = new BigIntExponentiation(256);
+    /**
+     * Represents two 32-bit words as a single decimal number. This requires a big integer storage
+     * model as JS numbers are not accurate enough to represent the 64-bit number.
+     *
+     * Based on https://www.danvk.org/hex2dec.html
+     */
+    function wordsToDecimalString(hi, lo) {
+        // Encode the four bytes in lo in the lower digits of the decimal number.
+        // Note: the multiplication results in lo itself but represented by a big integer using its
+        // decimal digits.
+        const decimal = base256.toThePowerOf(0).multiplyBy(lo);
+        // Encode the four bytes in hi above the four lo bytes. lo is a maximum of (2^8)^4, which is why
+        // this multiplication factor is applied.
+        base256.toThePowerOf(4).multiplyByAndAddTo(hi, decimal);
+        return decimal.toString();
+    }
+
+    /**
+     * @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
+     */
+    // XMB/XTB placeholders can only contain A-Z, 0-9 and _
+    function toPublicName(internalName) {
+        return internalName.toUpperCase().replace(/[^A-Z0-9_]/g, '_');
+    }
+
+    /**
+     * @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
+     */
+    /* Closure variables holding messages must be named `MSG_[A-Z0-9]+` */
+    const CLOSURE_TRANSLATION_VAR_PREFIX = 'MSG_';
+    /**
+     * Prefix for non-`goog.getMsg` i18n-related vars.
+     * Note: the prefix uses lowercase characters intentionally due to a Closure behavior that
+     * considers variables like `I18N_0` as constants and throws an error when their value changes.
+     */
+    const TRANSLATION_VAR_PREFIX = 'i18n_';
+    /** Name of the i18n attributes **/
+    const I18N_ATTR = 'i18n';
+    const I18N_ATTR_PREFIX = 'i18n-';
+    /** Prefix of var expressions used in ICUs */
+    const I18N_ICU_VAR_PREFIX = 'VAR_';
+    /** Prefix of ICU expressions for post processing */
+    const I18N_ICU_MAPPING_PREFIX = 'I18N_EXP_';
+    /** Placeholder wrapper for i18n expressions **/
+    const I18N_PLACEHOLDER_SYMBOL = '�';
+    function isI18nAttribute(name) {
+        return name === I18N_ATTR || name.startsWith(I18N_ATTR_PREFIX);
+    }
+    function isI18nRootNode(meta) {
+        return meta instanceof Message;
+    }
+    function isSingleI18nIcu(meta) {
+        return isI18nRootNode(meta) && meta.nodes.length === 1 && meta.nodes[0] instanceof Icu$1;
+    }
+    function hasI18nMeta(node) {
+        return !!node.i18n;
+    }
+    function hasI18nAttrs(element) {
+        return element.attrs.some((attr) => isI18nAttribute(attr.name));
+    }
+    function icuFromI18nMessage(message) {
+        return message.nodes[0];
+    }
+    function wrapI18nPlaceholder(content, contextId = 0) {
+        const blockId = contextId > 0 ? `:${contextId}` : '';
+        return `${I18N_PLACEHOLDER_SYMBOL}${content}${blockId}${I18N_PLACEHOLDER_SYMBOL}`;
+    }
+    function assembleI18nBoundString(strings, bindingStartIndex = 0, contextId = 0) {
+        if (!strings.length)
+            return '';
+        let acc = '';
+        const lastIdx = strings.length - 1;
+        for (let i = 0; i < lastIdx; i++) {
+            acc += `${strings[i]}${wrapI18nPlaceholder(bindingStartIndex + i, contextId)}`;
+        }
+        acc += strings[lastIdx];
+        return acc;
+    }
+    function getSeqNumberGenerator(startsAt = 0) {
+        let current = startsAt;
+        return () => current++;
+    }
+    function placeholdersToParams(placeholders) {
+        const params = {};
+        placeholders.forEach((values, key) => {
+            params[key] = literal(values.length > 1 ? `[${values.join('|')}]` : values[0]);
         });
-        const requiresQuotes = alwaysQuote || !_LEGAL_IDENTIFIER_RE.test(body);
-        return requiresQuotes ? `'${body}'` : body;
+        return params;
     }
-    function _createIndent(count) {
-        let res = '';
-        for (let i = 0; i < count; i++) {
-            res += _INDENT_WITH;
+    function updatePlaceholderMap(map, name, ...values) {
+        const current = map.get(name) || [];
+        current.push(...values);
+        map.set(name, current);
+    }
+    function assembleBoundTextPlaceholders(meta, bindingStartIndex = 0, contextId = 0) {
+        const startIdx = bindingStartIndex;
+        const placeholders = new Map();
+        const node = meta instanceof Message ? meta.nodes.find(node => node instanceof Container) : meta;
+        if (node) {
+            node
+                .children
+                .filter((child) => child instanceof Placeholder)
+                .forEach((child, idx) => {
+                const content = wrapI18nPlaceholder(startIdx + idx, contextId);
+                updatePlaceholderMap(placeholders, child.name, content);
+            });
         }
-        return res;
+        return placeholders;
+    }
+    /**
+     * Format the placeholder names in a map of placeholders to expressions.
+     *
+     * The placeholder names are converted from "internal" format (e.g. `START_TAG_DIV_1`) to "external"
+     * format (e.g. `startTagDiv_1`).
+     *
+     * @param params A map of placeholder names to expressions.
+     * @param useCamelCase whether to camelCase the placeholder name when formatting.
+     * @returns A new map of formatted placeholder names to expressions.
+     */
+    function i18nFormatPlaceholderNames(params = {}, useCamelCase) {
+        const _params = {};
+        if (params && Object.keys(params).length) {
+            Object.keys(params).forEach(key => _params[formatI18nPlaceholderName(key, useCamelCase)] = params[key]);
+        }
+        return _params;
+    }
+    /**
+     * Converts internal placeholder names to public-facing format
+     * (for example to use in goog.getMsg call).
+     * Example: `START_TAG_DIV_1` is converted to `startTagDiv_1`.
+     *
+     * @param name The placeholder name that should be formatted
+     * @returns Formatted placeholder name
+     */
+    function formatI18nPlaceholderName(name, useCamelCase = true) {
+        const publicName = toPublicName(name);
+        if (!useCamelCase) {
+            return publicName;
+        }
+        const chunks = publicName.split('_');
+        if (chunks.length === 1) {
+            // if no "_" found - just lowercase the value
+            return name.toLowerCase();
+        }
+        let postfix;
+        // eject last element if it's a number
+        if (/^\d+$/.test(chunks[chunks.length - 1])) {
+            postfix = chunks.pop();
+        }
+        let raw = chunks.shift().toLowerCase();
+        if (chunks.length) {
+            raw += chunks.map(c => c.charAt(0).toUpperCase() + c.slice(1).toLowerCase()).join('');
+        }
+        return postfix ? `${raw}_${postfix}` : raw;
+    }
+    /**
+     * Generates a prefix for translation const name.
+     *
+     * @param extra Additional local prefix that should be injected into translation var name
+     * @returns Complete translation const prefix
+     */
+    function getTranslationConstPrefix(extra) {
+        return `${CLOSURE_TRANSLATION_VAR_PREFIX}${extra}`.toUpperCase();
+    }
+    /**
+     * Generate AST to declare a variable. E.g. `var I18N_1;`.
+     * @param variable the name of the variable to declare.
+     */
+    function declareI18nVariable(variable) {
+        return new DeclareVarStmt(variable.name, undefined, INFERRED_TYPE, undefined, variable.sourceSpan);
     }
 
     /**
@@ -4694,242 +4684,205 @@ 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
      */
-    function typeWithParameters(type, numParams) {
-        if (numParams === 0) {
-            return expressionType(type);
-        }
-        const params = [];
-        for (let i = 0; i < numParams; i++) {
-            params.push(DYNAMIC_TYPE);
-        }
-        return expressionType(type, undefined, params);
-    }
-    const ANIMATE_SYMBOL_PREFIX = '@';
-    function prepareSyntheticPropertyName(name) {
-        return `${ANIMATE_SYMBOL_PREFIX}${name}`;
-    }
-    function prepareSyntheticListenerName(name, phase) {
-        return `${ANIMATE_SYMBOL_PREFIX}${name}.${phase}`;
-    }
-    function getSafePropertyAccessString(accessor, name) {
-        const escapedName = escapeIdentifier(name, false, false);
-        return escapedName !== name ? `${accessor}[${escapedName}]` : `${accessor}.${name}`;
-    }
-    function prepareSyntheticListenerFunctionName(name, phase) {
-        return `animation_${name}_${phase}`;
-    }
-    function jitOnlyGuardedExpression(expr) {
-        return guardedExpression('ngJitMode', expr);
-    }
-    function devOnlyGuardedExpression(expr) {
-        return guardedExpression('ngDevMode', expr);
-    }
-    function guardedExpression(guard, expr) {
-        const guardExpr = new ExternalExpr({ name: guard, moduleName: null });
-        const guardNotDefined = new BinaryOperatorExpr(BinaryOperator.Identical, new TypeofExpr(guardExpr), literal('undefined'));
-        const guardUndefinedOrTrue = new BinaryOperatorExpr(BinaryOperator.Or, guardNotDefined, guardExpr, /* type */ undefined, 
-        /* sourceSpan */ undefined, true);
-        return new BinaryOperatorExpr(BinaryOperator.And, guardUndefinedOrTrue, expr);
-    }
-    function wrapReference(value) {
-        const wrapped = new WrappedNodeExpr(value);
-        return { value: wrapped, type: wrapped };
-    }
-    function refsToArray(refs, shouldForwardDeclare) {
-        const values = literalArr(refs.map(ref => ref.value));
-        return shouldForwardDeclare ? fn([], [new ReturnStatement(values)]) : values;
-    }
-
-    var R3FactoryDelegateType;
-    (function (R3FactoryDelegateType) {
-        R3FactoryDelegateType[R3FactoryDelegateType["Class"] = 0] = "Class";
-        R3FactoryDelegateType[R3FactoryDelegateType["Function"] = 1] = "Function";
-    })(R3FactoryDelegateType || (R3FactoryDelegateType = {}));
-    var FactoryTarget;
-    (function (FactoryTarget) {
-        FactoryTarget[FactoryTarget["Directive"] = 0] = "Directive";
-        FactoryTarget[FactoryTarget["Component"] = 1] = "Component";
-        FactoryTarget[FactoryTarget["Injectable"] = 2] = "Injectable";
-        FactoryTarget[FactoryTarget["Pipe"] = 3] = "Pipe";
-        FactoryTarget[FactoryTarget["NgModule"] = 4] = "NgModule";
-    })(FactoryTarget || (FactoryTarget = {}));
     /**
-     * Construct a factory function expression for the given `R3FactoryMetadata`.
+     * Checks whether an object key contains potentially unsafe chars, thus the key should be wrapped in
+     * quotes. Note: we do not wrap all keys into quotes, as it may have impact on minification and may
+     * bot work in some cases when object keys are mangled by minifier.
+     *
+     * TODO(FW-1136): this is a temporary solution, we need to come up with a better way of working with
+     * inputs that contain potentially unsafe chars.
      */
-    function compileFactoryFunction(meta) {
-        const t = variable('t');
-        let baseFactoryVar = null;
-        // The type to instantiate via constructor invocation. If there is no delegated factory, meaning
-        // this type is always created by constructor invocation, then this is the type-to-create
-        // parameter provided by the user (t) if specified, or the current type if not. If there is a
-        // delegated factory (which is used to create the current type) then this is only the type-to-
-        // create parameter (t).
-        const typeForCtor = !isDelegatedFactoryMetadata(meta) ?
-            new BinaryOperatorExpr(BinaryOperator.Or, t, meta.internalType) :
-            t;
-        let ctorExpr = null;
-        if (meta.deps !== null) {
-            // There is a constructor (either explicitly or implicitly defined).
-            if (meta.deps !== 'invalid') {
-                ctorExpr = new InstantiateExpr(typeForCtor, injectDependencies(meta.deps, meta.target));
+    const UNSAFE_OBJECT_KEY_NAME_REGEXP = /[-.]/;
+    /** Name of the temporary to use during data binding */
+    const TEMPORARY_NAME = '_t';
+    /** Name of the context parameter passed into a template function */
+    const CONTEXT_NAME = 'ctx';
+    /** Name of the RenderFlag passed into a template function */
+    const RENDER_FLAGS = 'rf';
+    /** The prefix reference variables */
+    const REFERENCE_PREFIX = '_r';
+    /** The name of the implicit context reference */
+    const IMPLICIT_REFERENCE = '$implicit';
+    /** Non bindable attribute name **/
+    const NON_BINDABLE_ATTR = 'ngNonBindable';
+    /** Name for the variable keeping track of the context returned by `ɵɵrestoreView`. */
+    const RESTORED_VIEW_CONTEXT_NAME = 'restoredCtx';
+    /**
+     * Creates an allocator for a temporary variable.
+     *
+     * A variable declaration is added to the statements the first time the allocator is invoked.
+     */
+    function temporaryAllocator(statements, name) {
+        let temp = null;
+        return () => {
+            if (!temp) {
+                statements.push(new DeclareVarStmt(TEMPORARY_NAME, undefined, DYNAMIC_TYPE));
+                temp = variable(name);
             }
-        }
-        else {
-            // There is no constructor, use the base class' factory to construct typeForCtor.
-            baseFactoryVar = variable(`ɵ${meta.name}_BaseFactory`);
-            ctorExpr = baseFactoryVar.callFn([typeForCtor]);
-        }
-        const body = [];
-        let retExpr = null;
-        function makeConditionalFactory(nonCtorExpr) {
-            const r = variable('r');
-            body.push(r.set(NULL_EXPR).toDeclStmt());
-            const ctorStmt = ctorExpr !== null ? r.set(ctorExpr).toStmt() :
-                importExpr(Identifiers.invalidFactory).callFn([]).toStmt();
-            body.push(ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()]));
-            return r;
-        }
-        if (isDelegatedFactoryMetadata(meta)) {
-            // This type is created with a delegated factory. If a type parameter is not specified, call
-            // the factory instead.
-            const delegateArgs = injectDependencies(meta.delegateDeps, meta.target);
-            // Either call `new delegate(...)` or `delegate(...)` depending on meta.delegateType.
-            const factoryExpr = new (meta.delegateType === R3FactoryDelegateType.Class ?
-                InstantiateExpr :
-                InvokeFunctionExpr)(meta.delegate, delegateArgs);
-            retExpr = makeConditionalFactory(factoryExpr);
-        }
-        else if (isExpressionFactoryMetadata(meta)) {
-            // TODO(alxhub): decide whether to lower the value here or in the caller
-            retExpr = makeConditionalFactory(meta.expression);
-        }
-        else {
-            retExpr = ctorExpr;
-        }
-        if (retExpr === null) {
-            // The expression cannot be formed so render an `ɵɵinvalidFactory()` call.
-            body.push(importExpr(Identifiers.invalidFactory).callFn([]).toStmt());
-        }
-        else if (baseFactoryVar !== null) {
-            // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it.
-            const getInheritedFactoryCall = importExpr(Identifiers.getInheritedFactory).callFn([meta.internalType]);
-            // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`
-            const baseFactory = new BinaryOperatorExpr(BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
-            body.push(new ReturnStatement(baseFactory.callFn([typeForCtor])));
-        }
-        else {
-            // This is straightforward factory, just return it.
-            body.push(new ReturnStatement(retExpr));
-        }
-        let factoryFn = fn([new FnParam('t', DYNAMIC_TYPE)], body, INFERRED_TYPE, undefined, `${meta.name}_Factory`);
-        if (baseFactoryVar !== null) {
-            // There is a base factory variable so wrap its declaration along with the factory function into
-            // an IIFE.
-            factoryFn = fn([], [
-                new DeclareVarStmt(baseFactoryVar.name), new ReturnStatement(factoryFn)
-            ]).callFn([], /* sourceSpan */ undefined, /* pure */ true);
-        }
-        return {
-            expression: factoryFn,
-            statements: [],
-            type: createFactoryType(meta),
+            return temp;
         };
     }
-    function createFactoryType(meta) {
-        const ctorDepsType = meta.deps !== null && meta.deps !== 'invalid' ? createCtorDepsType(meta.deps) : NONE_TYPE;
-        return expressionType(importExpr(Identifiers.FactoryDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount), ctorDepsType]));
+    function unsupported(feature) {
+        if (this) {
+            throw new Error(`Builder ${this.constructor.name} doesn't support ${feature} yet`);
+        }
+        throw new Error(`Feature ${feature} is not supported yet`);
     }
-    function injectDependencies(deps, target) {
-        return deps.map((dep, index) => compileInjectDependency(dep, target, index));
+    function invalid$1(arg) {
+        throw new Error(`Invalid state: Visitor ${this.constructor.name} doesn't handle ${arg.constructor.name}`);
     }
-    function compileInjectDependency(dep, target, index) {
-        // Interpret the dependency according to its resolved type.
-        if (dep.token === null) {
-            return importExpr(Identifiers.invalidFactoryDep).callFn([literal(index)]);
+    function asLiteral(value) {
+        if (Array.isArray(value)) {
+            return literalArr(value.map(asLiteral));
         }
-        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 === FactoryTarget.Pipe ? 16 /* 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;
-            // Build up the arguments to the injectFn call.
-            const injectArgs = [dep.token];
-            if (flagsParam) {
-                injectArgs.push(flagsParam);
-            }
-            const injectFn = getInjectFn(target);
-            return importExpr(injectFn).callFn(injectArgs);
+        return literal(value, INFERRED_TYPE);
+    }
+    function conditionallyCreateMapObjectLiteral(keys, keepDeclared) {
+        if (Object.getOwnPropertyNames(keys).length > 0) {
+            return mapToExpression(keys, keepDeclared);
         }
-        else {
-            // The `dep.attributeTypeName` value is defined, which indicates that this is an `@Attribute()`
-            // type dependency. For the generated JS we still want to use the `dep.token` value in case the
-            // name given for the attribute is not a string literal. For example given `@Attribute(foo())`,
-            // we want to generate `ɵɵinjectAttribute(foo())`.
-            //
-            // The `dep.attributeTypeName` is only actually used (in `createCtorDepType()`) to generate
-            // typings.
-            return importExpr(Identifiers.injectAttribute).callFn([dep.token]);
+        return null;
+    }
+    function mapToExpression(map, keepDeclared) {
+        return literalMap(Object.getOwnPropertyNames(map).map(key => {
+            // canonical syntax: `dirProp: publicProp`
+            // if there is no `:`, use dirProp = elProp
+            const value = map[key];
+            let declaredName;
+            let publicName;
+            let minifiedName;
+            let needsDeclaredName;
+            if (Array.isArray(value)) {
+                [publicName, declaredName] = value;
+                minifiedName = key;
+                needsDeclaredName = publicName !== declaredName;
+            }
+            else {
+                [declaredName, publicName] = splitAtColon(key, [key, value]);
+                minifiedName = declaredName;
+                // Only include the declared name if extracted from the key, i.e. the key contains a colon.
+                // Otherwise the declared name should be omitted even if it is different from the public name,
+                // as it may have already been minified.
+                needsDeclaredName = publicName !== declaredName && key.includes(':');
+            }
+            return {
+                key: minifiedName,
+                // put quotes around keys that contain potentially unsafe characters
+                quoted: UNSAFE_OBJECT_KEY_NAME_REGEXP.test(minifiedName),
+                value: (keepDeclared && needsDeclaredName) ?
+                    literalArr([asLiteral(publicName), asLiteral(declaredName)]) :
+                    asLiteral(publicName)
+            };
+        }));
+    }
+    /**
+     *  Remove trailing null nodes as they are implied.
+     */
+    function trimTrailingNulls(parameters) {
+        while (isNull(parameters[parameters.length - 1])) {
+            parameters.pop();
         }
+        return parameters;
     }
-    function createCtorDepsType(deps) {
-        let hasTypes = false;
-        const attributeTypes = deps.map(dep => {
-            const type = createCtorDepType(dep);
-            if (type !== null) {
-                hasTypes = true;
-                return type;
-            }
-            else {
-                return literal(null);
-            }
-        });
-        if (hasTypes) {
-            return expressionType(literalArr(attributeTypes));
+    function getQueryPredicate(query, constantPool) {
+        if (Array.isArray(query.predicate)) {
+            let predicate = [];
+            query.predicate.forEach((selector) => {
+                // Each item in predicates array may contain strings with comma-separated refs
+                // (for ex. 'ref, ref1, ..., refN'), thus we extract individual refs and store them
+                // as separate array entities
+                const selectors = selector.split(',').map(token => literal(token.trim()));
+                predicate.push(...selectors);
+            });
+            return constantPool.getConstLiteral(literalArr(predicate), true);
         }
         else {
-            return NONE_TYPE;
+            // The original predicate may have been wrapped in a `forwardRef()` call.
+            switch (query.predicate.forwardRef) {
+                case 0 /* None */:
+                case 2 /* Unwrapped */:
+                    return query.predicate.expression;
+                case 1 /* Wrapped */:
+                    return importExpr(Identifiers.resolveForwardRef).callFn([query.predicate.expression]);
+            }
         }
     }
-    function createCtorDepType(dep) {
-        const entries = [];
-        if (dep.attributeNameType !== null) {
-            entries.push({ key: 'attribute', value: dep.attributeNameType, quoted: false });
+    /**
+     * A representation for an object literal used during codegen of definition objects. The generic
+     * type `T` allows to reference a documented type of the generated structure, such that the
+     * property names that are set can be resolved to their documented declaration.
+     */
+    class DefinitionMap {
+        constructor() {
+            this.values = [];
         }
-        if (dep.optional) {
-            entries.push({ key: 'optional', value: literal(true), quoted: false });
+        set(key, value) {
+            if (value) {
+                this.values.push({ key: key, value, quoted: false });
+            }
         }
-        if (dep.host) {
-            entries.push({ key: 'host', value: literal(true), quoted: false });
+        toLiteralMap() {
+            return literalMap(this.values);
         }
-        if (dep.self) {
-            entries.push({ key: 'self', value: literal(true), quoted: false });
+    }
+    /**
+     * Extract a map of properties to values for a given element or template node, which can be used
+     * by the directive matching machinery.
+     *
+     * @param elOrTpl the element or template in question
+     * @return an object set up for directive matching. For attributes on the element/template, this
+     * object maps a property name to its (static) value. For any bindings, this map simply maps the
+     * property name to an empty string.
+     */
+    function getAttrsForDirectiveMatching(elOrTpl) {
+        const attributesMap = {};
+        if (elOrTpl instanceof Template && elOrTpl.tagName !== 'ng-template') {
+            elOrTpl.templateAttrs.forEach(a => attributesMap[a.name] = '');
         }
-        if (dep.skipSelf) {
-            entries.push({ key: 'skipSelf', value: literal(true), quoted: false });
+        else {
+            elOrTpl.attributes.forEach(a => {
+                if (!isI18nAttribute(a.name)) {
+                    attributesMap[a.name] = a.value;
+                }
+            });
+            elOrTpl.inputs.forEach(i => {
+                attributesMap[i.name] = '';
+            });
+            elOrTpl.outputs.forEach(o => {
+                attributesMap[o.name] = '';
+            });
         }
-        return entries.length > 0 ? literalMap(entries) : null;
-    }
-    function isDelegatedFactoryMetadata(meta) {
-        return meta.delegateType !== undefined;
+        return attributesMap;
     }
-    function isExpressionFactoryMetadata(meta) {
-        return meta.expression !== undefined;
+    /** Returns a call expression to a chained instruction, e.g. `property(params[0])(params[1])`. */
+    function chainedInstruction(reference, calls, span) {
+        let expression = importExpr(reference, null, span);
+        if (calls.length > 0) {
+            for (let i = 0; i < calls.length; i++) {
+                expression = expression.callFn(calls[i], span);
+            }
+        }
+        else {
+            // Add a blank invocation, in case the `calls` array is empty.
+            expression = expression.callFn([], span);
+        }
+        return expression;
     }
-    function getInjectFn(target) {
-        switch (target) {
-            case FactoryTarget.Component:
-            case FactoryTarget.Directive:
-            case FactoryTarget.Pipe:
-                return Identifiers.directiveInject;
-            case FactoryTarget.NgModule:
-            case FactoryTarget.Injectable:
-            default:
-                return Identifiers.inject;
+    /**
+     * Gets the number of arguments expected to be passed to a generated instruction in the case of
+     * interpolation instructions.
+     * @param interpolation An interpolation ast
+     */
+    function getInterpolationArgsLength(interpolation) {
+        const { expressions, strings } = interpolation;
+        if (expressions.length === 1 && strings.length === 2 && strings[0] === '' && strings[1] === '') {
+            // If the interpolation has one interpolated value, but the prefix and suffix are both empty
+            // strings, we only pass one argument, to a special instruction like `propertyInterpolate` or
+            // `textInterpolate`.
+            return 1;
+        }
+        else {
+            return expressions.length + strings.length;
         }
     }
 
@@ -4940,9 +4893,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
      */
-    function createR3ProviderExpression(expression, isForwardRef) {
-        return { expression, isForwardRef };
-    }
     function compileInjectable(meta, resolveForwardRefs) {
         let result = null;
         const factoryMeta = {
@@ -5012,8 +4962,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         injectableProps.set('factory', result.expression);
         // Only generate providedIn property if it has a non-null value
         if (meta.providedIn.expression.value !== null) {
-            injectableProps.set('providedIn', meta.providedIn.isForwardRef ? generateForwardRef(meta.providedIn.expression) :
-                meta.providedIn.expression);
+            injectableProps.set('providedIn', convertFromMaybeForwardRefExpression(meta.providedIn));
         }
         const expression = importExpr(Identifiers.ɵɵdefineInjectable)
             .callFn([injectableProps.toLiteralMap()], undefined, true);
@@ -19817,22 +19766,27 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     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: Array.isArray(facade.predicate) ? facade.predicate :
-                new WrappedNodeExpr(facade.predicate), read: facade.read ? new WrappedNodeExpr(facade.read) : null, static: facade.static, emitDistinctChangesOnly: facade.emitDistinctChangesOnly });
+        return Object.assign(Object.assign({}, facade), { predicate: convertQueryPredicate(facade.predicate), read: facade.read ? new WrappedNodeExpr(facade.read) : null, static: facade.static, emitDistinctChangesOnly: facade.emitDistinctChangesOnly });
     }
     function convertQueryDeclarationToMetadata(declaration) {
         var _a, _b, _c, _d;
         return {
             propertyName: declaration.propertyName,
             first: (_a = declaration.first) !== null && _a !== void 0 ? _a : false,
-            predicate: Array.isArray(declaration.predicate) ? declaration.predicate :
-                new WrappedNodeExpr(declaration.predicate),
+            predicate: convertQueryPredicate(declaration.predicate),
             descendants: (_b = declaration.descendants) !== null && _b !== void 0 ? _b : false,
             read: declaration.read ? new WrappedNodeExpr(declaration.read) : null,
             static: (_c = declaration.static) !== null && _c !== void 0 ? _c : false,
             emitDistinctChangesOnly: (_d = declaration.emitDistinctChangesOnly) !== null && _d !== void 0 ? _d : true,
         };
     }
+    function convertQueryPredicate(predicate) {
+        return Array.isArray(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 */);
+    }
     function convertDirectiveFacadeToMetadata(facade) {
         const inputsFromMetadata = parseInputOutputs(facade.inputs || []);
         const outputsFromMetadata = parseInputOutputs(facade.outputs || []);
@@ -19943,11 +19897,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * In JIT mode we do not want the compiler to wrap the expression in a `forwardRef()` call because,
      * if it is referencing a type that has not yet been defined, it will have already been wrapped in
      * a `forwardRef()` - either by the application developer or during partial-compilation. Thus we can
-     * set `isForwardRef` to `false`.
+     * use `ForwardRefHandling.None`.
      */
     function convertToProviderExpression(obj, property) {
         if (obj.hasOwnProperty(property)) {
-            return createR3ProviderExpression(new WrappedNodeExpr(obj[property]), /* isForwardRef */ false);
+            return createMayBeForwardRefExpression(new WrappedNodeExpr(obj[property]), 0 /* None */);
         }
         else {
             return undefined;
@@ -19966,7 +19920,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             new LiteralExpr(providedIn !== null && providedIn !== void 0 ? providedIn : null) :
             new WrappedNodeExpr(providedIn);
         // See `convertToProviderExpression()` for why `isForwardRef` is false.
-        return createR3ProviderExpression(expression, /* isForwardRef */ false);
+        return createMayBeForwardRefExpression(expression, 0 /* None */);
     }
     function convertR3DependencyMetadataArray(facades) {
         return facades == null ? null : facades.map(convertR3DependencyMetadata);
@@ -20074,7 +20028,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.10');
+    const VERSION$1 = new Version('12.2.14');
 
     /**
      * @license
@@ -20713,7 +20667,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.10'));
+        definitionMap.set('version', literal('12.2.14'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', metadata.type);
         definitionMap.set('decorators', metadata.decorators);
@@ -20722,6 +20676,83 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         return importExpr(Identifiers.declareClassMetadata).callFn([definitionMap.toLiteralMap()]);
     }
 
+    /**
+     * @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
+     */
+    /**
+     * Creates an array literal expression from the given array, mapping all values to an expression
+     * using the provided mapping function. If the array is empty or null, then null is returned.
+     *
+     * @param values The array to transfer into literal array expression.
+     * @param mapper The logic to use for creating an expression for the array's values.
+     * @returns An array literal expression representing `values`, or null if `values` is empty or
+     * is itself null.
+     */
+    function toOptionalLiteralArray(values, mapper) {
+        if (values === null || values.length === 0) {
+            return null;
+        }
+        return literalArr(values.map(value => mapper(value)));
+    }
+    /**
+     * Creates an object literal expression from the given object, mapping all values to an expression
+     * using the provided mapping function. If the object has no keys, then null is returned.
+     *
+     * @param object The object to transfer into an object literal expression.
+     * @param mapper The logic to use for creating an expression for the object's values.
+     * @returns An object literal expression representing `object`, or null if `object` does not have
+     * any keys.
+     */
+    function toOptionalLiteralMap(object, mapper) {
+        const entries = Object.keys(object).map(key => {
+            const value = object[key];
+            return { key, value: mapper(value), quoted: true };
+        });
+        if (entries.length > 0) {
+            return literalMap(entries);
+        }
+        else {
+            return null;
+        }
+    }
+    function compileDependencies(deps) {
+        if (deps === 'invalid') {
+            // The `deps` can be set to the string "invalid"  by the `unwrapConstructorDependencies()`
+            // function, which tries to convert `ConstructorDeps` into `R3DependencyMetadata[]`.
+            return literal('invalid');
+        }
+        else if (deps === null) {
+            return literal(null);
+        }
+        else {
+            return literalArr(deps.map(compileDependency));
+        }
+    }
+    function compileDependency(dep) {
+        const depMeta = new DefinitionMap();
+        depMeta.set('token', dep.token);
+        if (dep.attributeNameType !== null) {
+            depMeta.set('attribute', literal(true));
+        }
+        if (dep.host) {
+            depMeta.set('host', literal(true));
+        }
+        if (dep.optional) {
+            depMeta.set('optional', literal(true));
+        }
+        if (dep.self) {
+            depMeta.set('self', literal(true));
+        }
+        if (dep.skipSelf) {
+            depMeta.set('skipSelf', literal(true));
+        }
+        return depMeta.toLiteralMap();
+    }
+
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -20753,7 +20784,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.10'));
+        definitionMap.set('version', literal('12.2.14'));
         // e.g. `type: MyDirective`
         definitionMap.set('type', meta.internalType);
         // e.g. `selector: 'some-dir'`
@@ -20792,7 +20823,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         if (query.first) {
             meta.set('first', literal(true));
         }
-        meta.set('predicate', Array.isArray(query.predicate) ? asLiteral(query.predicate) : query.predicate);
+        meta.set('predicate', Array.isArray(query.predicate) ? asLiteral(query.predicate) :
+            convertFromMaybeForwardRefExpression(query.predicate));
         if (!query.emitDistinctChangesOnly) {
             // `emitDistinctChangesOnly` is special because we expect it to be `true`.
             // Therefore we explicitly emit the field, and explicitly place it only when it's `false`.
@@ -20970,7 +21002,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.10'));
+        definitionMap.set('version', literal('12.2.14'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('deps', compileDependencies(meta.deps));
@@ -21012,24 +21044,24 @@ 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.10'));
+        definitionMap.set('version', literal('12.2.14'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // Only generate providedIn property if it has a non-null value
         if (meta.providedIn !== undefined) {
-            const providedIn = convertFromProviderExpression(meta.providedIn);
+            const providedIn = convertFromMaybeForwardRefExpression(meta.providedIn);
             if (providedIn.value !== null) {
                 definitionMap.set('providedIn', providedIn);
             }
         }
         if (meta.useClass !== undefined) {
-            definitionMap.set('useClass', convertFromProviderExpression(meta.useClass));
+            definitionMap.set('useClass', convertFromMaybeForwardRefExpression(meta.useClass));
         }
         if (meta.useExisting !== undefined) {
-            definitionMap.set('useExisting', convertFromProviderExpression(meta.useExisting));
+            definitionMap.set('useExisting', convertFromMaybeForwardRefExpression(meta.useExisting));
         }
         if (meta.useValue !== undefined) {
-            definitionMap.set('useValue', convertFromProviderExpression(meta.useValue));
+            definitionMap.set('useValue', convertFromMaybeForwardRefExpression(meta.useValue));
         }
         // Factories do not contain `ForwardRef`s since any types are already wrapped in a function call
         // so the types will not be eagerly evaluated. Therefore we do not need to process this expression
@@ -21042,27 +21074,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         return definitionMap;
     }
-    /**
-     * Convert an `R3ProviderExpression` to an `Expression`, possibly wrapping its expression in a
-     * `forwardRef()` call.
-     *
-     * If `R3ProviderExpression.isForwardRef` is true then the expression was originally wrapped in a
-     * `forwardRef()` call to prevent the value from being eagerly evaluated in the code.
-     *
-     * Normally, the linker will statically process the code, putting the `expression` inside a factory
-     * function so the `forwardRef()` wrapper is not evaluated before it has been defined. But if the
-     * partial declaration is evaluated by the JIT compiler the `forwardRef()` call is still needed to
-     * prevent eager evaluation of the `expression`.
-     *
-     * So in partial declarations, expressions that could be forward-refs are wrapped in `forwardRef()`
-     * calls, and this is then unwrapped in the linker as necessary.
-     *
-     * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and
-     * `packages/compiler/src/jit_compiler_facade.ts` for more information.
-     */
-    function convertFromProviderExpression({ expression, isForwardRef }) {
-        return isForwardRef ? generateForwardRef(expression) : expression;
-    }
 
     /**
      * @license
@@ -21091,7 +21102,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.10'));
+        definitionMap.set('version', literal('12.2.14'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('providers', meta.providers);
@@ -21128,7 +21139,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.10'));
+        definitionMap.set('version', literal('12.2.14'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // We only generate the keys in the metadata if the arrays contain values.
@@ -21186,7 +21197,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.10'));
+        definitionMap.set('version', literal('12.2.14'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         // e.g. `type: MyPipe`
         definitionMap.set('type', meta.internalType);
@@ -21218,7 +21229,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.10');
+    const VERSION$2 = new Version('12.2.14');
 
     /**
      * @license
@@ -21468,15 +21479,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          */
         ErrorCode[ErrorCode["SUGGEST_SUBOPTIMAL_TYPE_INFERENCE"] = 10002] = "SUGGEST_SUBOPTIMAL_TYPE_INFERENCE";
     })(ErrorCode || (ErrorCode = {}));
+
     /**
-     * @internal
-     * Base URL for the error details page.
-     * Keep this value in sync with a similar const in
-     * `packages/core/src/render3/error_code.ts`.
+     * @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
      */
-    const ERROR_DETAILS_PAGE_BASE_URL = 'https://angular.io/errors';
     /**
-     * @internal
      * Contains a set of error messages that have detailed guides at angular.io.
      * Full list of available error guides can be found at https://angular.io/errors
      */
@@ -21489,8 +21500,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         ErrorCode.MISSING_REFERENCE_TARGET,
         ErrorCode.COMPONENT_INVALID_SHADOW_DOM_SELECTOR,
     ]);
+
     /**
-     * @internal
+     * @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
      */
     function ngErrorCode(code) {
         return parseInt('-99' + code);
@@ -21542,6 +21558,22 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         };
     }
 
+    /**
+     * @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
+     */
+    /**
+     * Base URL for the error details page.
+     *
+     * Keep the files below in sync:
+     *  - packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.ts
+     *  - packages/core/src/render3/error_details_base_url.ts
+     */
+    const ERROR_DETAILS_PAGE_BASE_URL = 'https://angular.io/errors';
+
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -29444,12 +29476,12 @@ Either add the @Injectable() decorator to '${provider.node.name
         };
     }
     function extractQueryMetadata(exprNode, name, args, propertyName, reflector, evaluator) {
-        var _a;
         if (args.length === 0) {
             throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, exprNode, `@${name} must have arguments`);
         }
         const first = name === 'ViewChild' || name === 'ContentChild';
-        const node = (_a = tryUnwrapForwardRef(args[0], reflector)) !== null && _a !== void 0 ? _a : args[0];
+        const forwardReferenceTarget = tryUnwrapForwardRef(args[0], reflector);
+        const node = forwardReferenceTarget !== null && forwardReferenceTarget !== void 0 ? forwardReferenceTarget : args[0];
         const arg = evaluator.evaluate(node);
         /** Whether or not this query should collect only static results (see view/api.ts)  */
         let isStatic = false;
@@ -29457,7 +29489,7 @@ Either add the @Injectable() decorator to '${provider.node.name
         let predicate = null;
         if (arg instanceof Reference$1 || arg instanceof DynamicValue) {
             // References and predicates that could not be evaluated statically are emitted as is.
-            predicate = new WrappedNodeExpr(node);
+            predicate = createMayBeForwardRefExpression(new WrappedNodeExpr(node), forwardReferenceTarget !== null ? 2 /* Unwrapped */ : 0 /* None */);
         }
         else if (typeof arg === 'string') {
             predicate = [arg];
@@ -31463,7 +31495,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                 type,
                 typeArgumentCount,
                 internalType,
-                providedIn: createR3ProviderExpression(new LiteralExpr(null), false),
+                providedIn: createMayBeForwardRefExpression(new LiteralExpr(null), 0 /* None */),
             };
         }
         else if (decorator.args.length === 1) {
@@ -31478,7 +31510,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             const meta = reflectObjectLiteral(metaNode);
             const providedIn = meta.has('providedIn') ?
                 getProviderExpression(meta.get('providedIn'), reflector) :
-                createR3ProviderExpression(new LiteralExpr(null), false);
+                createMayBeForwardRefExpression(new LiteralExpr(null), 0 /* None */);
             let deps = undefined;
             if ((meta.has('useClass') || meta.has('useFactory')) && meta.has('deps')) {
                 const depsExpr = meta.get('deps');
@@ -31517,7 +31549,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      */
     function getProviderExpression(expression, reflector) {
         const forwardRefValue = tryUnwrapForwardRef(expression, reflector);
-        return createR3ProviderExpression(new WrappedNodeExpr(forwardRefValue !== null && forwardRefValue !== void 0 ? forwardRefValue : expression), forwardRefValue !== null);
+        return createMayBeForwardRefExpression(new WrappedNodeExpr(forwardRefValue !== null && forwardRefValue !== void 0 ? forwardRefValue : expression), forwardRefValue !== null ? 2 /* Unwrapped */ : 0 /* None */);
     }
     function extractInjectableCtorDeps(clazz, meta, decorator, reflector, isCore, strictCtorDeps) {
         if (decorator.args === null) {