static-injector 1.0.9 → 2.0.0

package/transform/compiler-cli/src/ngtsc/transform/src/utils.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -36,15 +40,16 @@ const ts = __importStar(require("typescript"));
 function addImports(importManager, sf, extraStatements = []) {
     // Generate the import statements to prepend.
     const addedImports = importManager.getAllImports(sf.fileName).map((i) => {
-        const qualifier = ts.createIdentifier(i.qualifier.text);
-        const importClause = ts.createImportClause(
+        const qualifier = ts.factory.createIdentifier(i.qualifier.text);
+        const importClause = ts.factory.createImportClause(
+        /* isTypeOnly */ false, 
         /* name */ undefined, 
-        /* namedBindings */ ts.createNamespaceImport(qualifier));
-        const decl = ts.createImportDeclaration(
+        /* namedBindings */ ts.factory.createNamespaceImport(qualifier));
+        const decl = ts.factory.createImportDeclaration(
         /* decorators */ undefined, 
         /* modifiers */ undefined, 
         /* importClause */ importClause, 
-        /* moduleSpecifier */ ts.createLiteral(i.specifier));
+        /* moduleSpecifier */ ts.factory.createStringLiteral(i.specifier));
         // Set the qualifier's original TS node to the `ts.ImportDeclaration`. This allows downstream
         // transforms such as tsickle to properly process references to this import.
         //
@@ -65,8 +70,8 @@ function addImports(importManager, sf, extraStatements = []) {
         // If we prepend imports, we also prepend NotEmittedStatement to use it as an anchor
         // for @fileoverview Closure annotation. If there is no @fileoverview annotations, this
         // statement would be a noop.
-        const fileoverviewAnchorStmt = ts.createNotEmittedStatement(sf);
-        return ts.updateSourceFileNode(sf, ts.createNodeArray([
+        const fileoverviewAnchorStmt = ts.factory.createNotEmittedStatement(sf);
+        return ts.factory.updateSourceFile(sf, ts.factory.createNodeArray([
             fileoverviewAnchorStmt,
             ...existingImports,
             ...addedImports,

package/transform/compiler-cli/src/ngtsc/translator/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/transform/compiler-cli/src/ngtsc/translator/src/import_manager.d.ts

@@ -5,9 +5,9 @@
  * 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
  */
-import * as ts from "typescript";
-import { ImportRewriter } from "../../imports";
-import { ImportGenerator, NamedImport } from "./api/import_generator";
+import * as ts from 'typescript';
+import { ImportRewriter } from '../../imports';
+import { ImportGenerator, NamedImport } from './api/import_generator';
 /**
  * Information about an import that has been added to a module.
  */

package/transform/compiler-cli/src/ngtsc/translator/src/import_manager.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -30,7 +34,7 @@ exports.ImportManager = void 0;
 const ts = __importStar(require("typescript"));
 const imports_1 = require("../../imports");
 class ImportManager {
-    constructor(rewriter = new imports_1.NoopImportRewriter(), prefix = "i") {
+    constructor(rewriter = new imports_1.NoopImportRewriter(), prefix = 'i') {
         this.rewriter = rewriter;
         this.prefix = prefix;
         this.specifierToIdentifier = new Map();
@@ -38,7 +42,7 @@ class ImportManager {
     }
     generateNamespaceImport(moduleName) {
         if (!this.specifierToIdentifier.has(moduleName)) {
-            this.specifierToIdentifier.set(moduleName, ts.createIdentifier(`${this.prefix}${this.nextIndex++}`));
+            this.specifierToIdentifier.set(moduleName, ts.factory.createIdentifier(`${this.prefix}${this.nextIndex++}`));
         }
         return this.specifierToIdentifier.get(moduleName);
     }

package/transform/compiler-cli/src/ngtsc/translator/src/translator.d.ts

@@ -27,21 +27,17 @@ export declare class ExpressionTranslatorVisitor<TStatement, TExpression> implem
     visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, context: Context): TStatement;
     visitExpressionStmt(stmt: o.ExpressionStatement, context: Context): TStatement;
     visitReturnStmt(stmt: o.ReturnStatement, context: Context): TStatement;
-    visitDeclareClassStmt(_stmt: o.ClassStmt, _context: Context): never;
     visitIfStmt(stmt: o.IfStmt, context: Context): TStatement;
     visitReadVarExpr(ast: o.ReadVarExpr, _context: Context): TExpression;
     visitWriteVarExpr(expr: o.WriteVarExpr, context: Context): TExpression;
     visitWriteKeyExpr(expr: o.WriteKeyExpr, context: Context): TExpression;
     visitWritePropExpr(expr: o.WritePropExpr, context: Context): TExpression;
-    visitInvokeMethodExpr(ast: o.InvokeMethodExpr, context: Context): TExpression;
     visitInvokeFunctionExpr(ast: o.InvokeFunctionExpr, context: Context): TExpression;
     visitInstantiateExpr(ast: o.InstantiateExpr, context: Context): TExpression;
     visitLiteralExpr(ast: o.LiteralExpr, _context: Context): TExpression;
     visitExternalExpr(ast: o.ExternalExpr, _context: Context): TExpression;
     visitConditionalExpr(ast: o.ConditionalExpr, context: Context): TExpression;
     visitNotExpr(ast: o.NotExpr, context: Context): TExpression;
-    visitAssertNotNullExpr(ast: o.AssertNotNull, context: Context): TExpression;
-    visitCastExpr(ast: o.CastExpr, context: Context): TExpression;
     visitFunctionExpr(ast: o.FunctionExpr, context: Context): TExpression;
     visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, context: Context): TExpression;
     visitReadPropExpr(ast: o.ReadPropExpr, context: Context): TExpression;

package/transform/compiler-cli/src/ngtsc/translator/src/translator.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -78,9 +82,6 @@ class ExpressionTranslatorVisitor {
     visitReturnStmt(stmt, context) {
         return this.attachComments(this.factory.createReturnStatement(stmt.value.visitExpression(this, context.withExpressionMode)), stmt.leadingComments);
     }
-    visitDeclareClassStmt(_stmt, _context) {
-        throw new Error('Method not implemented.');
-    }
     visitIfStmt(stmt, context) {
         return this.attachComments(this.factory.createIfStatement(stmt.condition.visitExpression(this, context), this.factory.createBlock(this.visitStatements(stmt.trueCase, context.withStatementMode)), stmt.falseCase.length > 0
             ? this.factory.createBlock(this.visitStatements(stmt.falseCase, context.withStatementMode))
@@ -109,13 +110,6 @@ class ExpressionTranslatorVisitor {
         const target = this.factory.createPropertyAccess(expr.receiver.visitExpression(this, context), expr.name);
         return this.factory.createAssignment(target, expr.value.visitExpression(this, context));
     }
-    visitInvokeMethodExpr(ast, context) {
-        const target = ast.receiver.visitExpression(this, context);
-        return this.setSourceMapRange(this.factory.createCallExpression(ast.name !== null
-            ? this.factory.createPropertyAccess(target, ast.name)
-            : target, ast.args.map((arg) => arg.visitExpression(this, context)), 
-        /* pure */ false), ast.sourceSpan);
-    }
     visitInvokeFunctionExpr(ast, context) {
         return this.setSourceMapRange(this.factory.createCallExpression(ast.fn.visitExpression(this, context), ast.args.map((arg) => arg.visitExpression(this, context)), ast.pure), ast.sourceSpan);
     }
@@ -182,12 +176,6 @@ class ExpressionTranslatorVisitor {
     visitNotExpr(ast, context) {
         return this.factory.createUnaryExpression('!', ast.condition.visitExpression(this, context));
     }
-    visitAssertNotNullExpr(ast, context) {
-        return ast.condition.visitExpression(this, context);
-    }
-    visitCastExpr(ast, context) {
-        return ast.value.visitExpression(this, context);
-    }
     visitFunctionExpr(ast, context) {
         var _a;
         return this.factory.createFunctionExpression((_a = ast.name) !== null && _a !== void 0 ? _a : null, ast.params.map((param) => param.name), this.factory.createBlock(this.visitStatements(ast.statements, context)));

package/transform/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.d.ts

@@ -5,8 +5,8 @@
  * 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
  */
-import * as ts from "typescript";
-import { AstFactory, BinaryOperator, LeadingComment, ObjectLiteralProperty, SourceMapRange, TemplateLiteral, UnaryOperator, VariableDeclarationType } from "./api/ast_factory";
+import * as ts from 'typescript';
+import { AstFactory, BinaryOperator, LeadingComment, ObjectLiteralProperty, SourceMapRange, TemplateLiteral, UnaryOperator, VariableDeclarationType } from './api/ast_factory';
 /**
  * A TypeScript flavoured implementation of the AstFactory.
  */
@@ -20,10 +20,7 @@ export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts
     createBinaryExpression(leftOperand: ts.Expression, operator: BinaryOperator, rightOperand: ts.Expression): ts.Expression;
     createBlock(body: ts.Statement[]): ts.Statement;
     createCallExpression(callee: ts.Expression, args: ts.Expression[], pure: boolean): ts.Expression;
-    createConditional: {
-        (condition: ts.Expression, whenTrue: ts.Expression, whenFalse: ts.Expression): ts.ConditionalExpression;
-        (condition: ts.Expression, questionToken: ts.QuestionToken, whenTrue: ts.Expression, colonToken: ts.ColonToken, whenFalse: ts.Expression): ts.ConditionalExpression;
-    };
+    createConditional(condition: ts.Expression, whenTrue: ts.Expression, whenFalse: ts.Expression): ts.Expression;
     createElementAccess: (expression: ts.Expression, index: number | ts.Expression) => ts.ElementAccessExpression;
     createExpressionStatement: (expression: ts.Expression) => ts.ExpressionStatement;
     createFunctionDeclaration(functionName: string, parameters: string[], body: ts.Statement): ts.Statement;

package/transform/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -43,28 +47,28 @@ var PureAnnotation;
     PureAnnotation["TERSER"] = "@__PURE__";
 })(PureAnnotation || (PureAnnotation = {}));
 const UNARY_OPERATORS = {
-    "+": ts.SyntaxKind.PlusToken,
-    "-": ts.SyntaxKind.MinusToken,
-    "!": ts.SyntaxKind.ExclamationToken,
+    '+': ts.SyntaxKind.PlusToken,
+    '-': ts.SyntaxKind.MinusToken,
+    '!': ts.SyntaxKind.ExclamationToken,
 };
 const BINARY_OPERATORS = {
-    "&&": ts.SyntaxKind.AmpersandAmpersandToken,
-    ">": ts.SyntaxKind.GreaterThanToken,
-    ">=": ts.SyntaxKind.GreaterThanEqualsToken,
-    "&": ts.SyntaxKind.AmpersandToken,
-    "/": ts.SyntaxKind.SlashToken,
-    "==": ts.SyntaxKind.EqualsEqualsToken,
-    "===": ts.SyntaxKind.EqualsEqualsEqualsToken,
-    "<": ts.SyntaxKind.LessThanToken,
-    "<=": ts.SyntaxKind.LessThanEqualsToken,
-    "-": ts.SyntaxKind.MinusToken,
-    "%": ts.SyntaxKind.PercentToken,
-    "*": ts.SyntaxKind.AsteriskToken,
-    "!=": ts.SyntaxKind.ExclamationEqualsToken,
-    "!==": ts.SyntaxKind.ExclamationEqualsEqualsToken,
-    "||": ts.SyntaxKind.BarBarToken,
-    "+": ts.SyntaxKind.PlusToken,
-    "??": ts.SyntaxKind.QuestionQuestionToken,
+    '&&': ts.SyntaxKind.AmpersandAmpersandToken,
+    '>': ts.SyntaxKind.GreaterThanToken,
+    '>=': ts.SyntaxKind.GreaterThanEqualsToken,
+    '&': ts.SyntaxKind.AmpersandToken,
+    '/': ts.SyntaxKind.SlashToken,
+    '==': ts.SyntaxKind.EqualsEqualsToken,
+    '===': ts.SyntaxKind.EqualsEqualsEqualsToken,
+    '<': ts.SyntaxKind.LessThanToken,
+    '<=': ts.SyntaxKind.LessThanEqualsToken,
+    '-': ts.SyntaxKind.MinusToken,
+    '%': ts.SyntaxKind.PercentToken,
+    '*': ts.SyntaxKind.AsteriskToken,
+    '!=': ts.SyntaxKind.ExclamationEqualsToken,
+    '!==': ts.SyntaxKind.ExclamationEqualsEqualsToken,
+    '||': ts.SyntaxKind.BarBarToken,
+    '+': ts.SyntaxKind.PlusToken,
+    '??': ts.SyntaxKind.QuestionQuestionToken,
 };
 const VAR_TYPES = {
     const: ts.NodeFlags.Const,
@@ -79,27 +83,26 @@ class TypeScriptAstFactory {
         this.annotateForClosureCompiler = annotateForClosureCompiler;
         this.externalSourceFiles = new Map();
         this.attachComments = attachComments;
-        this.createArrayLiteral = ts.createArrayLiteral;
-        this.createConditional = ts.createConditional;
-        this.createElementAccess = ts.createElementAccess;
-        this.createExpressionStatement = ts.createExpressionStatement;
-        this.createIdentifier = ts.createIdentifier;
-        this.createParenthesizedExpression = ts.createParen;
-        this.createPropertyAccess = ts.createPropertyAccess;
-        this.createThrowStatement = ts.createThrow;
-        this.createTypeOfExpression = ts.createTypeOf;
+        this.createArrayLiteral = ts.factory.createArrayLiteralExpression;
+        this.createElementAccess = ts.factory.createElementAccessExpression;
+        this.createExpressionStatement = ts.factory.createExpressionStatement;
+        this.createIdentifier = ts.factory.createIdentifier;
+        this.createParenthesizedExpression = ts.factory.createParenthesizedExpression;
+        this.createPropertyAccess = ts.factory.createPropertyAccessExpression;
+        this.createThrowStatement = ts.factory.createThrowStatement;
+        this.createTypeOfExpression = ts.factory.createTypeOfExpression;
     }
     createAssignment(target, value) {
-        return ts.createBinary(target, ts.SyntaxKind.EqualsToken, value);
+        return ts.factory.createBinaryExpression(target, ts.SyntaxKind.EqualsToken, value);
     }
     createBinaryExpression(leftOperand, operator, rightOperand) {
-        return ts.createBinary(leftOperand, BINARY_OPERATORS[operator], rightOperand);
+        return ts.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS[operator], rightOperand);
     }
     createBlock(body) {
-        return ts.createBlock(body);
+        return ts.factory.createBlock(body);
     }
     createCallExpression(callee, args, pure) {
-        const call = ts.createCall(callee, undefined, args);
+        const call = ts.factory.createCallExpression(callee, undefined, args);
         if (pure) {
             ts.addSyntheticLeadingComment(call, ts.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler
                 ? PureAnnotation.CLOSURE
@@ -108,49 +111,58 @@ class TypeScriptAstFactory {
         }
         return call;
     }
+    createConditional(condition, whenTrue, whenFalse) {
+        return ts.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
+    }
     createFunctionDeclaration(functionName, parameters, body) {
         if (!ts.isBlock(body)) {
             throw new Error(`Invalid syntax, expected a block, but got ${ts.SyntaxKind[body.kind]}.`);
         }
-        return ts.createFunctionDeclaration(undefined, undefined, undefined, functionName, undefined, parameters.map((param) => ts.createParameter(undefined, undefined, undefined, param)), undefined, body);
+        return ts.factory.createFunctionDeclaration(undefined, undefined, undefined, functionName, undefined, parameters.map((param) => ts.factory.createParameterDeclaration(undefined, undefined, undefined, param)), undefined, body);
     }
     createFunctionExpression(functionName, parameters, body) {
         if (!ts.isBlock(body)) {
             throw new Error(`Invalid syntax, expected a block, but got ${ts.SyntaxKind[body.kind]}.`);
         }
-        return ts.createFunctionExpression(undefined, undefined, functionName !== null && functionName !== void 0 ? functionName : undefined, undefined, parameters.map((param) => ts.createParameter(undefined, undefined, undefined, param)), undefined, body);
+        return ts.factory.createFunctionExpression(undefined, undefined, functionName !== null && functionName !== void 0 ? functionName : undefined, undefined, parameters.map((param) => ts.factory.createParameterDeclaration(undefined, undefined, undefined, param)), undefined, body);
     }
     createIfStatement(condition, thenStatement, elseStatement) {
-        return ts.createIf(condition, thenStatement, elseStatement !== null && elseStatement !== void 0 ? elseStatement : undefined);
+        return ts.factory.createIfStatement(condition, thenStatement, elseStatement !== null && elseStatement !== void 0 ? elseStatement : undefined);
     }
     createLiteral(value) {
         if (value === undefined) {
-            return ts.createIdentifier("undefined");
+            return ts.factory.createIdentifier('undefined');
         }
         else if (value === null) {
-            return ts.createNull();
+            return ts.factory.createNull();
+        }
+        else if (typeof value === 'boolean') {
+            return value ? ts.factory.createTrue() : ts.factory.createFalse();
+        }
+        else if (typeof value === 'number') {
+            return ts.factory.createNumericLiteral(value);
         }
         else {
-            return ts.createLiteral(value);
+            return ts.factory.createStringLiteral(value);
         }
     }
     createNewExpression(expression, args) {
-        return ts.createNew(expression, undefined, args);
+        return ts.factory.createNewExpression(expression, undefined, args);
     }
     createObjectLiteral(properties) {
-        return ts.createObjectLiteral(properties.map((prop) => ts.createPropertyAssignment(prop.quoted
-            ? ts.createLiteral(prop.propertyName)
-            : ts.createIdentifier(prop.propertyName), prop.value)));
+        return ts.factory.createObjectLiteralExpression(properties.map((prop) => ts.factory.createPropertyAssignment(prop.quoted
+            ? ts.factory.createStringLiteral(prop.propertyName)
+            : ts.factory.createIdentifier(prop.propertyName), prop.value)));
     }
     createReturnStatement(expression) {
-        return ts.createReturn(expression !== null && expression !== void 0 ? expression : undefined);
+        return ts.factory.createReturnStatement(expression !== null && expression !== void 0 ? expression : undefined);
     }
     createTaggedTemplate(tag, template) {
         let templateLiteral;
         const length = template.elements.length;
         const head = template.elements[0];
         if (length === 1) {
-            templateLiteral = ts.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+            templateLiteral = ts.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
         }
         else {
             const spans = [];
@@ -161,7 +173,7 @@ class TypeScriptAstFactory {
                 if (range !== null) {
                     this.setSourceMapRange(middle, range);
                 }
-                spans.push(ts.createTemplateSpan(template.expressions[i - 1], middle));
+                spans.push(ts.factory.createTemplateSpan(template.expressions[i - 1], middle));
             }
             // Create the tail part
             const resolvedExpression = template.expressions[length - 2];
@@ -170,21 +182,21 @@ class TypeScriptAstFactory {
             if (templatePart.range !== null) {
                 this.setSourceMapRange(templateTail, templatePart.range);
             }
-            spans.push(ts.createTemplateSpan(resolvedExpression, templateTail));
+            spans.push(ts.factory.createTemplateSpan(resolvedExpression, templateTail));
             // Put it all together
-            templateLiteral = ts.createTemplateExpression(ts.createTemplateHead(head.cooked, head.raw), spans);
+            templateLiteral = ts.factory.createTemplateExpression(ts.factory.createTemplateHead(head.cooked, head.raw), spans);
         }
         if (head.range !== null) {
             this.setSourceMapRange(templateLiteral, head.range);
         }
-        return ts.createTaggedTemplate(tag, templateLiteral);
+        return ts.factory.createTaggedTemplateExpression(tag, undefined, templateLiteral);
     }
     createUnaryExpression(operator, operand) {
-        return ts.createPrefix(UNARY_OPERATORS[operator], operand);
+        return ts.factory.createPrefixUnaryExpression(UNARY_OPERATORS[operator], operand);
     }
     createVariableDeclaration(variableName, initializer, type) {
-        return ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
-            ts.createVariableDeclaration(variableName, undefined, initializer !== null && initializer !== void 0 ? initializer : undefined),
+        return ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration(variableName, undefined, undefined, initializer !== null && initializer !== void 0 ? initializer : undefined),
         ], VAR_TYPES[type]));
     }
     setSourceMapRange(node, sourceMapRange) {
@@ -216,7 +228,7 @@ exports.createTemplateMiddle = createTemplateMiddle;
 // HACK: Use this in place of `ts.createTemplateTail()`.
 // Revert once https://github.com/microsoft/TypeScript/issues/35374 is fixed.
 function createTemplateTail(cooked, raw) {
-    const node = ts.createTemplateHead(cooked, raw);
+    const node = ts.factory.createTemplateHead(cooked, raw);
     node.kind = ts.SyntaxKind.TemplateTail;
     return node;
 }
@@ -236,7 +248,7 @@ function attachComments(statement, leadingComments) {
             ts.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
         }
         else {
-            for (const line of comment.toString().split("\n")) {
+            for (const line of comment.toString().split('\n')) {
                 ts.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
             }
         }

package/{import/es2015/decorator/interface/provider.js → transform/compiler-cli/src/ngtsc/ts_compatibility/index.d.ts}

@@ -5,4 +5,4 @@
  * 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
  */
-export {};
+export * from './src/ts_cross_version_utils';

package/transform/compiler-cli/src/ngtsc/ts_compatibility/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * @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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/ts_cross_version_utils"), exports);

package/transform/compiler-cli/src/ngtsc/ts_compatibility/src/ts_cross_version_utils.d.ts

@@ -0,0 +1,151 @@
+/*!
+ * @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
+ */
+import ts from 'typescript';
+/** Equivalent of `ts.ModifierLike` which is only present in TS 4.8+. */
+export declare type ModifierLike = ts.Modifier | ts.Decorator;
+/** Type of `ts.factory.updateParameterDeclaration` in TS 4.8+. */
+declare type Ts48UpdateParameterDeclarationFn = (node: ts.ParameterDeclaration, modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: ts.DotDotDotToken | undefined, name: string | ts.BindingName, questionToken: ts.QuestionToken | undefined, type: ts.TypeNode | undefined, initializer: ts.Expression | undefined) => ts.ParameterDeclaration;
+/**
+ * Updates a `ts.ParameterDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateParameterDeclaration: Ts48UpdateParameterDeclarationFn;
+/** Type of `ts.factory.updateImportDeclaration` in TS 4.8+. */
+declare type Ts48UpdateImportDeclarationFn = (node: ts.ImportDeclaration, modifiers: readonly ts.Modifier[] | undefined, importClause: ts.ImportClause | undefined, moduleSpecifier: ts.Expression, assertClause: ts.AssertClause | undefined) => ts.ImportDeclaration;
+/**
+ * Updates a `ts.ImportDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateImportDeclaration: Ts48UpdateImportDeclarationFn;
+/** Type of `ts.factory.updateClassDeclaration` in TS 4.8+. */
+declare type Ts48UpdateClassDeclarationFn = (node: ts.ClassDeclaration, modifiers: readonly ModifierLike[] | undefined, name: ts.Identifier | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, heritageClauses: readonly ts.HeritageClause[] | undefined, members: readonly ts.ClassElement[]) => ts.ClassDeclaration;
+/**
+ * Updates a `ts.ClassDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateClassDeclaration: Ts48UpdateClassDeclarationFn;
+/** Type of `ts.factory.createClassDeclaration` in TS 4.8+. */
+declare type Ts48CreateClassDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: ts.Identifier | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, heritageClauses: readonly ts.HeritageClause[] | undefined, members: readonly ts.ClassElement[]) => ts.ClassDeclaration;
+/**
+ * Creates a `ts.ClassDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createClassDeclaration: Ts48CreateClassDeclarationFn;
+/** Type of `ts.factory.updateMethodDeclaration` in TS 4.8+. */
+declare type Ts48UpdateMethodDeclarationFn = (node: ts.MethodDeclaration, modifiers: readonly ModifierLike[] | undefined, asteriskToken: ts.AsteriskToken | undefined, name: ts.PropertyName, questionToken: ts.QuestionToken | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.MethodDeclaration;
+/**
+ * Updates a `ts.MethodDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateMethodDeclaration: Ts48UpdateMethodDeclarationFn;
+/** Type of `ts.factory.createMethodDeclaration` in TS 4.8+. */
+declare type Ts48CreateMethodDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, asteriskToken: ts.AsteriskToken | undefined, name: ts.PropertyName, questionToken: ts.QuestionToken | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.MethodDeclaration;
+/**
+ * Creates a `ts.MethodDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createMethodDeclaration: Ts48CreateMethodDeclarationFn;
+/** Type of `ts.factory.updatePropertyDeclaration` in TS 4.8+. */
+declare type Ts48UpdatePropertyDeclarationFn = (node: ts.PropertyDeclaration, modifiers: readonly ModifierLike[] | undefined, name: string | ts.PropertyName, questionOrExclamationToken: ts.QuestionToken | ts.ExclamationToken | undefined, type: ts.TypeNode | undefined, initializer: ts.Expression | undefined) => ts.PropertyDeclaration;
+/**
+ * Updates a `ts.PropertyDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updatePropertyDeclaration: Ts48UpdatePropertyDeclarationFn;
+/** Type of `ts.factory.createPropertyDeclaration` in TS 4.8+. */
+declare type Ts48CreatePropertyDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: string | ts.PropertyName, questionOrExclamationToken: ts.QuestionToken | ts.ExclamationToken | undefined, type: ts.TypeNode | undefined, initializer: ts.Expression | undefined) => ts.PropertyDeclaration;
+/**
+ * Creates a `ts.PropertyDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createPropertyDeclaration: Ts48CreatePropertyDeclarationFn;
+/** Type of `ts.factory.updateGetAccessorDeclaration` in TS 4.8+. */
+declare type Ts48UpdateGetAccessorDeclarationFn = (node: ts.GetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.GetAccessorDeclaration;
+/**
+ * Updates a `ts.GetAccessorDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateGetAccessorDeclaration: Ts48UpdateGetAccessorDeclarationFn;
+/** Type of `ts.factory.createGetAccessorDeclaration` in TS 4.8+. */
+declare type Ts48CreateGetAccessorDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.GetAccessorDeclaration;
+/**
+ * Creates a `ts.GetAccessorDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createGetAccessorDeclaration: Ts48CreateGetAccessorDeclarationFn;
+/** Type of `ts.factory.updateSetAccessorDeclaration` in TS 4.8+. */
+declare type Ts48UpdateSetAccessorDeclarationFn = (node: ts.SetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], body: ts.Block | undefined) => ts.SetAccessorDeclaration;
+/**
+ * Updates a `ts.GetAccessorDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateSetAccessorDeclaration: Ts48UpdateSetAccessorDeclarationFn;
+/** Type of `ts.factory.createSetAccessorDeclaration` in TS 4.8+. */
+declare type Ts48CreateSetAccessorDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], body: ts.Block | undefined) => ts.SetAccessorDeclaration;
+/**
+ * Creates a `ts.GetAccessorDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createSetAccessorDeclaration: Ts48CreateSetAccessorDeclarationFn;
+/** Type of `ts.factory.updateConstructorDeclaration` in TS 4.8+. */
+declare type Ts48UpdateConstructorDeclarationFn = (node: ts.ConstructorDeclaration, modifiers: readonly ts.Modifier[] | undefined, parameters: readonly ts.ParameterDeclaration[], body: ts.Block | undefined) => ts.ConstructorDeclaration;
+/**
+ * Updates a `ts.ConstructorDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateConstructorDeclaration: Ts48UpdateConstructorDeclarationFn;
+/**
+ * Gets the decorators that have been applied to a node.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const getDecorators: (node: ts.Node) => readonly ts.Decorator[] | undefined;
+/**
+ * Gets the modifiers that have been set on a node.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const getModifiers: (node: ts.Node) => readonly ts.Modifier[] | undefined;
+/**
+ * Combines an optional array of decorators with an optional array of modifiers into a single
+ * `ts.ModifierLike` array. Used in version of TypeScript after 4.8 where the `decorators` and
+ * `modifiers` arrays have been combined.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare function combineModifiers(decorators: readonly ts.Decorator[] | undefined, modifiers: readonly ModifierLike[] | undefined): readonly ModifierLike[] | undefined;
+export {};