@angular/compiler-cli 10.0.9 → 10.0.10

package/ngcc/src/host/esm5_host.d.ts

@@ -139,4 +139,122 @@ export declare class Esm5ReflectionHost extends Esm2015ReflectionHost {
      * @returns an array of statements that may contain helper calls.
      */
     protected getStatementsForClass(classSymbol: NgccClassSymbol): ts.Statement[];
+    /**
+     * A constructor function may have been "synthesized" by TypeScript during JavaScript emit,
+     * in the case no user-defined constructor exists and e.g. property initializers are used.
+     * Those initializers need to be emitted into a constructor in JavaScript, so the TypeScript
+     * compiler generates a synthetic constructor.
+     *
+     * We need to identify such constructors as ngcc needs to be able to tell if a class did
+     * originally have a constructor in the TypeScript source. For ES5, we can not tell an
+     * empty constructor apart from a synthesized constructor, but fortunately that does not
+     * matter for the code generated by ngtsc.
+     *
+     * When a class has a superclass however, a synthesized constructor must not be considered
+     * as a user-defined constructor as that prevents a base factory call from being created by
+     * ngtsc, resulting in a factory function that does not inject the dependencies of the
+     * superclass. Hence, we identify a default synthesized super call in the constructor body,
+     * according to the structure that TypeScript's ES2015 to ES5 transformer generates in
+     * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1082-L1098
+     *
+     * Additionally, we handle synthetic delegate constructors that are emitted when TypeScript
+     * downlevel's ES2015 synthetically generated to ES5. These vary slightly from the default
+     * structure mentioned above because the ES2015 output uses a spread operator, for delegating
+     * to the parent constructor, that is preserved through a TypeScript helper in ES5. e.g.
+     *
+     * ```
+     * return _super.apply(this, tslib.__spread(arguments)) || this;
+     * ```
+     *
+     * Such constructs can be still considered as synthetic delegate constructors as they are
+     * the product of a common TypeScript to ES5 synthetic constructor, just being downleveled
+     * to ES5 using `tsc`. See: https://github.com/angular/angular/issues/38453.
+     *
+     *
+     * @param constructor a constructor function to test
+     * @returns true if the constructor appears to have been synthesized
+     */
+    private isSynthesizedConstructor;
+    /**
+     * Identifies synthesized super calls which pass-through function arguments directly and are
+     * being assigned to a common `_this` variable. The following patterns we intend to match:
+     *
+     * 1. Delegate call emitted by TypeScript when it emits ES5 directly.
+     *   ```
+     *   var _this = _super !== null && _super.apply(this, arguments) || this;
+     *   ```
+     *
+     * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.
+     *   ```
+     *   var _this = _super.apply(this, tslib.__spread(arguments)) || this;
+     *   ```
+     *
+     *
+     * @param statement a statement that may be a synthesized super call
+     * @returns true if the statement looks like a synthesized super call
+     */
+    private isSynthesizedSuperThisAssignment;
+    /**
+     * Identifies synthesized super calls which pass-through function arguments directly and
+     * are being returned. The following patterns correspond to synthetic super return calls:
+     *
+     * 1. Delegate call emitted by TypeScript when it emits ES5 directly.
+     *   ```
+     *   return _super !== null && _super.apply(this, arguments) || this;
+     *   ```
+     *
+     * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.
+     *   ```
+     *   return _super.apply(this, tslib.__spread(arguments)) || this;
+     *   ```
+     *
+     * @param statement a statement that may be a synthesized super call
+     * @returns true if the statement looks like a synthesized super call
+     */
+    private isSynthesizedSuperReturnStatement;
+    /**
+     * Identifies synthesized super calls which pass-through function arguments directly. The
+     * synthetic delegate super call match the following patterns we intend to match:
+     *
+     * 1. Delegate call emitted by TypeScript when it emits ES5 directly.
+     *   ```
+     *   _super !== null && _super.apply(this, arguments) || this;
+     *   ```
+     *
+     * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.
+     *   ```
+     *   _super.apply(this, tslib.__spread(arguments)) || this;
+     *   ```
+     *
+     * @param expression an expression that may represent a default super call
+     * @returns true if the expression corresponds with the above form
+     */
+    private isSynthesizedDefaultSuperCall;
+    /**
+     * Tests whether the expression corresponds to a `super` call passing through
+     * function arguments without any modification. e.g.
+     *
+     * ```
+     * _super !== null && _super.apply(this, arguments) || this;
+     * ```
+     *
+     * This structure is generated by TypeScript when transforming ES2015 to ES5, see
+     * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1148-L1163
+     *
+     * Additionally, we also handle cases where `arguments` are wrapped by a TypeScript spread helper.
+     * This can happen if ES2015 class output contain auto-generated constructors due to class
+     * members. The ES2015 output will be using `super(...arguments)` to delegate to the superclass,
+     * but once downleveled to ES5, the spread operator will be persisted through a TypeScript spread
+     * helper. For example:
+     *
+     * ```
+     * _super.apply(this, __spread(arguments)) || this;
+     * ```
+     *
+     * More details can be found in: https://github.com/angular/angular/issues/38453.
+     *
+     * @param expression an expression that may represent a default super call
+     * @returns true if the expression corresponds with the above form
+     */
+    private isSuperApplyCall;
 }

package/ngcc/src/host/esm5_host.js

@@ -206,7 +206,7 @@
             if (constructor.parameters.length > 0) {
                 return Array.from(constructor.parameters);
             }
-            if (isSynthesizedConstructor(constructor)) {
+            if (this.isSynthesizedConstructor(constructor)) {
                 return null;
             }
             return [];
@@ -331,6 +331,212 @@
             var classDeclarationParent = classSymbol.implementation.valueDeclaration.parent;
             return ts.isBlock(classDeclarationParent) ? Array.from(classDeclarationParent.statements) : [];
         };
+        ///////////// Host Private Helpers /////////////
+        /**
+         * A constructor function may have been "synthesized" by TypeScript during JavaScript emit,
+         * in the case no user-defined constructor exists and e.g. property initializers are used.
+         * Those initializers need to be emitted into a constructor in JavaScript, so the TypeScript
+         * compiler generates a synthetic constructor.
+         *
+         * We need to identify such constructors as ngcc needs to be able to tell if a class did
+         * originally have a constructor in the TypeScript source. For ES5, we can not tell an
+         * empty constructor apart from a synthesized constructor, but fortunately that does not
+         * matter for the code generated by ngtsc.
+         *
+         * When a class has a superclass however, a synthesized constructor must not be considered
+         * as a user-defined constructor as that prevents a base factory call from being created by
+         * ngtsc, resulting in a factory function that does not inject the dependencies of the
+         * superclass. Hence, we identify a default synthesized super call in the constructor body,
+         * according to the structure that TypeScript's ES2015 to ES5 transformer generates in
+         * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1082-L1098
+         *
+         * Additionally, we handle synthetic delegate constructors that are emitted when TypeScript
+         * downlevel's ES2015 synthetically generated to ES5. These vary slightly from the default
+         * structure mentioned above because the ES2015 output uses a spread operator, for delegating
+         * to the parent constructor, that is preserved through a TypeScript helper in ES5. e.g.
+         *
+         * ```
+         * return _super.apply(this, tslib.__spread(arguments)) || this;
+         * ```
+         *
+         * Such constructs can be still considered as synthetic delegate constructors as they are
+         * the product of a common TypeScript to ES5 synthetic constructor, just being downleveled
+         * to ES5 using `tsc`. See: https://github.com/angular/angular/issues/38453.
+         *
+         *
+         * @param constructor a constructor function to test
+         * @returns true if the constructor appears to have been synthesized
+         */
+        Esm5ReflectionHost.prototype.isSynthesizedConstructor = function (constructor) {
+            if (!constructor.body)
+                return false;
+            var firstStatement = constructor.body.statements[0];
+            if (!firstStatement)
+                return false;
+            return this.isSynthesizedSuperThisAssignment(firstStatement) ||
+                this.isSynthesizedSuperReturnStatement(firstStatement);
+        };
+        /**
+         * Identifies synthesized super calls which pass-through function arguments directly and are
+         * being assigned to a common `_this` variable. The following patterns we intend to match:
+         *
+         * 1. Delegate call emitted by TypeScript when it emits ES5 directly.
+         *   ```
+         *   var _this = _super !== null && _super.apply(this, arguments) || this;
+         *   ```
+         *
+         * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.
+         *   ```
+         *   var _this = _super.apply(this, tslib.__spread(arguments)) || this;
+         *   ```
+         *
+         *
+         * @param statement a statement that may be a synthesized super call
+         * @returns true if the statement looks like a synthesized super call
+         */
+        Esm5ReflectionHost.prototype.isSynthesizedSuperThisAssignment = function (statement) {
+            if (!ts.isVariableStatement(statement))
+                return false;
+            var variableDeclarations = statement.declarationList.declarations;
+            if (variableDeclarations.length !== 1)
+                return false;
+            var variableDeclaration = variableDeclarations[0];
+            if (!ts.isIdentifier(variableDeclaration.name) ||
+                !variableDeclaration.name.text.startsWith('_this'))
+                return false;
+            var initializer = variableDeclaration.initializer;
+            if (!initializer)
+                return false;
+            return this.isSynthesizedDefaultSuperCall(initializer);
+        };
+        /**
+         * Identifies synthesized super calls which pass-through function arguments directly and
+         * are being returned. The following patterns correspond to synthetic super return calls:
+         *
+         * 1. Delegate call emitted by TypeScript when it emits ES5 directly.
+         *   ```
+         *   return _super !== null && _super.apply(this, arguments) || this;
+         *   ```
+         *
+         * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.
+         *   ```
+         *   return _super.apply(this, tslib.__spread(arguments)) || this;
+         *   ```
+         *
+         * @param statement a statement that may be a synthesized super call
+         * @returns true if the statement looks like a synthesized super call
+         */
+        Esm5ReflectionHost.prototype.isSynthesizedSuperReturnStatement = function (statement) {
+            if (!ts.isReturnStatement(statement))
+                return false;
+            var expression = statement.expression;
+            if (!expression)
+                return false;
+            return this.isSynthesizedDefaultSuperCall(expression);
+        };
+        /**
+         * Identifies synthesized super calls which pass-through function arguments directly. The
+         * synthetic delegate super call match the following patterns we intend to match:
+         *
+         * 1. Delegate call emitted by TypeScript when it emits ES5 directly.
+         *   ```
+         *   _super !== null && _super.apply(this, arguments) || this;
+         *   ```
+         *
+         * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.
+         *   ```
+         *   _super.apply(this, tslib.__spread(arguments)) || this;
+         *   ```
+         *
+         * @param expression an expression that may represent a default super call
+         * @returns true if the expression corresponds with the above form
+         */
+        Esm5ReflectionHost.prototype.isSynthesizedDefaultSuperCall = function (expression) {
+            if (!isBinaryExpr(expression, ts.SyntaxKind.BarBarToken))
+                return false;
+            if (expression.right.kind !== ts.SyntaxKind.ThisKeyword)
+                return false;
+            var left = expression.left;
+            if (isBinaryExpr(left, ts.SyntaxKind.AmpersandAmpersandToken)) {
+                return isSuperNotNull(left.left) && this.isSuperApplyCall(left.right);
+            }
+            else {
+                return this.isSuperApplyCall(left);
+            }
+        };
+        /**
+         * Tests whether the expression corresponds to a `super` call passing through
+         * function arguments without any modification. e.g.
+         *
+         * ```
+         * _super !== null && _super.apply(this, arguments) || this;
+         * ```
+         *
+         * This structure is generated by TypeScript when transforming ES2015 to ES5, see
+         * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1148-L1163
+         *
+         * Additionally, we also handle cases where `arguments` are wrapped by a TypeScript spread helper.
+         * This can happen if ES2015 class output contain auto-generated constructors due to class
+         * members. The ES2015 output will be using `super(...arguments)` to delegate to the superclass,
+         * but once downleveled to ES5, the spread operator will be persisted through a TypeScript spread
+         * helper. For example:
+         *
+         * ```
+         * _super.apply(this, __spread(arguments)) || this;
+         * ```
+         *
+         * More details can be found in: https://github.com/angular/angular/issues/38453.
+         *
+         * @param expression an expression that may represent a default super call
+         * @returns true if the expression corresponds with the above form
+         */
+        Esm5ReflectionHost.prototype.isSuperApplyCall = function (expression) {
+            if (!ts.isCallExpression(expression) || expression.arguments.length !== 2)
+                return false;
+            var targetFn = expression.expression;
+            if (!ts.isPropertyAccessExpression(targetFn))
+                return false;
+            if (!isSuperIdentifier(targetFn.expression))
+                return false;
+            if (targetFn.name.text !== 'apply')
+                return false;
+            var thisArgument = expression.arguments[0];
+            if (thisArgument.kind !== ts.SyntaxKind.ThisKeyword)
+                return false;
+            var argumentsExpr = expression.arguments[1];
+            // If the super is directly invoked with `arguments`, return `true`. This represents the
+            // common TypeScript output where the delegate constructor super call matches the following
+            // pattern: `super.apply(this, arguments)`.
+            if (isArgumentsIdentifier(argumentsExpr)) {
+                return true;
+            }
+            // The other scenario we intend to detect: The `arguments` variable might be wrapped with the
+            // TypeScript spread helper (either through tslib or inlined). This can happen if an explicit
+            // delegate constructor uses `super(...arguments)` in ES2015 and is downleveled to ES5 using
+            // `--downlevelIteration`. The output in such cases would not directly pass the function
+            // `arguments` to the `super` call, but wrap it in a TS spread helper. The output would match
+            // the following pattern: `super.apply(this, tslib.__spread(arguments))`. We check for such
+            // constructs below, but perform the detection of the call expression definition as last as
+            // that is the most expensive operation here.
+            if (!ts.isCallExpression(argumentsExpr) || argumentsExpr.arguments.length !== 1 ||
+                !isArgumentsIdentifier(argumentsExpr.arguments[0])) {
+                return false;
+            }
+            var argumentsCallExpr = argumentsExpr.expression;
+            var argumentsCallDeclaration = null;
+            // The `__spread` helper could be globally available, or accessed through a namespaced
+            // import. Hence we support a property access here as long as it resolves to the actual
+            // known TypeScript spread helper.
+            if (ts.isIdentifier(argumentsCallExpr)) {
+                argumentsCallDeclaration = this.getDeclarationOfIdentifier(argumentsCallExpr);
+            }
+            else if (ts.isPropertyAccessExpression(argumentsCallExpr) &&
+                ts.isIdentifier(argumentsCallExpr.name)) {
+                argumentsCallDeclaration = this.getDeclarationOfIdentifier(argumentsCallExpr.name);
+            }
+            return argumentsCallDeclaration !== null &&
+                argumentsCallDeclaration.known === reflection_1.KnownDeclaration.TsHelperSpread;
+        };
         return Esm5ReflectionHost;
     }(esm2015_host_1.Esm2015ReflectionHost));
     exports.Esm5ReflectionHost = Esm5ReflectionHost;
@@ -386,132 +592,13 @@
     function reflectArrayElement(element) {
         return ts.isObjectLiteralExpression(element) ? reflection_1.reflectObjectLiteral(element) : null;
     }
-    /**
-     * A constructor function may have been "synthesized" by TypeScript during JavaScript emit,
-     * in the case no user-defined constructor exists and e.g. property initializers are used.
-     * Those initializers need to be emitted into a constructor in JavaScript, so the TypeScript
-     * compiler generates a synthetic constructor.
-     *
-     * We need to identify such constructors as ngcc needs to be able to tell if a class did
-     * originally have a constructor in the TypeScript source. For ES5, we can not tell an
-     * empty constructor apart from a synthesized constructor, but fortunately that does not
-     * matter for the code generated by ngtsc.
-     *
-     * When a class has a superclass however, a synthesized constructor must not be considered
-     * as a user-defined constructor as that prevents a base factory call from being created by
-     * ngtsc, resulting in a factory function that does not inject the dependencies of the
-     * superclass. Hence, we identify a default synthesized super call in the constructor body,
-     * according to the structure that TypeScript's ES2015 to ES5 transformer generates in
-     * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1082-L1098
-     *
-     * @param constructor a constructor function to test
-     * @returns true if the constructor appears to have been synthesized
-     */
-    function isSynthesizedConstructor(constructor) {
-        if (!constructor.body)
-            return false;
-        var firstStatement = constructor.body.statements[0];
-        if (!firstStatement)
-            return false;
-        return isSynthesizedSuperThisAssignment(firstStatement) ||
-            isSynthesizedSuperReturnStatement(firstStatement);
-    }
-    /**
-     * Identifies a synthesized super call of the form:
-     *
-     * ```
-     * var _this = _super !== null && _super.apply(this, arguments) || this;
-     * ```
-     *
-     * @param statement a statement that may be a synthesized super call
-     * @returns true if the statement looks like a synthesized super call
-     */
-    function isSynthesizedSuperThisAssignment(statement) {
-        if (!ts.isVariableStatement(statement))
-            return false;
-        var variableDeclarations = statement.declarationList.declarations;
-        if (variableDeclarations.length !== 1)
-            return false;
-        var variableDeclaration = variableDeclarations[0];
-        if (!ts.isIdentifier(variableDeclaration.name) ||
-            !variableDeclaration.name.text.startsWith('_this'))
-            return false;
-        var initializer = variableDeclaration.initializer;
-        if (!initializer)
-            return false;
-        return isSynthesizedDefaultSuperCall(initializer);
-    }
-    /**
-     * Identifies a synthesized super call of the form:
-     *
-     * ```
-     * return _super !== null && _super.apply(this, arguments) || this;
-     * ```
-     *
-     * @param statement a statement that may be a synthesized super call
-     * @returns true if the statement looks like a synthesized super call
-     */
-    function isSynthesizedSuperReturnStatement(statement) {
-        if (!ts.isReturnStatement(statement))
-            return false;
-        var expression = statement.expression;
-        if (!expression)
-            return false;
-        return isSynthesizedDefaultSuperCall(expression);
-    }
-    /**
-     * Tests whether the expression is of the form:
-     *
-     * ```
-     * _super !== null && _super.apply(this, arguments) || this;
-     * ```
-     *
-     * This structure is generated by TypeScript when transforming ES2015 to ES5, see
-     * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1148-L1163
-     *
-     * @param expression an expression that may represent a default super call
-     * @returns true if the expression corresponds with the above form
-     */
-    function isSynthesizedDefaultSuperCall(expression) {
-        if (!isBinaryExpr(expression, ts.SyntaxKind.BarBarToken))
-            return false;
-        if (expression.right.kind !== ts.SyntaxKind.ThisKeyword)
-            return false;
-        var left = expression.left;
-        if (!isBinaryExpr(left, ts.SyntaxKind.AmpersandAmpersandToken))
-            return false;
-        return isSuperNotNull(left.left) && isSuperApplyCall(left.right);
+    function isArgumentsIdentifier(expression) {
+        return ts.isIdentifier(expression) && expression.text === 'arguments';
     }
     function isSuperNotNull(expression) {
         return isBinaryExpr(expression, ts.SyntaxKind.ExclamationEqualsEqualsToken) &&
             isSuperIdentifier(expression.left);
     }
-    /**
-     * Tests whether the expression is of the form
-     *
-     * ```
-     * _super.apply(this, arguments)
-     * ```
-     *
-     * @param expression an expression that may represent a default super call
-     * @returns true if the expression corresponds with the above form
-     */
-    function isSuperApplyCall(expression) {
-        if (!ts.isCallExpression(expression) || expression.arguments.length !== 2)
-            return false;
-        var targetFn = expression.expression;
-        if (!ts.isPropertyAccessExpression(targetFn))
-            return false;
-        if (!isSuperIdentifier(targetFn.expression))
-            return false;
-        if (targetFn.name.text !== 'apply')
-            return false;
-        var thisArgument = expression.arguments[0];
-        if (thisArgument.kind !== ts.SyntaxKind.ThisKeyword)
-            return false;
-        var argumentsArgument = expression.arguments[1];
-        return ts.isIdentifier(argumentsArgument) && argumentsArgument.text === 'arguments';
-    }
     function isBinaryExpr(expression, operator) {
         return ts.isBinaryExpression(expression) && expression.operatorToken.kind === operator;
     }
@@ -588,4 +675,4 @@
         return iifeWrapper && ts.isFunctionExpression(iifeWrapper) ? iifeWrapper : null;
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esm5_host.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/host/esm5_host.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as ts from 'typescript';\n\nimport {ClassDeclaration, ClassMember, ClassMemberKind, Declaration, Decorator, FunctionDefinition, Parameter, reflectObjectLiteral} from '../../../src/ngtsc/reflection';\nimport {getTsHelperFnFromDeclaration, getTsHelperFnFromIdentifier, hasNameIdentifier} from '../utils';\n\nimport {Esm2015ReflectionHost, getClassDeclarationFromInnerDeclaration, getPropertyValueFromSymbol, isAssignmentStatement, ParamInfo} from './esm2015_host';\nimport {NgccClassSymbol} from './ngcc_host';\n\n\n/**\n * ESM5 packages contain ECMAScript IIFE functions that act like classes. For example:\n *\n * ```\n * var CommonModule = (function () {\n *  function CommonModule() {\n *  }\n *  CommonModule.decorators = [ ... ];\n *  return CommonModule;\n * ```\n *\n * * \"Classes\" are decorated if they have a static property called `decorators`.\n * * Members are decorated if there is a matching key on a static property\n *   called `propDecorators`.\n * * Constructor parameters decorators are found on an object returned from\n *   a static method called `ctorParameters`.\n *\n */\nexport class Esm5ReflectionHost extends Esm2015ReflectionHost {\n  getBaseClassExpression(clazz: ClassDeclaration): ts.Expression|null {\n    const superBaseClassExpression = super.getBaseClassExpression(clazz);\n    if (superBaseClassExpression !== null) {\n      return superBaseClassExpression;\n    }\n\n    const iife = getIifeFn(this.getClassSymbol(clazz));\n    if (iife === null) return null;\n\n    if (iife.parameters.length !== 1 || !isSuperIdentifier(iife.parameters[0].name)) {\n      return null;\n    }\n\n    if (!ts.isCallExpression(iife.parent)) {\n      return null;\n    }\n\n    return iife.parent.arguments[0];\n  }\n\n  /**\n   * Trace an identifier to its declaration, if possible.\n   *\n   * This method attempts to resolve the declaration of the given identifier, tracing back through\n   * imports and re-exports until the original declaration statement is found. A `Declaration`\n   * object is returned if the original declaration is found, or `null` is returned otherwise.\n   *\n   * In ES5, the implementation of a class is a function expression that is hidden inside an IIFE.\n   * If we are looking for the declaration of the identifier of the inner function expression, we\n   * will get hold of the outer \"class\" variable declaration and return its identifier instead. See\n   * `getClassDeclarationFromInnerFunctionDeclaration()` for more info.\n   *\n   * @param id a TypeScript `ts.Identifier` to trace back to a declaration.\n   *\n   * @returns metadata about the `Declaration` if the original declaration is found, or `null`\n   * otherwise.\n   */\n  getDeclarationOfIdentifier(id: ts.Identifier): Declaration|null {\n    const declaration = super.getDeclarationOfIdentifier(id);\n\n    if (declaration === null) {\n      const nonEmittedNorImportedTsHelperDeclaration = getTsHelperFnFromIdentifier(id);\n      if (nonEmittedNorImportedTsHelperDeclaration !== null) {\n        // No declaration could be found for this identifier and its name matches a known TS helper\n        // function. This can happen if a package is compiled with `noEmitHelpers: true` and\n        // `importHelpers: false` (the default). This is, for example, the case with\n        // `@nativescript/angular@9.0.0-next-2019-11-12-155500-01`.\n        return {\n          expression: id,\n          known: nonEmittedNorImportedTsHelperDeclaration,\n          node: null,\n          viaModule: null,\n        };\n      }\n    }\n\n    if (declaration === null || declaration.node === null || declaration.known !== null) {\n      return declaration;\n    }\n\n    if (!ts.isVariableDeclaration(declaration.node) || declaration.node.initializer !== undefined ||\n        // VariableDeclaration => VariableDeclarationList => VariableStatement => IIFE Block\n        !ts.isBlock(declaration.node.parent.parent.parent)) {\n      return declaration;\n    }\n\n    // We might have an alias to another variable declaration.\n    // Search the containing iife body for it.\n    const block = declaration.node.parent.parent.parent;\n    const aliasSymbol = this.checker.getSymbolAtLocation(declaration.node.name);\n    for (let i = 0; i < block.statements.length; i++) {\n      const statement = block.statements[i];\n      // Looking for statement that looks like: `AliasedVariable = OriginalVariable;`\n      if (isAssignmentStatement(statement) && ts.isIdentifier(statement.expression.left) &&\n          ts.isIdentifier(statement.expression.right) &&\n          this.checker.getSymbolAtLocation(statement.expression.left) === aliasSymbol) {\n        return this.getDeclarationOfIdentifier(statement.expression.right);\n      }\n    }\n\n    return declaration;\n  }\n\n  /**\n   * Parse a function declaration to find the relevant metadata about it.\n   *\n   * In ESM5 we need to do special work with optional arguments to the function, since they get\n   * their own initializer statement that needs to be parsed and then not included in the \"body\"\n   * statements of the function.\n   *\n   * @param node the function declaration to parse.\n   * @returns an object containing the node, statements and parameters of the function.\n   */\n  getDefinitionOfFunction(node: ts.Node): FunctionDefinition|null {\n    const definition = super.getDefinitionOfFunction(node);\n    if (definition === null) {\n      return null;\n    }\n\n    // Filter out and capture parameter initializers\n    if (definition.body !== null) {\n      let lookingForInitializers = true;\n      const statements = definition.body.filter(s => {\n        lookingForInitializers =\n            lookingForInitializers && captureParamInitializer(s, definition.parameters);\n        // If we are no longer looking for parameter initializers then we include this statement\n        return !lookingForInitializers;\n      });\n      definition.body = statements;\n    }\n\n    return definition;\n  }\n\n  /**\n   * Check whether a `Declaration` corresponds with a known declaration, such as a TypeScript helper\n   * function, and set its `known` property to the appropriate `KnownDeclaration`.\n   *\n   * @param decl The `Declaration` to check.\n   * @return The passed in `Declaration` (potentially enhanced with a `KnownDeclaration`).\n   */\n  detectKnownDeclaration<T extends Declaration>(decl: T): T {\n    decl = super.detectKnownDeclaration(decl);\n\n    // Also check for TS helpers\n    if (decl.known === null && decl.node !== null) {\n      decl.known = getTsHelperFnFromDeclaration(decl.node);\n    }\n\n    return decl;\n  }\n\n\n  ///////////// Protected Helpers /////////////\n\n  /**\n   * In ES5, the implementation of a class is a function expression that is hidden inside an IIFE,\n   * whose value is assigned to a variable (which represents the class to the rest of the program).\n   * So we might need to dig around to get hold of the \"class\" declaration.\n   *\n   * This method extracts a `NgccClassSymbol` if `declaration` is the function declaration inside\n   * the IIFE. Otherwise, undefined is returned.\n   *\n   * @param declaration the declaration whose symbol we are finding.\n   * @returns the symbol for the node or `undefined` if it is not a \"class\" or has no symbol.\n   */\n  protected getClassSymbolFromInnerDeclaration(declaration: ts.Node): NgccClassSymbol|undefined {\n    const classSymbol = super.getClassSymbolFromInnerDeclaration(declaration);\n    if (classSymbol !== undefined) {\n      return classSymbol;\n    }\n\n    if (!ts.isFunctionDeclaration(declaration) || !hasNameIdentifier(declaration)) {\n      return undefined;\n    }\n\n    const outerDeclaration = getClassDeclarationFromInnerDeclaration(declaration);\n    if (outerDeclaration === null || !hasNameIdentifier(outerDeclaration)) {\n      return undefined;\n    }\n\n    return this.createClassSymbol(outerDeclaration, declaration);\n  }\n\n  /**\n   * Find the declarations of the constructor parameters of a class identified by its symbol.\n   *\n   * In ESM5, there is no \"class\" so the constructor that we want is actually the inner function\n   * declaration inside the IIFE, whose return value is assigned to the outer variable declaration\n   * (that represents the class to the rest of the program).\n   *\n   * @param classSymbol the symbol of the class (i.e. the outer variable declaration) whose\n   * parameters we want to find.\n   * @returns an array of `ts.ParameterDeclaration` objects representing each of the parameters in\n   * the class's constructor or `null` if there is no constructor.\n   */\n  protected getConstructorParameterDeclarations(classSymbol: NgccClassSymbol):\n      ts.ParameterDeclaration[]|null {\n    const constructor = classSymbol.implementation.valueDeclaration;\n    if (!ts.isFunctionDeclaration(constructor)) return null;\n\n    if (constructor.parameters.length > 0) {\n      return Array.from(constructor.parameters);\n    }\n\n    if (isSynthesizedConstructor(constructor)) {\n      return null;\n    }\n\n    return [];\n  }\n\n  /**\n   * Get the parameter type and decorators for the constructor of a class,\n   * where the information is stored on a static method of the class.\n   *\n   * In this case the decorators are stored in the body of a method\n   * (`ctorParatemers`) attached to the constructor function.\n   *\n   * Note that unlike ESM2015 this is a function expression rather than an arrow\n   * function:\n   *\n   * ```\n   * SomeDirective.ctorParameters = function() { return [\n   *   { type: ViewContainerRef, },\n   *   { type: TemplateRef, },\n   *   { type: IterableDiffers, },\n   *   { type: undefined, decorators: [{ type: Inject, args: [INJECTED_TOKEN,] },] },\n   * ]; };\n   * ```\n   *\n   * @param paramDecoratorsProperty the property that holds the parameter info we want to get.\n   * @returns an array of objects containing the type and decorators for each parameter.\n   */\n  protected getParamInfoFromStaticProperty(paramDecoratorsProperty: ts.Symbol): ParamInfo[]|null {\n    const paramDecorators = getPropertyValueFromSymbol(paramDecoratorsProperty);\n    // The decorators array may be wrapped in a function. If so unwrap it.\n    const returnStatement = getReturnStatement(paramDecorators);\n    const expression = returnStatement ? returnStatement.expression : paramDecorators;\n    if (expression && ts.isArrayLiteralExpression(expression)) {\n      const elements = expression.elements;\n      return elements.map(reflectArrayElement).map(paramInfo => {\n        const typeExpression = paramInfo && paramInfo.has('type') ? paramInfo.get('type')! : null;\n        const decoratorInfo =\n            paramInfo && paramInfo.has('decorators') ? paramInfo.get('decorators')! : null;\n        const decorators = decoratorInfo && this.reflectDecorators(decoratorInfo);\n        return {typeExpression, decorators};\n      });\n    } else if (paramDecorators !== undefined) {\n      this.logger.warn(\n          'Invalid constructor parameter decorator in ' + paramDecorators.getSourceFile().fileName +\n              ':\\n',\n          paramDecorators.getText());\n    }\n    return null;\n  }\n\n  /**\n   * Reflect over a symbol and extract the member information, combining it with the\n   * provided decorator information, and whether it is a static member.\n   *\n   * If a class member uses accessors (e.g getters and/or setters) then it gets downleveled\n   * in ES5 to a single `Object.defineProperty()` call. In that case we must parse this\n   * call to extract the one or two ClassMember objects that represent the accessors.\n   *\n   * @param symbol the symbol for the member to reflect over.\n   * @param decorators an array of decorators associated with the member.\n   * @param isStatic true if this member is static, false if it is an instance property.\n   * @returns the reflected member information, or null if the symbol is not a member.\n   */\n  protected reflectMembers(symbol: ts.Symbol, decorators?: Decorator[], isStatic?: boolean):\n      ClassMember[]|null {\n    const node = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0];\n    const propertyDefinition = node && getPropertyDefinition(node);\n    if (propertyDefinition) {\n      const members: ClassMember[] = [];\n      if (propertyDefinition.setter) {\n        members.push({\n          node,\n          implementation: propertyDefinition.setter,\n          kind: ClassMemberKind.Setter,\n          type: null,\n          name: symbol.name,\n          nameNode: null,\n          value: null,\n          isStatic: isStatic || false,\n          decorators: decorators || [],\n        });\n\n        // Prevent attaching the decorators to a potential getter. In ES5, we can't tell where the\n        // decorators were originally attached to, however we only want to attach them to a single\n        // `ClassMember` as otherwise ngtsc would handle the same decorators twice.\n        decorators = undefined;\n      }\n      if (propertyDefinition.getter) {\n        members.push({\n          node,\n          implementation: propertyDefinition.getter,\n          kind: ClassMemberKind.Getter,\n          type: null,\n          name: symbol.name,\n          nameNode: null,\n          value: null,\n          isStatic: isStatic || false,\n          decorators: decorators || [],\n        });\n      }\n      return members;\n    }\n\n    const members = super.reflectMembers(symbol, decorators, isStatic);\n    members && members.forEach(member => {\n      if (member && member.kind === ClassMemberKind.Method && member.isStatic && member.node &&\n          ts.isPropertyAccessExpression(member.node) && member.node.parent &&\n          ts.isBinaryExpression(member.node.parent) &&\n          ts.isFunctionExpression(member.node.parent.right)) {\n        // Recompute the implementation for this member:\n        // ES5 static methods are variable declarations so the declaration is actually the\n        // initializer of the variable assignment\n        member.implementation = member.node.parent.right;\n      }\n    });\n    return members;\n  }\n\n  /**\n   * Find statements related to the given class that may contain calls to a helper.\n   *\n   * In ESM5 code the helper calls are hidden inside the class's IIFE.\n   *\n   * @param classSymbol the class whose helper calls we are interested in. We expect this symbol\n   * to reference the inner identifier inside the IIFE.\n   * @returns an array of statements that may contain helper calls.\n   */\n  protected getStatementsForClass(classSymbol: NgccClassSymbol): ts.Statement[] {\n    const classDeclarationParent = classSymbol.implementation.valueDeclaration.parent;\n    return ts.isBlock(classDeclarationParent) ? Array.from(classDeclarationParent.statements) : [];\n  }\n}\n\n///////////// Internal Helpers /////////////\n\n/**\n * Represents the details about property definitions that were set using `Object.defineProperty`.\n */\ninterface PropertyDefinition {\n  setter: ts.FunctionExpression|null;\n  getter: ts.FunctionExpression|null;\n}\n\n/**\n * In ES5, getters and setters have been downleveled into call expressions of\n * `Object.defineProperty`, such as\n *\n * ```\n * Object.defineProperty(Clazz.prototype, \"property\", {\n *   get: function () {\n *       return 'value';\n *   },\n *   set: function (value) {\n *       this.value = value;\n *   },\n *   enumerable: true,\n *   configurable: true\n * });\n * ```\n *\n * This function inspects the given node to determine if it corresponds with such a call, and if so\n * extracts the `set` and `get` function expressions from the descriptor object, if they exist.\n *\n * @param node The node to obtain the property definition from.\n * @returns The property definition if the node corresponds with accessor, null otherwise.\n */\nfunction getPropertyDefinition(node: ts.Node): PropertyDefinition|null {\n  if (!ts.isCallExpression(node)) return null;\n\n  const fn = node.expression;\n  if (!ts.isPropertyAccessExpression(fn) || !ts.isIdentifier(fn.expression) ||\n      fn.expression.text !== 'Object' || fn.name.text !== 'defineProperty')\n    return null;\n\n  const descriptor = node.arguments[2];\n  if (!descriptor || !ts.isObjectLiteralExpression(descriptor)) return null;\n\n  return {\n    setter: readPropertyFunctionExpression(descriptor, 'set'),\n    getter: readPropertyFunctionExpression(descriptor, 'get'),\n  };\n}\n\nfunction readPropertyFunctionExpression(object: ts.ObjectLiteralExpression, name: string) {\n  const property = object.properties.find(\n      (p): p is ts.PropertyAssignment =>\n          ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === name);\n\n  return property && ts.isFunctionExpression(property.initializer) && property.initializer || null;\n}\n\nfunction getReturnStatement(declaration: ts.Expression|undefined): ts.ReturnStatement|undefined {\n  return declaration && ts.isFunctionExpression(declaration) ?\n      declaration.body.statements.find(ts.isReturnStatement) :\n      undefined;\n}\n\nfunction reflectArrayElement(element: ts.Expression) {\n  return ts.isObjectLiteralExpression(element) ? reflectObjectLiteral(element) : null;\n}\n\n/**\n * A constructor function may have been \"synthesized\" by TypeScript during JavaScript emit,\n * in the case no user-defined constructor exists and e.g. property initializers are used.\n * Those initializers need to be emitted into a constructor in JavaScript, so the TypeScript\n * compiler generates a synthetic constructor.\n *\n * We need to identify such constructors as ngcc needs to be able to tell if a class did\n * originally have a constructor in the TypeScript source. For ES5, we can not tell an\n * empty constructor apart from a synthesized constructor, but fortunately that does not\n * matter for the code generated by ngtsc.\n *\n * When a class has a superclass however, a synthesized constructor must not be considered\n * as a user-defined constructor as that prevents a base factory call from being created by\n * ngtsc, resulting in a factory function that does not inject the dependencies of the\n * superclass. Hence, we identify a default synthesized super call in the constructor body,\n * according to the structure that TypeScript's ES2015 to ES5 transformer generates in\n * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1082-L1098\n *\n * @param constructor a constructor function to test\n * @returns true if the constructor appears to have been synthesized\n */\nfunction isSynthesizedConstructor(constructor: ts.FunctionDeclaration): boolean {\n  if (!constructor.body) return false;\n\n  const firstStatement = constructor.body.statements[0];\n  if (!firstStatement) return false;\n\n  return isSynthesizedSuperThisAssignment(firstStatement) ||\n      isSynthesizedSuperReturnStatement(firstStatement);\n}\n\n/**\n * Identifies a synthesized super call of the form:\n *\n * ```\n * var _this = _super !== null && _super.apply(this, arguments) || this;\n * ```\n *\n * @param statement a statement that may be a synthesized super call\n * @returns true if the statement looks like a synthesized super call\n */\nfunction isSynthesizedSuperThisAssignment(statement: ts.Statement): boolean {\n  if (!ts.isVariableStatement(statement)) return false;\n\n  const variableDeclarations = statement.declarationList.declarations;\n  if (variableDeclarations.length !== 1) return false;\n\n  const variableDeclaration = variableDeclarations[0];\n  if (!ts.isIdentifier(variableDeclaration.name) ||\n      !variableDeclaration.name.text.startsWith('_this'))\n    return false;\n\n  const initializer = variableDeclaration.initializer;\n  if (!initializer) return false;\n\n  return isSynthesizedDefaultSuperCall(initializer);\n}\n/**\n * Identifies a synthesized super call of the form:\n *\n * ```\n * return _super !== null && _super.apply(this, arguments) || this;\n * ```\n *\n * @param statement a statement that may be a synthesized super call\n * @returns true if the statement looks like a synthesized super call\n */\nfunction isSynthesizedSuperReturnStatement(statement: ts.Statement): boolean {\n  if (!ts.isReturnStatement(statement)) return false;\n\n  const expression = statement.expression;\n  if (!expression) return false;\n\n  return isSynthesizedDefaultSuperCall(expression);\n}\n\n/**\n * Tests whether the expression is of the form:\n *\n * ```\n * _super !== null && _super.apply(this, arguments) || this;\n * ```\n *\n * This structure is generated by TypeScript when transforming ES2015 to ES5, see\n * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1148-L1163\n *\n * @param expression an expression that may represent a default super call\n * @returns true if the expression corresponds with the above form\n */\nfunction isSynthesizedDefaultSuperCall(expression: ts.Expression): boolean {\n  if (!isBinaryExpr(expression, ts.SyntaxKind.BarBarToken)) return false;\n  if (expression.right.kind !== ts.SyntaxKind.ThisKeyword) return false;\n\n  const left = expression.left;\n  if (!isBinaryExpr(left, ts.SyntaxKind.AmpersandAmpersandToken)) return false;\n\n  return isSuperNotNull(left.left) && isSuperApplyCall(left.right);\n}\n\nfunction isSuperNotNull(expression: ts.Expression): boolean {\n  return isBinaryExpr(expression, ts.SyntaxKind.ExclamationEqualsEqualsToken) &&\n      isSuperIdentifier(expression.left);\n}\n\n/**\n * Tests whether the expression is of the form\n *\n * ```\n * _super.apply(this, arguments)\n * ```\n *\n * @param expression an expression that may represent a default super call\n * @returns true if the expression corresponds with the above form\n */\nfunction isSuperApplyCall(expression: ts.Expression): boolean {\n  if (!ts.isCallExpression(expression) || expression.arguments.length !== 2) return false;\n\n  const targetFn = expression.expression;\n  if (!ts.isPropertyAccessExpression(targetFn)) return false;\n  if (!isSuperIdentifier(targetFn.expression)) return false;\n  if (targetFn.name.text !== 'apply') return false;\n\n  const thisArgument = expression.arguments[0];\n  if (thisArgument.kind !== ts.SyntaxKind.ThisKeyword) return false;\n\n  const argumentsArgument = expression.arguments[1];\n  return ts.isIdentifier(argumentsArgument) && argumentsArgument.text === 'arguments';\n}\n\nfunction isBinaryExpr(\n    expression: ts.Expression, operator: ts.BinaryOperator): expression is ts.BinaryExpression {\n  return ts.isBinaryExpression(expression) && expression.operatorToken.kind === operator;\n}\n\nfunction isSuperIdentifier(node: ts.Node): boolean {\n  // Verify that the identifier is prefixed with `_super`. We don't test for equivalence\n  // as TypeScript may have suffixed the name, e.g. `_super_1` to avoid name conflicts.\n  // Requiring only a prefix should be sufficiently accurate.\n  return ts.isIdentifier(node) && node.text.startsWith('_super');\n}\n\n/**\n * Parse the statement to extract the ESM5 parameter initializer if there is one.\n * If one is found, add it to the appropriate parameter in the `parameters` collection.\n *\n * The form we are looking for is:\n *\n * ```\n * if (arg === void 0) { arg = initializer; }\n * ```\n *\n * @param statement a statement that may be initializing an optional parameter\n * @param parameters the collection of parameters that were found in the function definition\n * @returns true if the statement was a parameter initializer\n */\nfunction captureParamInitializer(statement: ts.Statement, parameters: Parameter[]) {\n  if (ts.isIfStatement(statement) && isUndefinedComparison(statement.expression) &&\n      ts.isBlock(statement.thenStatement) && statement.thenStatement.statements.length === 1) {\n    const ifStatementComparison = statement.expression;           // (arg === void 0)\n    const thenStatement = statement.thenStatement.statements[0];  // arg = initializer;\n    if (isAssignmentStatement(thenStatement)) {\n      const comparisonName = ifStatementComparison.left.text;\n      const assignmentName = thenStatement.expression.left.text;\n      if (comparisonName === assignmentName) {\n        const parameter = parameters.find(p => p.name === comparisonName);\n        if (parameter) {\n          parameter.initializer = thenStatement.expression.right;\n          return true;\n        }\n      }\n    }\n  }\n  return false;\n}\n\nfunction isUndefinedComparison(expression: ts.Expression): expression is ts.Expression&\n    {left: ts.Identifier, right: ts.Expression} {\n  return ts.isBinaryExpression(expression) &&\n      expression.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken &&\n      ts.isVoidExpression(expression.right) && ts.isIdentifier(expression.left);\n}\n\n/**\n * Parse the declaration of the given `classSymbol` to find the IIFE wrapper function.\n *\n * This function may accept a `_super` argument if there is a base class.\n *\n * ```\n * var TestClass = (function (_super) {\n *   __extends(TestClass, _super);\n *   function TestClass() {}\n *   return TestClass;\n * }(BaseClass));\n * ```\n *\n * @param classSymbol the class whose iife wrapper function we want to get.\n * @returns the IIFE function or null if it could not be parsed.\n */\nfunction getIifeFn(classSymbol: NgccClassSymbol|undefined): ts.FunctionExpression|null {\n  if (classSymbol === undefined) {\n    return null;\n  }\n\n  const innerDeclaration = classSymbol.implementation.valueDeclaration;\n  const iifeBody = innerDeclaration.parent;\n  if (!ts.isBlock(iifeBody)) {\n    return null;\n  }\n\n  const iifeWrapper = iifeBody.parent;\n  return iifeWrapper && ts.isFunctionExpression(iifeWrapper) ? iifeWrapper : null;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esm5_host.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/host/esm5_host.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as ts from 'typescript';\n\nimport {ClassDeclaration, ClassMember, ClassMemberKind, Declaration, Decorator, FunctionDefinition, KnownDeclaration, Parameter, reflectObjectLiteral} from '../../../src/ngtsc/reflection';\nimport {getTsHelperFnFromDeclaration, getTsHelperFnFromIdentifier, hasNameIdentifier} from '../utils';\n\nimport {Esm2015ReflectionHost, getClassDeclarationFromInnerDeclaration, getPropertyValueFromSymbol, isAssignmentStatement, ParamInfo} from './esm2015_host';\nimport {NgccClassSymbol} from './ngcc_host';\n\n\n/**\n * ESM5 packages contain ECMAScript IIFE functions that act like classes. For example:\n *\n * ```\n * var CommonModule = (function () {\n *  function CommonModule() {\n *  }\n *  CommonModule.decorators = [ ... ];\n *  return CommonModule;\n * ```\n *\n * * \"Classes\" are decorated if they have a static property called `decorators`.\n * * Members are decorated if there is a matching key on a static property\n *   called `propDecorators`.\n * * Constructor parameters decorators are found on an object returned from\n *   a static method called `ctorParameters`.\n *\n */\nexport class Esm5ReflectionHost extends Esm2015ReflectionHost {\n  getBaseClassExpression(clazz: ClassDeclaration): ts.Expression|null {\n    const superBaseClassExpression = super.getBaseClassExpression(clazz);\n    if (superBaseClassExpression !== null) {\n      return superBaseClassExpression;\n    }\n\n    const iife = getIifeFn(this.getClassSymbol(clazz));\n    if (iife === null) return null;\n\n    if (iife.parameters.length !== 1 || !isSuperIdentifier(iife.parameters[0].name)) {\n      return null;\n    }\n\n    if (!ts.isCallExpression(iife.parent)) {\n      return null;\n    }\n\n    return iife.parent.arguments[0];\n  }\n\n  /**\n   * Trace an identifier to its declaration, if possible.\n   *\n   * This method attempts to resolve the declaration of the given identifier, tracing back through\n   * imports and re-exports until the original declaration statement is found. A `Declaration`\n   * object is returned if the original declaration is found, or `null` is returned otherwise.\n   *\n   * In ES5, the implementation of a class is a function expression that is hidden inside an IIFE.\n   * If we are looking for the declaration of the identifier of the inner function expression, we\n   * will get hold of the outer \"class\" variable declaration and return its identifier instead. See\n   * `getClassDeclarationFromInnerFunctionDeclaration()` for more info.\n   *\n   * @param id a TypeScript `ts.Identifier` to trace back to a declaration.\n   *\n   * @returns metadata about the `Declaration` if the original declaration is found, or `null`\n   * otherwise.\n   */\n  getDeclarationOfIdentifier(id: ts.Identifier): Declaration|null {\n    const declaration = super.getDeclarationOfIdentifier(id);\n\n    if (declaration === null) {\n      const nonEmittedNorImportedTsHelperDeclaration = getTsHelperFnFromIdentifier(id);\n      if (nonEmittedNorImportedTsHelperDeclaration !== null) {\n        // No declaration could be found for this identifier and its name matches a known TS helper\n        // function. This can happen if a package is compiled with `noEmitHelpers: true` and\n        // `importHelpers: false` (the default). This is, for example, the case with\n        // `@nativescript/angular@9.0.0-next-2019-11-12-155500-01`.\n        return {\n          expression: id,\n          known: nonEmittedNorImportedTsHelperDeclaration,\n          node: null,\n          viaModule: null,\n        };\n      }\n    }\n\n    if (declaration === null || declaration.node === null || declaration.known !== null) {\n      return declaration;\n    }\n\n    if (!ts.isVariableDeclaration(declaration.node) || declaration.node.initializer !== undefined ||\n        // VariableDeclaration => VariableDeclarationList => VariableStatement => IIFE Block\n        !ts.isBlock(declaration.node.parent.parent.parent)) {\n      return declaration;\n    }\n\n    // We might have an alias to another variable declaration.\n    // Search the containing iife body for it.\n    const block = declaration.node.parent.parent.parent;\n    const aliasSymbol = this.checker.getSymbolAtLocation(declaration.node.name);\n    for (let i = 0; i < block.statements.length; i++) {\n      const statement = block.statements[i];\n      // Looking for statement that looks like: `AliasedVariable = OriginalVariable;`\n      if (isAssignmentStatement(statement) && ts.isIdentifier(statement.expression.left) &&\n          ts.isIdentifier(statement.expression.right) &&\n          this.checker.getSymbolAtLocation(statement.expression.left) === aliasSymbol) {\n        return this.getDeclarationOfIdentifier(statement.expression.right);\n      }\n    }\n\n    return declaration;\n  }\n\n  /**\n   * Parse a function declaration to find the relevant metadata about it.\n   *\n   * In ESM5 we need to do special work with optional arguments to the function, since they get\n   * their own initializer statement that needs to be parsed and then not included in the \"body\"\n   * statements of the function.\n   *\n   * @param node the function declaration to parse.\n   * @returns an object containing the node, statements and parameters of the function.\n   */\n  getDefinitionOfFunction(node: ts.Node): FunctionDefinition|null {\n    const definition = super.getDefinitionOfFunction(node);\n    if (definition === null) {\n      return null;\n    }\n\n    // Filter out and capture parameter initializers\n    if (definition.body !== null) {\n      let lookingForInitializers = true;\n      const statements = definition.body.filter(s => {\n        lookingForInitializers =\n            lookingForInitializers && captureParamInitializer(s, definition.parameters);\n        // If we are no longer looking for parameter initializers then we include this statement\n        return !lookingForInitializers;\n      });\n      definition.body = statements;\n    }\n\n    return definition;\n  }\n\n  /**\n   * Check whether a `Declaration` corresponds with a known declaration, such as a TypeScript helper\n   * function, and set its `known` property to the appropriate `KnownDeclaration`.\n   *\n   * @param decl The `Declaration` to check.\n   * @return The passed in `Declaration` (potentially enhanced with a `KnownDeclaration`).\n   */\n  detectKnownDeclaration<T extends Declaration>(decl: T): T {\n    decl = super.detectKnownDeclaration(decl);\n\n    // Also check for TS helpers\n    if (decl.known === null && decl.node !== null) {\n      decl.known = getTsHelperFnFromDeclaration(decl.node);\n    }\n\n    return decl;\n  }\n\n\n  ///////////// Protected Helpers /////////////\n\n  /**\n   * In ES5, the implementation of a class is a function expression that is hidden inside an IIFE,\n   * whose value is assigned to a variable (which represents the class to the rest of the program).\n   * So we might need to dig around to get hold of the \"class\" declaration.\n   *\n   * This method extracts a `NgccClassSymbol` if `declaration` is the function declaration inside\n   * the IIFE. Otherwise, undefined is returned.\n   *\n   * @param declaration the declaration whose symbol we are finding.\n   * @returns the symbol for the node or `undefined` if it is not a \"class\" or has no symbol.\n   */\n  protected getClassSymbolFromInnerDeclaration(declaration: ts.Node): NgccClassSymbol|undefined {\n    const classSymbol = super.getClassSymbolFromInnerDeclaration(declaration);\n    if (classSymbol !== undefined) {\n      return classSymbol;\n    }\n\n    if (!ts.isFunctionDeclaration(declaration) || !hasNameIdentifier(declaration)) {\n      return undefined;\n    }\n\n    const outerDeclaration = getClassDeclarationFromInnerDeclaration(declaration);\n    if (outerDeclaration === null || !hasNameIdentifier(outerDeclaration)) {\n      return undefined;\n    }\n\n    return this.createClassSymbol(outerDeclaration, declaration);\n  }\n\n  /**\n   * Find the declarations of the constructor parameters of a class identified by its symbol.\n   *\n   * In ESM5, there is no \"class\" so the constructor that we want is actually the inner function\n   * declaration inside the IIFE, whose return value is assigned to the outer variable declaration\n   * (that represents the class to the rest of the program).\n   *\n   * @param classSymbol the symbol of the class (i.e. the outer variable declaration) whose\n   * parameters we want to find.\n   * @returns an array of `ts.ParameterDeclaration` objects representing each of the parameters in\n   * the class's constructor or `null` if there is no constructor.\n   */\n  protected getConstructorParameterDeclarations(classSymbol: NgccClassSymbol):\n      ts.ParameterDeclaration[]|null {\n    const constructor = classSymbol.implementation.valueDeclaration;\n    if (!ts.isFunctionDeclaration(constructor)) return null;\n\n    if (constructor.parameters.length > 0) {\n      return Array.from(constructor.parameters);\n    }\n\n    if (this.isSynthesizedConstructor(constructor)) {\n      return null;\n    }\n\n    return [];\n  }\n\n  /**\n   * Get the parameter type and decorators for the constructor of a class,\n   * where the information is stored on a static method of the class.\n   *\n   * In this case the decorators are stored in the body of a method\n   * (`ctorParatemers`) attached to the constructor function.\n   *\n   * Note that unlike ESM2015 this is a function expression rather than an arrow\n   * function:\n   *\n   * ```\n   * SomeDirective.ctorParameters = function() { return [\n   *   { type: ViewContainerRef, },\n   *   { type: TemplateRef, },\n   *   { type: IterableDiffers, },\n   *   { type: undefined, decorators: [{ type: Inject, args: [INJECTED_TOKEN,] },] },\n   * ]; };\n   * ```\n   *\n   * @param paramDecoratorsProperty the property that holds the parameter info we want to get.\n   * @returns an array of objects containing the type and decorators for each parameter.\n   */\n  protected getParamInfoFromStaticProperty(paramDecoratorsProperty: ts.Symbol): ParamInfo[]|null {\n    const paramDecorators = getPropertyValueFromSymbol(paramDecoratorsProperty);\n    // The decorators array may be wrapped in a function. If so unwrap it.\n    const returnStatement = getReturnStatement(paramDecorators);\n    const expression = returnStatement ? returnStatement.expression : paramDecorators;\n    if (expression && ts.isArrayLiteralExpression(expression)) {\n      const elements = expression.elements;\n      return elements.map(reflectArrayElement).map(paramInfo => {\n        const typeExpression = paramInfo && paramInfo.has('type') ? paramInfo.get('type')! : null;\n        const decoratorInfo =\n            paramInfo && paramInfo.has('decorators') ? paramInfo.get('decorators')! : null;\n        const decorators = decoratorInfo && this.reflectDecorators(decoratorInfo);\n        return {typeExpression, decorators};\n      });\n    } else if (paramDecorators !== undefined) {\n      this.logger.warn(\n          'Invalid constructor parameter decorator in ' + paramDecorators.getSourceFile().fileName +\n              ':\\n',\n          paramDecorators.getText());\n    }\n    return null;\n  }\n\n  /**\n   * Reflect over a symbol and extract the member information, combining it with the\n   * provided decorator information, and whether it is a static member.\n   *\n   * If a class member uses accessors (e.g getters and/or setters) then it gets downleveled\n   * in ES5 to a single `Object.defineProperty()` call. In that case we must parse this\n   * call to extract the one or two ClassMember objects that represent the accessors.\n   *\n   * @param symbol the symbol for the member to reflect over.\n   * @param decorators an array of decorators associated with the member.\n   * @param isStatic true if this member is static, false if it is an instance property.\n   * @returns the reflected member information, or null if the symbol is not a member.\n   */\n  protected reflectMembers(symbol: ts.Symbol, decorators?: Decorator[], isStatic?: boolean):\n      ClassMember[]|null {\n    const node = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0];\n    const propertyDefinition = node && getPropertyDefinition(node);\n    if (propertyDefinition) {\n      const members: ClassMember[] = [];\n      if (propertyDefinition.setter) {\n        members.push({\n          node,\n          implementation: propertyDefinition.setter,\n          kind: ClassMemberKind.Setter,\n          type: null,\n          name: symbol.name,\n          nameNode: null,\n          value: null,\n          isStatic: isStatic || false,\n          decorators: decorators || [],\n        });\n\n        // Prevent attaching the decorators to a potential getter. In ES5, we can't tell where the\n        // decorators were originally attached to, however we only want to attach them to a single\n        // `ClassMember` as otherwise ngtsc would handle the same decorators twice.\n        decorators = undefined;\n      }\n      if (propertyDefinition.getter) {\n        members.push({\n          node,\n          implementation: propertyDefinition.getter,\n          kind: ClassMemberKind.Getter,\n          type: null,\n          name: symbol.name,\n          nameNode: null,\n          value: null,\n          isStatic: isStatic || false,\n          decorators: decorators || [],\n        });\n      }\n      return members;\n    }\n\n    const members = super.reflectMembers(symbol, decorators, isStatic);\n    members && members.forEach(member => {\n      if (member && member.kind === ClassMemberKind.Method && member.isStatic && member.node &&\n          ts.isPropertyAccessExpression(member.node) && member.node.parent &&\n          ts.isBinaryExpression(member.node.parent) &&\n          ts.isFunctionExpression(member.node.parent.right)) {\n        // Recompute the implementation for this member:\n        // ES5 static methods are variable declarations so the declaration is actually the\n        // initializer of the variable assignment\n        member.implementation = member.node.parent.right;\n      }\n    });\n    return members;\n  }\n\n  /**\n   * Find statements related to the given class that may contain calls to a helper.\n   *\n   * In ESM5 code the helper calls are hidden inside the class's IIFE.\n   *\n   * @param classSymbol the class whose helper calls we are interested in. We expect this symbol\n   * to reference the inner identifier inside the IIFE.\n   * @returns an array of statements that may contain helper calls.\n   */\n  protected getStatementsForClass(classSymbol: NgccClassSymbol): ts.Statement[] {\n    const classDeclarationParent = classSymbol.implementation.valueDeclaration.parent;\n    return ts.isBlock(classDeclarationParent) ? Array.from(classDeclarationParent.statements) : [];\n  }\n\n  ///////////// Host Private Helpers /////////////\n\n  /**\n   * A constructor function may have been \"synthesized\" by TypeScript during JavaScript emit,\n   * in the case no user-defined constructor exists and e.g. property initializers are used.\n   * Those initializers need to be emitted into a constructor in JavaScript, so the TypeScript\n   * compiler generates a synthetic constructor.\n   *\n   * We need to identify such constructors as ngcc needs to be able to tell if a class did\n   * originally have a constructor in the TypeScript source. For ES5, we can not tell an\n   * empty constructor apart from a synthesized constructor, but fortunately that does not\n   * matter for the code generated by ngtsc.\n   *\n   * When a class has a superclass however, a synthesized constructor must not be considered\n   * as a user-defined constructor as that prevents a base factory call from being created by\n   * ngtsc, resulting in a factory function that does not inject the dependencies of the\n   * superclass. Hence, we identify a default synthesized super call in the constructor body,\n   * according to the structure that TypeScript's ES2015 to ES5 transformer generates in\n   * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1082-L1098\n   *\n   * Additionally, we handle synthetic delegate constructors that are emitted when TypeScript\n   * downlevel's ES2015 synthetically generated to ES5. These vary slightly from the default\n   * structure mentioned above because the ES2015 output uses a spread operator, for delegating\n   * to the parent constructor, that is preserved through a TypeScript helper in ES5. e.g.\n   *\n   * ```\n   * return _super.apply(this, tslib.__spread(arguments)) || this;\n   * ```\n   *\n   * Such constructs can be still considered as synthetic delegate constructors as they are\n   * the product of a common TypeScript to ES5 synthetic constructor, just being downleveled\n   * to ES5 using `tsc`. See: https://github.com/angular/angular/issues/38453.\n   *\n   *\n   * @param constructor a constructor function to test\n   * @returns true if the constructor appears to have been synthesized\n   */\n  private isSynthesizedConstructor(constructor: ts.FunctionDeclaration): boolean {\n    if (!constructor.body) return false;\n\n    const firstStatement = constructor.body.statements[0];\n    if (!firstStatement) return false;\n\n    return this.isSynthesizedSuperThisAssignment(firstStatement) ||\n        this.isSynthesizedSuperReturnStatement(firstStatement);\n  }\n\n  /**\n   * Identifies synthesized super calls which pass-through function arguments directly and are\n   * being assigned to a common `_this` variable. The following patterns we intend to match:\n   *\n   * 1. Delegate call emitted by TypeScript when it emits ES5 directly.\n   *   ```\n   *   var _this = _super !== null && _super.apply(this, arguments) || this;\n   *   ```\n   *\n   * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.\n   *   ```\n   *   var _this = _super.apply(this, tslib.__spread(arguments)) || this;\n   *   ```\n   *\n   *\n   * @param statement a statement that may be a synthesized super call\n   * @returns true if the statement looks like a synthesized super call\n   */\n  private isSynthesizedSuperThisAssignment(statement: ts.Statement): boolean {\n    if (!ts.isVariableStatement(statement)) return false;\n\n    const variableDeclarations = statement.declarationList.declarations;\n    if (variableDeclarations.length !== 1) return false;\n\n    const variableDeclaration = variableDeclarations[0];\n    if (!ts.isIdentifier(variableDeclaration.name) ||\n        !variableDeclaration.name.text.startsWith('_this'))\n      return false;\n\n    const initializer = variableDeclaration.initializer;\n    if (!initializer) return false;\n\n    return this.isSynthesizedDefaultSuperCall(initializer);\n  }\n  /**\n   * Identifies synthesized super calls which pass-through function arguments directly and\n   * are being returned. The following patterns correspond to synthetic super return calls:\n   *\n   * 1. Delegate call emitted by TypeScript when it emits ES5 directly.\n   *   ```\n   *   return _super !== null && _super.apply(this, arguments) || this;\n   *   ```\n   *\n   * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.\n   *   ```\n   *   return _super.apply(this, tslib.__spread(arguments)) || this;\n   *   ```\n   *\n   * @param statement a statement that may be a synthesized super call\n   * @returns true if the statement looks like a synthesized super call\n   */\n  private isSynthesizedSuperReturnStatement(statement: ts.Statement): boolean {\n    if (!ts.isReturnStatement(statement)) return false;\n\n    const expression = statement.expression;\n    if (!expression) return false;\n\n    return this.isSynthesizedDefaultSuperCall(expression);\n  }\n\n  /**\n   * Identifies synthesized super calls which pass-through function arguments directly. The\n   * synthetic delegate super call match the following patterns we intend to match:\n   *\n   * 1. Delegate call emitted by TypeScript when it emits ES5 directly.\n   *   ```\n   *   _super !== null && _super.apply(this, arguments) || this;\n   *   ```\n   *\n   * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.\n   *   ```\n   *   _super.apply(this, tslib.__spread(arguments)) || this;\n   *   ```\n   *\n   * @param expression an expression that may represent a default super call\n   * @returns true if the expression corresponds with the above form\n   */\n  private isSynthesizedDefaultSuperCall(expression: ts.Expression): boolean {\n    if (!isBinaryExpr(expression, ts.SyntaxKind.BarBarToken)) return false;\n    if (expression.right.kind !== ts.SyntaxKind.ThisKeyword) return false;\n\n    const left = expression.left;\n    if (isBinaryExpr(left, ts.SyntaxKind.AmpersandAmpersandToken)) {\n      return isSuperNotNull(left.left) && this.isSuperApplyCall(left.right);\n    } else {\n      return this.isSuperApplyCall(left);\n    }\n  }\n\n  /**\n   * Tests whether the expression corresponds to a `super` call passing through\n   * function arguments without any modification. e.g.\n   *\n   * ```\n   * _super !== null && _super.apply(this, arguments) || this;\n   * ```\n   *\n   * This structure is generated by TypeScript when transforming ES2015 to ES5, see\n   * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1148-L1163\n   *\n   * Additionally, we also handle cases where `arguments` are wrapped by a TypeScript spread helper.\n   * This can happen if ES2015 class output contain auto-generated constructors due to class\n   * members. The ES2015 output will be using `super(...arguments)` to delegate to the superclass,\n   * but once downleveled to ES5, the spread operator will be persisted through a TypeScript spread\n   * helper. For example:\n   *\n   * ```\n   * _super.apply(this, __spread(arguments)) || this;\n   * ```\n   *\n   * More details can be found in: https://github.com/angular/angular/issues/38453.\n   *\n   * @param expression an expression that may represent a default super call\n   * @returns true if the expression corresponds with the above form\n   */\n  private isSuperApplyCall(expression: ts.Expression): boolean {\n    if (!ts.isCallExpression(expression) || expression.arguments.length !== 2) return false;\n\n    const targetFn = expression.expression;\n    if (!ts.isPropertyAccessExpression(targetFn)) return false;\n    if (!isSuperIdentifier(targetFn.expression)) return false;\n    if (targetFn.name.text !== 'apply') return false;\n\n    const thisArgument = expression.arguments[0];\n    if (thisArgument.kind !== ts.SyntaxKind.ThisKeyword) return false;\n\n    const argumentsExpr = expression.arguments[1];\n\n    // If the super is directly invoked with `arguments`, return `true`. This represents the\n    // common TypeScript output where the delegate constructor super call matches the following\n    // pattern: `super.apply(this, arguments)`.\n    if (isArgumentsIdentifier(argumentsExpr)) {\n      return true;\n    }\n\n    // The other scenario we intend to detect: The `arguments` variable might be wrapped with the\n    // TypeScript spread helper (either through tslib or inlined). This can happen if an explicit\n    // delegate constructor uses `super(...arguments)` in ES2015 and is downleveled to ES5 using\n    // `--downlevelIteration`. The output in such cases would not directly pass the function\n    // `arguments` to the `super` call, but wrap it in a TS spread helper. The output would match\n    // the following pattern: `super.apply(this, tslib.__spread(arguments))`. We check for such\n    // constructs below, but perform the detection of the call expression definition as last as\n    // that is the most expensive operation here.\n    if (!ts.isCallExpression(argumentsExpr) || argumentsExpr.arguments.length !== 1 ||\n        !isArgumentsIdentifier(argumentsExpr.arguments[0])) {\n      return false;\n    }\n\n    const argumentsCallExpr = argumentsExpr.expression;\n    let argumentsCallDeclaration: Declaration|null = null;\n\n    // The `__spread` helper could be globally available, or accessed through a namespaced\n    // import. Hence we support a property access here as long as it resolves to the actual\n    // known TypeScript spread helper.\n    if (ts.isIdentifier(argumentsCallExpr)) {\n      argumentsCallDeclaration = this.getDeclarationOfIdentifier(argumentsCallExpr);\n    } else if (\n        ts.isPropertyAccessExpression(argumentsCallExpr) &&\n        ts.isIdentifier(argumentsCallExpr.name)) {\n      argumentsCallDeclaration = this.getDeclarationOfIdentifier(argumentsCallExpr.name);\n    }\n\n    return argumentsCallDeclaration !== null &&\n        argumentsCallDeclaration.known === KnownDeclaration.TsHelperSpread;\n  }\n}\n\n///////////// Internal Helpers /////////////\n\n/**\n * Represents the details about property definitions that were set using `Object.defineProperty`.\n */\ninterface PropertyDefinition {\n  setter: ts.FunctionExpression|null;\n  getter: ts.FunctionExpression|null;\n}\n\n/**\n * In ES5, getters and setters have been downleveled into call expressions of\n * `Object.defineProperty`, such as\n *\n * ```\n * Object.defineProperty(Clazz.prototype, \"property\", {\n *   get: function () {\n *       return 'value';\n *   },\n *   set: function (value) {\n *       this.value = value;\n *   },\n *   enumerable: true,\n *   configurable: true\n * });\n * ```\n *\n * This function inspects the given node to determine if it corresponds with such a call, and if so\n * extracts the `set` and `get` function expressions from the descriptor object, if they exist.\n *\n * @param node The node to obtain the property definition from.\n * @returns The property definition if the node corresponds with accessor, null otherwise.\n */\nfunction getPropertyDefinition(node: ts.Node): PropertyDefinition|null {\n  if (!ts.isCallExpression(node)) return null;\n\n  const fn = node.expression;\n  if (!ts.isPropertyAccessExpression(fn) || !ts.isIdentifier(fn.expression) ||\n      fn.expression.text !== 'Object' || fn.name.text !== 'defineProperty')\n    return null;\n\n  const descriptor = node.arguments[2];\n  if (!descriptor || !ts.isObjectLiteralExpression(descriptor)) return null;\n\n  return {\n    setter: readPropertyFunctionExpression(descriptor, 'set'),\n    getter: readPropertyFunctionExpression(descriptor, 'get'),\n  };\n}\n\nfunction readPropertyFunctionExpression(object: ts.ObjectLiteralExpression, name: string) {\n  const property = object.properties.find(\n      (p): p is ts.PropertyAssignment =>\n          ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === name);\n\n  return property && ts.isFunctionExpression(property.initializer) && property.initializer || null;\n}\n\nfunction getReturnStatement(declaration: ts.Expression|undefined): ts.ReturnStatement|undefined {\n  return declaration && ts.isFunctionExpression(declaration) ?\n      declaration.body.statements.find(ts.isReturnStatement) :\n      undefined;\n}\n\nfunction reflectArrayElement(element: ts.Expression) {\n  return ts.isObjectLiteralExpression(element) ? reflectObjectLiteral(element) : null;\n}\n\nfunction isArgumentsIdentifier(expression: ts.Expression): boolean {\n  return ts.isIdentifier(expression) && expression.text === 'arguments';\n}\n\nfunction isSuperNotNull(expression: ts.Expression): boolean {\n  return isBinaryExpr(expression, ts.SyntaxKind.ExclamationEqualsEqualsToken) &&\n      isSuperIdentifier(expression.left);\n}\n\nfunction isBinaryExpr(\n    expression: ts.Expression, operator: ts.BinaryOperator): expression is ts.BinaryExpression {\n  return ts.isBinaryExpression(expression) && expression.operatorToken.kind === operator;\n}\n\nfunction isSuperIdentifier(node: ts.Node): boolean {\n  // Verify that the identifier is prefixed with `_super`. We don't test for equivalence\n  // as TypeScript may have suffixed the name, e.g. `_super_1` to avoid name conflicts.\n  // Requiring only a prefix should be sufficiently accurate.\n  return ts.isIdentifier(node) && node.text.startsWith('_super');\n}\n\n/**\n * Parse the statement to extract the ESM5 parameter initializer if there is one.\n * If one is found, add it to the appropriate parameter in the `parameters` collection.\n *\n * The form we are looking for is:\n *\n * ```\n * if (arg === void 0) { arg = initializer; }\n * ```\n *\n * @param statement a statement that may be initializing an optional parameter\n * @param parameters the collection of parameters that were found in the function definition\n * @returns true if the statement was a parameter initializer\n */\nfunction captureParamInitializer(statement: ts.Statement, parameters: Parameter[]) {\n  if (ts.isIfStatement(statement) && isUndefinedComparison(statement.expression) &&\n      ts.isBlock(statement.thenStatement) && statement.thenStatement.statements.length === 1) {\n    const ifStatementComparison = statement.expression;           // (arg === void 0)\n    const thenStatement = statement.thenStatement.statements[0];  // arg = initializer;\n    if (isAssignmentStatement(thenStatement)) {\n      const comparisonName = ifStatementComparison.left.text;\n      const assignmentName = thenStatement.expression.left.text;\n      if (comparisonName === assignmentName) {\n        const parameter = parameters.find(p => p.name === comparisonName);\n        if (parameter) {\n          parameter.initializer = thenStatement.expression.right;\n          return true;\n        }\n      }\n    }\n  }\n  return false;\n}\n\nfunction isUndefinedComparison(expression: ts.Expression): expression is ts.Expression&\n    {left: ts.Identifier, right: ts.Expression} {\n  return ts.isBinaryExpression(expression) &&\n      expression.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken &&\n      ts.isVoidExpression(expression.right) && ts.isIdentifier(expression.left);\n}\n\n/**\n * Parse the declaration of the given `classSymbol` to find the IIFE wrapper function.\n *\n * This function may accept a `_super` argument if there is a base class.\n *\n * ```\n * var TestClass = (function (_super) {\n *   __extends(TestClass, _super);\n *   function TestClass() {}\n *   return TestClass;\n * }(BaseClass));\n * ```\n *\n * @param classSymbol the class whose iife wrapper function we want to get.\n * @returns the IIFE function or null if it could not be parsed.\n */\nfunction getIifeFn(classSymbol: NgccClassSymbol|undefined): ts.FunctionExpression|null {\n  if (classSymbol === undefined) {\n    return null;\n  }\n\n  const innerDeclaration = classSymbol.implementation.valueDeclaration;\n  const iifeBody = innerDeclaration.parent;\n  if (!ts.isBlock(iifeBody)) {\n    return null;\n  }\n\n  const iifeWrapper = iifeBody.parent;\n  return iifeWrapper && ts.isFunctionExpression(iifeWrapper) ? iifeWrapper : null;\n}\n"]}

package/ngcc/src/packages/build_marker.d.ts

@@ -9,7 +9,7 @@
 import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
 import { PackageJsonUpdater } from '../writing/package_json_updater';
 import { EntryPointPackageJson, PackageJsonFormatProperties } from './entry_point';
-export declare const NGCC_VERSION = "10.0.9";
+export declare const NGCC_VERSION = "10.0.10";
 /**
  * Returns true if there is a format in this entry-point that was compiled with an outdated version
  * of ngcc.

package/ngcc/src/packages/build_marker.js

@@ -12,7 +12,7 @@
     exports.markAsProcessed = exports.hasBeenProcessed = exports.cleanPackageJson = exports.needsCleaning = exports.NGCC_VERSION = void 0;
     var tslib_1 = require("tslib");
     var new_entry_point_file_writer_1 = require("@angular/compiler-cli/ngcc/src/writing/new_entry_point_file_writer");
-    exports.NGCC_VERSION = '10.0.9';
+    exports.NGCC_VERSION = '10.0.10';
     /**
      * Returns true if there is a format in this entry-point that was compiled with an outdated version
      * of ngcc.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "10.0.9",
+  "version": "10.0.10",
   "description": "Angular - the compiler CLI for Node.js",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -26,7 +26,7 @@
     "yargs": "15.3.0"
   },
   "peerDependencies": {
-    "@angular/compiler": "10.0.9",
+    "@angular/compiler": "10.0.10",
     "typescript": ">=3.9 <4.0"
   },
   "engines": {

package/src/main.js

@@ -146,7 +146,6 @@
                 emitFlags: api.EmitFlags.Default
             };
         }
-        var allDiagnostics = [];
         var config = perform_compile_1.readConfiguration(project, cmdConfig.options);
         var options = tslib_1.__assign(tslib_1.__assign({}, config.options), existingOptions);
         if (options.locale) {
@@ -207,4 +206,4 @@
         process.exitCode = main(args);
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../../../../../../packages/compiler-cli/src/main.ts"],"names":[],"mappings":";AACA;;;;;;GAMG;;;;;;;;;;;;;;IAEH,oEAAoE;IACpE,4BAA0B;IAE1B,+BAAiC;IAIjC,gEAA0C;IAC1C,oEAAoD;IAEpD,6EAA0K;IAC1K,yEAAgF;IAChF,2EAAoE;IAEpE,SAAgB,IAAI,CAChB,IAAc,EAAE,YAAiD,EACjE,MAA+B,EAAE,kBAA2C,EAAE,YAE7E,EACD,qBAAwC;QAJxB,6BAAA,EAAA,eAAoC,OAAO,CAAC,KAAK;QAK/D,IAAA,KACA,MAAM,IAAI,kCAAkC,CAAC,IAAI,CAAC,EADjD,OAAO,aAAA,EAAE,SAAS,eAAA,EAAE,OAAO,aAAA,EAAU,YAAY,YAAA,EAAE,KAAK,WAAA,EAAE,SAAS,eAClB,CAAC;QACvD,IAAI,YAAY,CAAC,MAAM,EAAE;YACvB,OAAO,mBAAmB,CAAC,YAAY,EAAE,WAAW,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;SAC/E;QACD,IAAI,KAAK,EAAE;YACT,IAAM,MAAM,GAAG,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;YACzD,OAAO,mBAAmB,CAAC,MAAM,CAAC,kBAAkB,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;SAC9E;QAED,IAAI,UAAiC,CAAC;QACtC,IAAI,YAAY,KAAK,SAAS,EAAE;YAC9B,UAAU,GAAG,YAAY,CAAC,OAAO,CAAC;SACnC;QAEK,IAAA,KAAuC,oCAAkB,CAAC;YAC9D,SAAS,WAAA;YACT,OAAO,SAAA;YACP,SAAS,WAAA;YACT,UAAU,YAAA;YACV,YAAY,EAAE,kBAAkB,CAAC,OAAO,CAAC;YACzC,kBAAkB,oBAAA;YAClB,qBAAqB,uBAAA;SACtB,CAAC,EARkB,YAAY,iBAAA,EAAE,OAAO,aAQvC,CAAC;QACH,IAAI,YAAY,KAAK,SAAS,EAAE;YAC9B,YAAY,CAAC,OAAO,GAAG,OAAO,CAAC;SAChC;QACD,OAAO,mBAAmB,CAAC,YAAY,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;IAClE,CAAC;IAlCD,oBAkCC;IAED,SAAgB,sBAAsB,CAClC,IAAc,EAAE,MAA+B,EAC/C,YAA+C,EAC/C,qBAAwC;QACtC,IAAA,KACA,MAAM,IAAI,kCAAkC,CAAC,IAAI,CAAC,EADjD,OAAO,aAAA,EAAE,SAAS,eAAA,EAAE,OAAO,aAAA,EAAU,YAAY,YAAA,EAAE,KAAK,WAAA,EAAE,SAAS,eAClB,CAAC;QACvD,IAAI,YAAY,CAAC,MAAM,EAAE;YACvB,OAAO,YAAY,CAAC;SACrB;QAED,IAAI,UAAiC,CAAC;QACtC,IAAI,YAAY,KAAK,SAAS,EAAE;YAC9B,UAAU,GAAG,YAAY,CAAC,OAAO,CAAC;SACnC;QAEK,IAAA,KAAuC,oCAAkB,CAAC;YAC9D,SAAS,WAAA;YACT,OAAO,SAAA;YACP,SAAS,WAAA;YACT,UAAU,YAAA;YACV,qBAAqB,uBAAA;YACrB,YAAY,EAAE,kBAAkB,CAAC,OAAO,CAAC;SAC1C,CAAC,EAPkB,YAAY,iBAAA,EAAE,OAAO,aAOvC,CAAC;QAEH,IAAI,YAAY,KAAK,SAAS,EAAE;YAC9B,YAAY,CAAC,OAAO,GAAG,OAAO,CAAC;SAChC;QAED,OAAO,YAAY,CAAC;IACtB,CAAC;IA7BD,wDA6BC;IAED,SAAS,kBAAkB,CAAC,OAA4B;QACtD,IAAI,CAAC,OAAO,CAAC,0BAA0B,EAAE;YACvC,OAAO,SAAS,CAAC;SAClB;QACD,IAAM,WAAW,GAIsC;YACrD,2BAA2B,EAAE,UAAC,QAAQ,IAAK,OAAA,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC;gBAChE,kFAAkF;gBAClF,CAAC,CAAC,OAAO,CAAC,SAAS,IAAI,sBAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAFf,CAEe;YAC1D,gBAAgB,EAAE,UAAC,OAAO,EAAE,UAAU,IAAK,OAAA,EAAE,EAAF,CAAE;YAC7C,2BAA2B,EAAE,UAAC,QAAQ,IAAK,OAAA,KAAK,EAAL,CAAK;YAChD,kBAAkB,EAAE,UAAC,QAAQ,IAAK,OAAA,QAAQ,EAAR,CAAQ;YAC1C,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE,IAAI;YACb,2BAA2B,EAAE,KAAK;YAClC,gFAAgF;YAChF,+DAA+D;YAC/D,mBAAmB,EAAE,KAAK;YAC1B,uBAAuB,EAAE,IAAI;SAC9B,CAAC;QAEF,OAAO,UAAC,EASA;gBARC,OAAO,aAAA,EACP,gBAAgB,sBAAA,EAChB,SAAS,eAAA,EACT,iBAAiB,uBAAA,EACjB,gBAAgB,sBAAA,EAChB,0BAAuB,EAAvB,kBAAkB,mBAAG,EAAE,KAAA,EACvB,IAAI,UAAA,EACJ,OAAO,aAAA;YAEL,kFAAkF;YACzF,OAAA,OAAO,CAAC,SAAS,CAAC,CAAC,eAAe,CAC9B,OAAO,wCAAM,WAAW,KAAE,OAAO,SAAA,EAAE,IAAI,MAAA,EAAE,oBAAoB,EAAE,IAAI,KAAG,IAAI,EAAE,OAAO,EACnF,gBAAgB,EAAE,SAAS,EAAE,iBAAiB,EAAE,gBAAgB,EAAE;gBAChE,QAAQ,EAAE,kBAAkB,CAAC,MAAM;gBACnC,OAAO,EAAE,kBAAkB,CAAC,KAAK;aAClC,CAAC;QALN,CAKM,CAAC;IACb,CAAC;IAMD,SAAgB,kCAAkC,CAAC,IAAc;QAC/D,IAAM,OAAO,GAAwB,EAAE,CAAC;QACxC,IAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,UAAU,CAAC,QAAQ;YAAE,OAAO,CAAC,UAAU,GAAG,UAAU,CAAC,QAAQ,CAAC;QAClE,IAAI,UAAU,CAAC,UAAU;YAAE,OAAO,CAAC,YAAY,GAAG,UAAU,CAAC,UAAU,CAAC;QACxE,IAAI,UAAU,CAAC,MAAM;YAAE,OAAO,CAAC,YAAY,GAAG,UAAU,CAAC,MAAM,CAAC;QAChE,IAAM,EAAE,GAAG,UAAU,CAAC,kBAAkB,CAAC;QACzC,IAAI,EAAE,KAAK,OAAO,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,KAAK,QAAQ,EAAE;YACzD,OAAO,CAAC,yBAAyB,GAAG,EAAE,CAAC;SACxC;QACD,IAAM,MAAM,GAAG,+BAA+B,CAC1C,IAAI,EAAE,OAAO,EAAE,CAAC,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,oBAAoB,EAAE,OAAO,CAAC,CAAC,CAAC;QACxF,IAAM,KAAK,GAAG,UAAU,CAAC,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC;QAC/C,6CAAW,MAAM,KAAE,KAAK,OAAA,IAAE;IAC5B,CAAC;IAdD,gFAcC;IAED,SAAgB,+BAA+B,CAC3C,IAAc,EAAE,eAAyC,EACzD,gBAA+B;QADf,gCAAA,EAAA,oBAAyC;QACzD,iCAAA,EAAA,qBAA+B;QACjC,IAAI,SAAS,GAAG,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,OAAO,IAAI,GAAG,CAAC;QACjD,IAAM,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,UAAA,CAAC;YACzC,IAAI,OAAO,CAAC,CAAC,WAAW,KAAK,QAAQ,EAAE;gBACrC,IAAM,KAAG,GAAG,CAAC,CAAC,WAAW,CAAC;gBAC1B,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAA,CAAC,IAAI,OAAA,KAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,EAAnB,CAAmB,CAAC,CAAC;aACzD;YACD,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;QACH,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO;gBACL,OAAO,SAAA;gBACP,SAAS,EAAE,EAAE;gBACb,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,MAAM,EAAE,SAAS;gBACjB,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,OAAO;aACjC,CAAC;SACH;QACD,IAAM,cAAc,GAAgB,EAAE,CAAC;QACvC,IAAM,MAAM,GAAG,mCAAiB,CAAC,OAAO,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;QAC7D,IAAM,OAAO,yCAAO,MAAM,CAAC,OAAO,GAAK,eAAe,CAAC,CAAC;QACxD,IAAI,OAAO,CAAC,MAAM,EAAE;YAClB,OAAO,CAAC,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;SACvC;QACD,OAAO;YACL,OAAO,SAAA;YACP,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,OAAO,SAAA;YACP,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,SAAS,EAAE,MAAM,CAAC,SAAS;SAC5B,CAAC;IACJ,CAAC;IAlCD,0EAkCC;IAED,SAAS,wBAAwB,CAAC,OAA6B;QAC7D,IAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;QACxD,OAAO;YACL,mBAAmB,EAAE,cAAM,OAAA,QAAQ,IAAI,EAAE,CAAC,GAAG,CAAC,mBAAmB,EAAE,EAAxC,CAAwC;YACnE,+EAA+E;YAC/E,sFAAsF;YACtF,+BAA+B;YAC/B,oBAAoB,EAAE,UAAA,QAAQ,IAAI,OAAA,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,EAA5B,CAA4B;YAC9D,UAAU,EAAE;gBACV,6EAA6E;gBAC7E,iFAAiF;gBACjF,6EAA6E;gBAC7E,IAAI,OAAO,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS,EAAE;oBAC5C,OAAO,OAAO,CAAC,OAAO,KAAK,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC;iBACpE;gBACD,OAAO,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC;YACxB,CAAC;SACF,CAAC;IACJ,CAAC;IAED,SAAS,mBAAmB,CACxB,cAA2B,EAAE,OAA6B,EAC1D,YAAiD;QAAjD,6BAAA,EAAA,eAAoC,OAAO,CAAC,KAAK;QACnD,IAAM,iBAAiB,GAAG,yCAAuB,CAAC,cAAc,CAAC,CAAC;QAClE,gBAAgB,CAAC,iBAAiB,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;QAC3D,OAAO,oCAAkB,CAAC,cAAc,CAAC,CAAC;IAC5C,CAAC;IAED,SAAgB,SAAS,CACrB,OAAe,EAAE,OAA4B,EAAE,YAAiC;QAClF,OAAO,uCAAuB,CAAC,sCAAsB,CAAC,OAAO,EAAE,UAAA,WAAW;YACxE,gBAAgB,CAAC,WAAW,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;QACvD,CAAC,EAAE,OAAO,EAAE,UAAA,OAAO,IAAI,OAAA,kBAAkB,CAAC,OAAO,CAAC,EAA3B,CAA2B,CAAC,CAAC,CAAC;IACvD,CAAC;IALD,8BAKC;IAED,SAAS,gBAAgB,CACrB,WAAwD,EACxD,OAAsC,EAAE,YAAiC;QAC3E,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE;YAC5B,OAAO;SACR;QACD,IAAM,UAAU,GAAG,wBAAwB,CAAC,OAAO,CAAC,CAAC;QACrD,YAAY,CAAC,mCAAiB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED,kBAAkB;IAClB,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE;QAC3B,IAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACnC,uEAAuE;QACvE,2BAAa,CAAC,IAAI,8BAAgB,EAAE,CAAC,CAAC;QACtC,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;KAC/B","sourcesContent":["#!/usr/bin/env node\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// Must be imported first, because Angular decorators throw on load.\nimport 'reflect-metadata';\n\nimport * as ts from 'typescript';\nimport * as tsickle from 'tsickle';\n\nimport {replaceTsWithNgInErrors} from './ngtsc/diagnostics';\nimport * as api from './transformers/api';\nimport {GENERATED_FILES} from './transformers/util';\n\nimport {exitCodeFromResult, performCompilation, readConfiguration, formatDiagnostics, Diagnostics, ParsedConfiguration, filterErrorsAndWarnings} from './perform_compile';\nimport {performWatchCompilation, createPerformWatchHost} from './perform_watch';\nimport {NodeJSFileSystem, setFileSystem} from './ngtsc/file_system';\n\nexport function main(\n    args: string[], consoleError: (s: string) => void = console.error,\n    config?: NgcParsedConfiguration, customTransformers?: api.CustomTransformers, programReuse?: {\n      program: api.Program|undefined,\n    },\n    modifiedResourceFiles?: Set<string>|null): number {\n  let {project, rootNames, options, errors: configErrors, watch, emitFlags} =\n      config || readNgcCommandLineAndConfiguration(args);\n  if (configErrors.length) {\n    return reportErrorsAndExit(configErrors, /*options*/ undefined, consoleError);\n  }\n  if (watch) {\n    const result = watchMode(project, options, consoleError);\n    return reportErrorsAndExit(result.firstCompileResult, options, consoleError);\n  }\n\n  let oldProgram: api.Program|undefined;\n  if (programReuse !== undefined) {\n    oldProgram = programReuse.program;\n  }\n\n  const {diagnostics: compileDiags, program} = performCompilation({\n    rootNames,\n    options,\n    emitFlags,\n    oldProgram,\n    emitCallback: createEmitCallback(options),\n    customTransformers,\n    modifiedResourceFiles\n  });\n  if (programReuse !== undefined) {\n    programReuse.program = program;\n  }\n  return reportErrorsAndExit(compileDiags, options, consoleError);\n}\n\nexport function mainDiagnosticsForTest(\n    args: string[], config?: NgcParsedConfiguration,\n    programReuse?: {program: api.Program|undefined},\n    modifiedResourceFiles?: Set<string>|null): ReadonlyArray<ts.Diagnostic|api.Diagnostic> {\n  let {project, rootNames, options, errors: configErrors, watch, emitFlags} =\n      config || readNgcCommandLineAndConfiguration(args);\n  if (configErrors.length) {\n    return configErrors;\n  }\n\n  let oldProgram: api.Program|undefined;\n  if (programReuse !== undefined) {\n    oldProgram = programReuse.program;\n  }\n\n  const {diagnostics: compileDiags, program} = performCompilation({\n    rootNames,\n    options,\n    emitFlags,\n    oldProgram,\n    modifiedResourceFiles,\n    emitCallback: createEmitCallback(options),\n  });\n\n  if (programReuse !== undefined) {\n    programReuse.program = program;\n  }\n\n  return compileDiags;\n}\n\nfunction createEmitCallback(options: api.CompilerOptions): api.TsEmitCallback|undefined {\n  if (!options.annotateForClosureCompiler) {\n    return undefined;\n  }\n  const tsickleHost: Pick<\n      tsickle.TsickleHost,\n      'shouldSkipTsickleProcessing'|'pathToModuleName'|'shouldIgnoreWarningsForPath'|\n      'fileNameToModuleId'|'googmodule'|'untyped'|'convertIndexImportShorthand'|\n      'transformDecorators'|'transformTypesToClosure'> = {\n    shouldSkipTsickleProcessing: (fileName) => /\\.d\\.ts$/.test(fileName) ||\n        // View Engine's generated files were never intended to be processed with tsickle.\n        (!options.enableIvy && GENERATED_FILES.test(fileName)),\n    pathToModuleName: (context, importPath) => '',\n    shouldIgnoreWarningsForPath: (filePath) => false,\n    fileNameToModuleId: (fileName) => fileName,\n    googmodule: false,\n    untyped: true,\n    convertIndexImportShorthand: false,\n    // Decorators are transformed as part of the Angular compiler programs. To avoid\n    // conflicts, we disable decorator transformations for tsickle.\n    transformDecorators: false,\n    transformTypesToClosure: true,\n  };\n\n  return ({\n           program,\n           targetSourceFile,\n           writeFile,\n           cancellationToken,\n           emitOnlyDtsFiles,\n           customTransformers = {},\n           host,\n           options\n         }) =>\n             // tslint:disable-next-line:no-require-imports only depend on tsickle if requested\n      require('tsickle').emitWithTsickle(\n          program, {...tsickleHost, options, host, moduleResolutionHost: host}, host, options,\n          targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, {\n            beforeTs: customTransformers.before,\n            afterTs: customTransformers.after,\n          });\n}\n\nexport interface NgcParsedConfiguration extends ParsedConfiguration {\n  watch?: boolean;\n}\n\nexport function readNgcCommandLineAndConfiguration(args: string[]): NgcParsedConfiguration {\n  const options: api.CompilerOptions = {};\n  const parsedArgs = require('minimist')(args);\n  if (parsedArgs.i18nFile) options.i18nInFile = parsedArgs.i18nFile;\n  if (parsedArgs.i18nFormat) options.i18nInFormat = parsedArgs.i18nFormat;\n  if (parsedArgs.locale) options.i18nInLocale = parsedArgs.locale;\n  const mt = parsedArgs.missingTranslation;\n  if (mt === 'error' || mt === 'warning' || mt === 'ignore') {\n    options.i18nInMissingTranslations = mt;\n  }\n  const config = readCommandLineAndConfiguration(\n      args, options, ['i18nFile', 'i18nFormat', 'locale', 'missingTranslation', 'watch']);\n  const watch = parsedArgs.w || parsedArgs.watch;\n  return {...config, watch};\n}\n\nexport function readCommandLineAndConfiguration(\n    args: string[], existingOptions: api.CompilerOptions = {},\n    ngCmdLineOptions: string[] = []): ParsedConfiguration {\n  let cmdConfig = ts.parseCommandLine(args);\n  const project = cmdConfig.options.project || '.';\n  const cmdErrors = cmdConfig.errors.filter(e => {\n    if (typeof e.messageText === 'string') {\n      const msg = e.messageText;\n      return !ngCmdLineOptions.some(o => msg.indexOf(o) >= 0);\n    }\n    return true;\n  });\n  if (cmdErrors.length) {\n    return {\n      project,\n      rootNames: [],\n      options: cmdConfig.options,\n      errors: cmdErrors,\n      emitFlags: api.EmitFlags.Default\n    };\n  }\n  const allDiagnostics: Diagnostics = [];\n  const config = readConfiguration(project, cmdConfig.options);\n  const options = {...config.options, ...existingOptions};\n  if (options.locale) {\n    options.i18nInLocale = options.locale;\n  }\n  return {\n    project,\n    rootNames: config.rootNames,\n    options,\n    errors: config.errors,\n    emitFlags: config.emitFlags\n  };\n}\n\nfunction getFormatDiagnosticsHost(options?: api.CompilerOptions): ts.FormatDiagnosticsHost {\n  const basePath = options ? options.basePath : undefined;\n  return {\n    getCurrentDirectory: () => basePath || ts.sys.getCurrentDirectory(),\n    // We need to normalize the path separators here because by default, TypeScript\n    // compiler hosts use posix canonical paths. In order to print consistent diagnostics,\n    // we also normalize the paths.\n    getCanonicalFileName: fileName => fileName.replace(/\\\\/g, '/'),\n    getNewLine: () => {\n      // Manually determine the proper new line string based on the passed compiler\n      // options. There is no public TypeScript function that returns the corresponding\n      // new line string. see: https://github.com/Microsoft/TypeScript/issues/29581\n      if (options && options.newLine !== undefined) {\n        return options.newLine === ts.NewLineKind.LineFeed ? '\\n' : '\\r\\n';\n      }\n      return ts.sys.newLine;\n    },\n  };\n}\n\nfunction reportErrorsAndExit(\n    allDiagnostics: Diagnostics, options?: api.CompilerOptions,\n    consoleError: (s: string) => void = console.error): number {\n  const errorsAndWarnings = filterErrorsAndWarnings(allDiagnostics);\n  printDiagnostics(errorsAndWarnings, options, consoleError);\n  return exitCodeFromResult(allDiagnostics);\n}\n\nexport function watchMode(\n    project: string, options: api.CompilerOptions, consoleError: (s: string) => void) {\n  return performWatchCompilation(createPerformWatchHost(project, diagnostics => {\n    printDiagnostics(diagnostics, options, consoleError);\n  }, options, options => createEmitCallback(options)));\n}\n\nfunction printDiagnostics(\n    diagnostics: ReadonlyArray<ts.Diagnostic|api.Diagnostic>,\n    options: api.CompilerOptions|undefined, consoleError: (s: string) => void): void {\n  if (diagnostics.length === 0) {\n    return;\n  }\n  const formatHost = getFormatDiagnosticsHost(options);\n  consoleError(formatDiagnostics(diagnostics, formatHost));\n}\n\n// CLI entry point\nif (require.main === module) {\n  const args = process.argv.slice(2);\n  // We are running the real compiler so run against the real file-system\n  setFileSystem(new NodeJSFileSystem());\n  process.exitCode = main(args);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../../../../../../packages/compiler-cli/src/main.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// Must be imported first, because Angular decorators throw on load.\nimport 'reflect-metadata';\n\nimport * as ts from 'typescript';\nimport * as tsickle from 'tsickle';\n\nimport {replaceTsWithNgInErrors} from './ngtsc/diagnostics';\nimport * as api from './transformers/api';\nimport {GENERATED_FILES} from './transformers/util';\n\nimport {exitCodeFromResult, performCompilation, readConfiguration, formatDiagnostics, Diagnostics, ParsedConfiguration, filterErrorsAndWarnings} from './perform_compile';\nimport {performWatchCompilation, createPerformWatchHost} from './perform_watch';\nimport {NodeJSFileSystem, setFileSystem} from './ngtsc/file_system';\n\nexport function main(\n    args: string[], consoleError: (s: string) => void = console.error,\n    config?: NgcParsedConfiguration, customTransformers?: api.CustomTransformers, programReuse?: {\n      program: api.Program|undefined,\n    },\n    modifiedResourceFiles?: Set<string>|null): number {\n  let {project, rootNames, options, errors: configErrors, watch, emitFlags} =\n      config || readNgcCommandLineAndConfiguration(args);\n  if (configErrors.length) {\n    return reportErrorsAndExit(configErrors, /*options*/ undefined, consoleError);\n  }\n  if (watch) {\n    const result = watchMode(project, options, consoleError);\n    return reportErrorsAndExit(result.firstCompileResult, options, consoleError);\n  }\n\n  let oldProgram: api.Program|undefined;\n  if (programReuse !== undefined) {\n    oldProgram = programReuse.program;\n  }\n\n  const {diagnostics: compileDiags, program} = performCompilation({\n    rootNames,\n    options,\n    emitFlags,\n    oldProgram,\n    emitCallback: createEmitCallback(options),\n    customTransformers,\n    modifiedResourceFiles\n  });\n  if (programReuse !== undefined) {\n    programReuse.program = program;\n  }\n  return reportErrorsAndExit(compileDiags, options, consoleError);\n}\n\nexport function mainDiagnosticsForTest(\n    args: string[], config?: NgcParsedConfiguration,\n    programReuse?: {program: api.Program|undefined},\n    modifiedResourceFiles?: Set<string>|null): ReadonlyArray<ts.Diagnostic|api.Diagnostic> {\n  let {project, rootNames, options, errors: configErrors, watch, emitFlags} =\n      config || readNgcCommandLineAndConfiguration(args);\n  if (configErrors.length) {\n    return configErrors;\n  }\n\n  let oldProgram: api.Program|undefined;\n  if (programReuse !== undefined) {\n    oldProgram = programReuse.program;\n  }\n\n  const {diagnostics: compileDiags, program} = performCompilation({\n    rootNames,\n    options,\n    emitFlags,\n    oldProgram,\n    modifiedResourceFiles,\n    emitCallback: createEmitCallback(options),\n  });\n\n  if (programReuse !== undefined) {\n    programReuse.program = program;\n  }\n\n  return compileDiags;\n}\n\nfunction createEmitCallback(options: api.CompilerOptions): api.TsEmitCallback|undefined {\n  if (!options.annotateForClosureCompiler) {\n    return undefined;\n  }\n  const tsickleHost: Pick<\n      tsickle.TsickleHost,\n      'shouldSkipTsickleProcessing'|'pathToModuleName'|'shouldIgnoreWarningsForPath'|\n      'fileNameToModuleId'|'googmodule'|'untyped'|'convertIndexImportShorthand'|\n      'transformDecorators'|'transformTypesToClosure'> = {\n    shouldSkipTsickleProcessing: (fileName) => /\\.d\\.ts$/.test(fileName) ||\n        // View Engine's generated files were never intended to be processed with tsickle.\n        (!options.enableIvy && GENERATED_FILES.test(fileName)),\n    pathToModuleName: (context, importPath) => '',\n    shouldIgnoreWarningsForPath: (filePath) => false,\n    fileNameToModuleId: (fileName) => fileName,\n    googmodule: false,\n    untyped: true,\n    convertIndexImportShorthand: false,\n    // Decorators are transformed as part of the Angular compiler programs. To avoid\n    // conflicts, we disable decorator transformations for tsickle.\n    transformDecorators: false,\n    transformTypesToClosure: true,\n  };\n\n  return ({\n           program,\n           targetSourceFile,\n           writeFile,\n           cancellationToken,\n           emitOnlyDtsFiles,\n           customTransformers = {},\n           host,\n           options\n         }) =>\n             // tslint:disable-next-line:no-require-imports only depend on tsickle if requested\n      require('tsickle').emitWithTsickle(\n          program, {...tsickleHost, options, host, moduleResolutionHost: host}, host, options,\n          targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, {\n            beforeTs: customTransformers.before,\n            afterTs: customTransformers.after,\n          });\n}\n\nexport interface NgcParsedConfiguration extends ParsedConfiguration {\n  watch?: boolean;\n}\n\nexport function readNgcCommandLineAndConfiguration(args: string[]): NgcParsedConfiguration {\n  const options: api.CompilerOptions = {};\n  const parsedArgs = require('minimist')(args);\n  if (parsedArgs.i18nFile) options.i18nInFile = parsedArgs.i18nFile;\n  if (parsedArgs.i18nFormat) options.i18nInFormat = parsedArgs.i18nFormat;\n  if (parsedArgs.locale) options.i18nInLocale = parsedArgs.locale;\n  const mt = parsedArgs.missingTranslation;\n  if (mt === 'error' || mt === 'warning' || mt === 'ignore') {\n    options.i18nInMissingTranslations = mt;\n  }\n  const config = readCommandLineAndConfiguration(\n      args, options, ['i18nFile', 'i18nFormat', 'locale', 'missingTranslation', 'watch']);\n  const watch = parsedArgs.w || parsedArgs.watch;\n  return {...config, watch};\n}\n\nexport function readCommandLineAndConfiguration(\n    args: string[], existingOptions: api.CompilerOptions = {},\n    ngCmdLineOptions: string[] = []): ParsedConfiguration {\n  let cmdConfig = ts.parseCommandLine(args);\n  const project = cmdConfig.options.project || '.';\n  const cmdErrors = cmdConfig.errors.filter(e => {\n    if (typeof e.messageText === 'string') {\n      const msg = e.messageText;\n      return !ngCmdLineOptions.some(o => msg.indexOf(o) >= 0);\n    }\n    return true;\n  });\n  if (cmdErrors.length) {\n    return {\n      project,\n      rootNames: [],\n      options: cmdConfig.options,\n      errors: cmdErrors,\n      emitFlags: api.EmitFlags.Default\n    };\n  }\n  const config = readConfiguration(project, cmdConfig.options);\n  const options = {...config.options, ...existingOptions};\n  if (options.locale) {\n    options.i18nInLocale = options.locale;\n  }\n  return {\n    project,\n    rootNames: config.rootNames,\n    options,\n    errors: config.errors,\n    emitFlags: config.emitFlags\n  };\n}\n\nfunction getFormatDiagnosticsHost(options?: api.CompilerOptions): ts.FormatDiagnosticsHost {\n  const basePath = options ? options.basePath : undefined;\n  return {\n    getCurrentDirectory: () => basePath || ts.sys.getCurrentDirectory(),\n    // We need to normalize the path separators here because by default, TypeScript\n    // compiler hosts use posix canonical paths. In order to print consistent diagnostics,\n    // we also normalize the paths.\n    getCanonicalFileName: fileName => fileName.replace(/\\\\/g, '/'),\n    getNewLine: () => {\n      // Manually determine the proper new line string based on the passed compiler\n      // options. There is no public TypeScript function that returns the corresponding\n      // new line string. see: https://github.com/Microsoft/TypeScript/issues/29581\n      if (options && options.newLine !== undefined) {\n        return options.newLine === ts.NewLineKind.LineFeed ? '\\n' : '\\r\\n';\n      }\n      return ts.sys.newLine;\n    },\n  };\n}\n\nfunction reportErrorsAndExit(\n    allDiagnostics: Diagnostics, options?: api.CompilerOptions,\n    consoleError: (s: string) => void = console.error): number {\n  const errorsAndWarnings = filterErrorsAndWarnings(allDiagnostics);\n  printDiagnostics(errorsAndWarnings, options, consoleError);\n  return exitCodeFromResult(allDiagnostics);\n}\n\nexport function watchMode(\n    project: string, options: api.CompilerOptions, consoleError: (s: string) => void) {\n  return performWatchCompilation(createPerformWatchHost(project, diagnostics => {\n    printDiagnostics(diagnostics, options, consoleError);\n  }, options, options => createEmitCallback(options)));\n}\n\nfunction printDiagnostics(\n    diagnostics: ReadonlyArray<ts.Diagnostic|api.Diagnostic>,\n    options: api.CompilerOptions|undefined, consoleError: (s: string) => void): void {\n  if (diagnostics.length === 0) {\n    return;\n  }\n  const formatHost = getFormatDiagnosticsHost(options);\n  consoleError(formatDiagnostics(diagnostics, formatHost));\n}\n\n// CLI entry point\nif (require.main === module) {\n  const args = process.argv.slice(2);\n  // We are running the real compiler so run against the real file-system\n  setFileSystem(new NodeJSFileSystem());\n  process.exitCode = main(args);\n}\n"]}

package/src/version.js

@@ -23,6 +23,6 @@
      * Entry point for all public APIs of the common package.
      */
     var compiler_1 = require("@angular/compiler");
-    exports.VERSION = new compiler_1.Version('10.0.9');
+    exports.VERSION = new compiler_1.Version('10.0.10');
 });
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9zcmMvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7SUFFSDs7OztPQUlHO0lBRUgsOENBQTBDO0lBRTdCLFFBQUEsT0FBTyxHQUFHLElBQUksa0JBQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8qKlxuICogQG1vZHVsZVxuICogQGRlc2NyaXB0aW9uXG4gKiBFbnRyeSBwb2ludCBmb3IgYWxsIHB1YmxpYyBBUElzIG9mIHRoZSBjb21tb24gcGFja2FnZS5cbiAqL1xuXG5pbXBvcnQge1ZlcnNpb259IGZyb20gJ0Bhbmd1bGFyL2NvbXBpbGVyJztcblxuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBuZXcgVmVyc2lvbignMC4wLjAtUExBQ0VIT0xERVInKTtcbiJdfQ==