@angular/compiler-cli 12.1.1 → 12.1.5

package/src/transformers/downlevel_decorators_transform.mjs

@@ -1,507 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import * as ts from 'typescript';
-import { isAliasImportDeclaration, loadIsReferencedAliasDeclarationPatch } from './patch_alias_reference_resolution';
-/**
- * Whether a given decorator should be treated as an Angular decorator.
- * Either it's used in @angular/core, or it's imported from there.
- */
-function isAngularDecorator(decorator, isCore) {
-    return isCore || (decorator.import !== null && decorator.import.from === '@angular/core');
-}
-/*
- #####################################################################
-  Code below has been extracted from the tsickle decorator downlevel transformer
-  and a few local modifications have been applied:
-
-    1. Tsickle by default processed all decorators that had the `@Annotation` JSDoc.
-       We modified the transform to only be concerned with known Angular decorators.
-    2. Tsickle by default added `@nocollapse` to all generated `ctorParameters` properties.
-       We only do this when `annotateForClosureCompiler` is enabled.
-    3. Tsickle does not handle union types for dependency injection. i.e. if a injected type
-       is denoted with `@Optional`, the actual type could be set to `T | null`.
-       See: https://github.com/angular/angular-cli/commit/826803d0736b807867caff9f8903e508970ad5e4.
-    4. Tsickle relied on `emitDecoratorMetadata` to be set to `true`. This is due to a limitation
-       in TypeScript transformers that never has been fixed. We were able to work around this
-       limitation so that `emitDecoratorMetadata` doesn't need to be specified.
-       See: `patchAliasReferenceResolution` for more details.
-
-  Here is a link to the tsickle revision on which this transformer is based:
-  https://github.com/angular/tsickle/blob/fae06becb1570f491806060d83f29f2d50c43cdd/src/decorator_downlevel_transformer.ts
- #####################################################################
-*/
-/**
- * Creates the AST for the decorator field type annotation, which has the form
- *     { type: Function, args?: any[] }[]
- */
-function createDecoratorInvocationType() {
-    const typeElements = [];
-    typeElements.push(ts.createPropertySignature(undefined, 'type', undefined, ts.createTypeReferenceNode(ts.createIdentifier('Function'), undefined), undefined));
-    typeElements.push(ts.createPropertySignature(undefined, 'args', ts.createToken(ts.SyntaxKind.QuestionToken), ts.createArrayTypeNode(ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)), undefined));
-    return ts.createArrayTypeNode(ts.createTypeLiteralNode(typeElements));
-}
-/**
- * Extracts the type of the decorator (the function or expression invoked), as well as all the
- * arguments passed to the decorator. Returns an AST with the form:
- *
- *     // For @decorator(arg1, arg2)
- *     { type: decorator, args: [arg1, arg2] }
- */
-function extractMetadataFromSingleDecorator(decorator, diagnostics) {
-    const metadataProperties = [];
-    const expr = decorator.expression;
-    switch (expr.kind) {
-        case ts.SyntaxKind.Identifier:
-            // The decorator was a plain @Foo.
-            metadataProperties.push(ts.createPropertyAssignment('type', expr));
-            break;
-        case ts.SyntaxKind.CallExpression:
-            // The decorator was a call, like @Foo(bar).
-            const call = expr;
-            metadataProperties.push(ts.createPropertyAssignment('type', call.expression));
-            if (call.arguments.length) {
-                const args = [];
-                for (const arg of call.arguments) {
-                    args.push(arg);
-                }
-                const argsArrayLiteral = ts.createArrayLiteral(args);
-                argsArrayLiteral.elements.hasTrailingComma = true;
-                metadataProperties.push(ts.createPropertyAssignment('args', argsArrayLiteral));
-            }
-            break;
-        default:
-            diagnostics.push({
-                file: decorator.getSourceFile(),
-                start: decorator.getStart(),
-                length: decorator.getEnd() - decorator.getStart(),
-                messageText: `${ts.SyntaxKind[decorator.kind]} not implemented in gathering decorator metadata.`,
-                category: ts.DiagnosticCategory.Error,
-                code: 0,
-            });
-            break;
-    }
-    return ts.createObjectLiteral(metadataProperties);
-}
-/**
- * Takes a list of decorator metadata object ASTs and produces an AST for a
- * static class property of an array of those metadata objects.
- */
-function createDecoratorClassProperty(decoratorList) {
-    const modifier = ts.createToken(ts.SyntaxKind.StaticKeyword);
-    const type = createDecoratorInvocationType();
-    const initializer = ts.createArrayLiteral(decoratorList, true);
-    // NB: the .decorators property does not get a @nocollapse property. There is
-    // no good reason why - it means .decorators is not runtime accessible if you
-    // compile with collapse properties, whereas propDecorators is, which doesn't
-    // follow any stringent logic. However this has been the case previously, and
-    // adding it back in leads to substantial code size increases as Closure fails
-    // to tree shake these props without @nocollapse.
-    return ts.createProperty(undefined, [modifier], 'decorators', undefined, type, initializer);
-}
-/**
- * Creates the AST for the 'ctorParameters' field type annotation:
- *   () => ({ type: any, decorators?: {type: Function, args?: any[]}[] }|null)[]
- */
-function createCtorParametersClassPropertyType() {
-    // Sorry about this. Try reading just the string literals below.
-    const typeElements = [];
-    typeElements.push(ts.createPropertySignature(undefined, 'type', undefined, ts.createTypeReferenceNode(ts.createIdentifier('any'), undefined), undefined));
-    typeElements.push(ts.createPropertySignature(undefined, 'decorators', ts.createToken(ts.SyntaxKind.QuestionToken), ts.createArrayTypeNode(ts.createTypeLiteralNode([
-        ts.createPropertySignature(undefined, 'type', undefined, ts.createTypeReferenceNode(ts.createIdentifier('Function'), undefined), undefined),
-        ts.createPropertySignature(undefined, 'args', ts.createToken(ts.SyntaxKind.QuestionToken), ts.createArrayTypeNode(ts.createTypeReferenceNode(ts.createIdentifier('any'), undefined)), undefined),
-    ])), undefined));
-    return ts.createFunctionTypeNode(undefined, [], ts.createArrayTypeNode(ts.createUnionTypeNode([
-        ts.createTypeLiteralNode(typeElements),
-        ts.createLiteralTypeNode(ts.createNull()),
-    ])));
-}
-/**
- * Sets a Closure \@nocollapse synthetic comment on the given node. This prevents Closure Compiler
- * from collapsing the apparently static property, which would make it impossible to find for code
- * trying to detect it at runtime.
- */
-function addNoCollapseComment(n) {
-    ts.setSyntheticLeadingComments(n, [{
-            kind: ts.SyntaxKind.MultiLineCommentTrivia,
-            text: '* @nocollapse ',
-            pos: -1,
-            end: -1,
-            hasTrailingNewLine: true
-        }]);
-}
-/**
- * createCtorParametersClassProperty creates a static 'ctorParameters' property containing
- * downleveled decorator information.
- *
- * The property contains an arrow function that returns an array of object literals of the shape:
- *     static ctorParameters = () => [{
- *       type: SomeClass|undefined,  // the type of the param that's decorated, if it's a value.
- *       decorators: [{
- *         type: DecoratorFn,  // the type of the decorator that's invoked.
- *         args: [ARGS],       // the arguments passed to the decorator.
- *       }]
- *     }];
- */
-function createCtorParametersClassProperty(diagnostics, entityNameToExpression, ctorParameters, isClosureCompilerEnabled) {
-    const params = [];
-    for (const ctorParam of ctorParameters) {
-        if (!ctorParam.type && ctorParam.decorators.length === 0) {
-            params.push(ts.createNull());
-            continue;
-        }
-        const paramType = ctorParam.type ?
-            typeReferenceToExpression(entityNameToExpression, ctorParam.type) :
-            undefined;
-        const members = [ts.createPropertyAssignment('type', paramType || ts.createIdentifier('undefined'))];
-        const decorators = [];
-        for (const deco of ctorParam.decorators) {
-            decorators.push(extractMetadataFromSingleDecorator(deco, diagnostics));
-        }
-        if (decorators.length) {
-            members.push(ts.createPropertyAssignment('decorators', ts.createArrayLiteral(decorators)));
-        }
-        params.push(ts.createObjectLiteral(members));
-    }
-    const initializer = ts.createArrowFunction(undefined, undefined, [], undefined, ts.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.createArrayLiteral(params, true));
-    const type = createCtorParametersClassPropertyType();
-    const ctorProp = ts.createProperty(undefined, [ts.createToken(ts.SyntaxKind.StaticKeyword)], 'ctorParameters', undefined, type, initializer);
-    if (isClosureCompilerEnabled) {
-        addNoCollapseComment(ctorProp);
-    }
-    return ctorProp;
-}
-/**
- * createPropDecoratorsClassProperty creates a static 'propDecorators' property containing type
- * information for every property that has a decorator applied.
- *
- *     static propDecorators: {[key: string]: {type: Function, args?: any[]}[]} = {
- *       propA: [{type: MyDecorator, args: [1, 2]}, ...],
- *       ...
- *     };
- */
-function createPropDecoratorsClassProperty(diagnostics, properties) {
-    //  `static propDecorators: {[key: string]: ` + {type: Function, args?: any[]}[] + `} = {\n`);
-    const entries = [];
-    for (const [name, decorators] of properties.entries()) {
-        entries.push(ts.createPropertyAssignment(name, ts.createArrayLiteral(decorators.map(deco => extractMetadataFromSingleDecorator(deco, diagnostics)))));
-    }
-    const initializer = ts.createObjectLiteral(entries, true);
-    const type = ts.createTypeLiteralNode([ts.createIndexSignature(undefined, undefined, [ts.createParameter(undefined, undefined, undefined, 'key', undefined, ts.createTypeReferenceNode('string', undefined), undefined)], createDecoratorInvocationType())]);
-    return ts.createProperty(undefined, [ts.createToken(ts.SyntaxKind.StaticKeyword)], 'propDecorators', undefined, type, initializer);
-}
-/**
- * Returns an expression representing the (potentially) value part for the given node.
- *
- * This is a partial re-implementation of TypeScript's serializeTypeReferenceNode. This is a
- * workaround for https://github.com/Microsoft/TypeScript/issues/17516 (serializeTypeReferenceNode
- * not being exposed). In practice this implementation is sufficient for Angular's use of type
- * metadata.
- */
-function typeReferenceToExpression(entityNameToExpression, node) {
-    let kind = node.kind;
-    if (ts.isLiteralTypeNode(node)) {
-        // Treat literal types like their base type (boolean, string, number).
-        kind = node.literal.kind;
-    }
-    switch (kind) {
-        case ts.SyntaxKind.FunctionType:
-        case ts.SyntaxKind.ConstructorType:
-            return ts.createIdentifier('Function');
-        case ts.SyntaxKind.ArrayType:
-        case ts.SyntaxKind.TupleType:
-            return ts.createIdentifier('Array');
-        case ts.SyntaxKind.TypePredicate:
-        case ts.SyntaxKind.TrueKeyword:
-        case ts.SyntaxKind.FalseKeyword:
-        case ts.SyntaxKind.BooleanKeyword:
-            return ts.createIdentifier('Boolean');
-        case ts.SyntaxKind.StringLiteral:
-        case ts.SyntaxKind.StringKeyword:
-            return ts.createIdentifier('String');
-        case ts.SyntaxKind.ObjectKeyword:
-            return ts.createIdentifier('Object');
-        case ts.SyntaxKind.NumberKeyword:
-        case ts.SyntaxKind.NumericLiteral:
-            return ts.createIdentifier('Number');
-        case ts.SyntaxKind.TypeReference:
-            const typeRef = node;
-            // Ignore any generic types, just return the base type.
-            return entityNameToExpression(typeRef.typeName);
-        case ts.SyntaxKind.UnionType:
-            const childTypeNodes = node
-                .types.filter(t => !(ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword));
-            return childTypeNodes.length === 1 ?
-                typeReferenceToExpression(entityNameToExpression, childTypeNodes[0]) :
-                undefined;
-        default:
-            return undefined;
-    }
-}
-/**
- * Checks whether a given symbol refers to a value that exists at runtime (as distinct from a type).
- *
- * Expands aliases, which is important for the case where
- *   import * as x from 'some-module';
- * and x is now a value (the module object).
- */
-function symbolIsRuntimeValue(typeChecker, symbol) {
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-        symbol = typeChecker.getAliasedSymbol(symbol);
-    }
-    // Note that const enums are a special case, because
-    // while they have a value, they don't exist at runtime.
-    return (symbol.flags & ts.SymbolFlags.Value & ts.SymbolFlags.ConstEnumExcludes) !== 0;
-}
-/**
- * Gets a transformer for downleveling Angular decorators.
- * @param typeChecker Reference to the program's type checker.
- * @param host Reflection host that is used for determining decorators.
- * @param diagnostics List which will be populated with diagnostics if any.
- * @param isCore Whether the current TypeScript program is for the `@angular/core` package.
- * @param isClosureCompilerEnabled Whether closure annotations need to be added where needed.
- * @param skipClassDecorators Whether class decorators should be skipped from downleveling.
- *   This is useful for JIT mode where class decorators should be preserved as they could rely
- *   on immediate execution. e.g. downleveling `@Injectable` means that the injectable factory
- *   is not created, and injecting the token will not work. If this decorator would not be
- *   downleveled, the `Injectable` decorator will execute immediately on file load, and
- *   Angular will generate the corresponding injectable factory.
- */
-export function getDownlevelDecoratorsTransform(typeChecker, host, diagnostics, isCore, isClosureCompilerEnabled, skipClassDecorators) {
-    return (context) => {
-        // Ensure that referenced type symbols are not elided by TypeScript. Imports for
-        // such parameter type symbols previously could be type-only, but now might be also
-        // used in the `ctorParameters` static property as a value. We want to make sure
-        // that TypeScript does not elide imports for such type references. Read more
-        // about this in the description for `loadIsReferencedAliasDeclarationPatch`.
-        const referencedParameterTypes = loadIsReferencedAliasDeclarationPatch(context);
-        /**
-         * Converts an EntityName (from a type annotation) to an expression (accessing a value).
-         *
-         * For a given qualified name, this walks depth first to find the leftmost identifier,
-         * and then converts the path into a property access that can be used as expression.
-         */
-        function entityNameToExpression(name) {
-            const symbol = typeChecker.getSymbolAtLocation(name);
-            // Check if the entity name references a symbol that is an actual value. If it is not, it
-            // cannot be referenced by an expression, so return undefined.
-            if (!symbol || !symbolIsRuntimeValue(typeChecker, symbol) || !symbol.declarations ||
-                symbol.declarations.length === 0) {
-                return undefined;
-            }
-            // If we deal with a qualified name, build up a property access expression
-            // that could be used in the JavaScript output.
-            if (ts.isQualifiedName(name)) {
-                const containerExpr = entityNameToExpression(name.left);
-                if (containerExpr === undefined) {
-                    return undefined;
-                }
-                return ts.createPropertyAccess(containerExpr, name.right);
-            }
-            const decl = symbol.declarations[0];
-            // If the given entity name has been resolved to an alias import declaration,
-            // ensure that the alias declaration is not elided by TypeScript, and use its
-            // name identifier to reference it at runtime.
-            if (isAliasImportDeclaration(decl)) {
-                referencedParameterTypes.add(decl);
-                // If the entity name resolves to an alias import declaration, we reference the
-                // entity based on the alias import name. This ensures that TypeScript properly
-                // resolves the link to the import. Cloning the original entity name identifier
-                // could lead to an incorrect resolution at local scope. e.g. Consider the following
-                // snippet: `constructor(Dep: Dep) {}`. In such a case, the local `Dep` identifier
-                // would resolve to the actual parameter name, and not to the desired import.
-                // This happens because the entity name identifier symbol is internally considered
-                // as type-only and therefore TypeScript tries to resolve it as value manually.
-                // We can help TypeScript and avoid this non-reliable resolution by using an identifier
-                // that is not type-only and is directly linked to the import alias declaration.
-                if (decl.name !== undefined) {
-                    return ts.getMutableClone(decl.name);
-                }
-            }
-            // Clone the original entity name identifier so that it can be used to reference
-            // its value at runtime. This is used when the identifier is resolving to a file
-            // local declaration (otherwise it would resolve to an alias import declaration).
-            return ts.getMutableClone(name);
-        }
-        /**
-         * Transforms a class element. Returns a three tuple of name, transformed element, and
-         * decorators found. Returns an undefined name if there are no decorators to lower on the
-         * element, or the element has an exotic name.
-         */
-        function transformClassElement(element) {
-            element = ts.visitEachChild(element, decoratorDownlevelVisitor, context);
-            const decoratorsToKeep = [];
-            const toLower = [];
-            const decorators = host.getDecoratorsOfDeclaration(element) || [];
-            for (const decorator of decorators) {
-                // We only deal with concrete nodes in TypeScript sources, so we don't
-                // need to handle synthetically created decorators.
-                const decoratorNode = decorator.node;
-                if (!isAngularDecorator(decorator, isCore)) {
-                    decoratorsToKeep.push(decoratorNode);
-                    continue;
-                }
-                toLower.push(decoratorNode);
-            }
-            if (!toLower.length)
-                return [undefined, element, []];
-            if (!element.name || !ts.isIdentifier(element.name)) {
-                // Method has a weird name, e.g.
-                //   [Symbol.foo]() {...}
-                diagnostics.push({
-                    file: element.getSourceFile(),
-                    start: element.getStart(),
-                    length: element.getEnd() - element.getStart(),
-                    messageText: `Cannot process decorators for class element with non-analyzable name.`,
-                    category: ts.DiagnosticCategory.Error,
-                    code: 0,
-                });
-                return [undefined, element, []];
-            }
-            const name = element.name.text;
-            const mutable = ts.getMutableClone(element);
-            mutable.decorators = decoratorsToKeep.length ?
-                ts.setTextRange(ts.createNodeArray(decoratorsToKeep), mutable.decorators) :
-                undefined;
-            return [name, mutable, toLower];
-        }
-        /**
-         * Transforms a constructor. Returns the transformed constructor and the list of parameter
-         * information collected, consisting of decorators and optional type.
-         */
-        function transformConstructor(ctor) {
-            ctor = ts.visitEachChild(ctor, decoratorDownlevelVisitor, context);
-            const newParameters = [];
-            const oldParameters = ts.visitParameterList(ctor.parameters, decoratorDownlevelVisitor, context);
-            const parametersInfo = [];
-            for (const param of oldParameters) {
-                const decoratorsToKeep = [];
-                const paramInfo = { decorators: [], type: null };
-                const decorators = host.getDecoratorsOfDeclaration(param) || [];
-                for (const decorator of decorators) {
-                    // We only deal with concrete nodes in TypeScript sources, so we don't
-                    // need to handle synthetically created decorators.
-                    const decoratorNode = decorator.node;
-                    if (!isAngularDecorator(decorator, isCore)) {
-                        decoratorsToKeep.push(decoratorNode);
-                        continue;
-                    }
-                    paramInfo.decorators.push(decoratorNode);
-                }
-                if (param.type) {
-                    // param has a type provided, e.g. "foo: Bar".
-                    // The type will be emitted as a value expression in entityNameToExpression, which takes
-                    // care not to emit anything for types that cannot be expressed as a value (e.g.
-                    // interfaces).
-                    paramInfo.type = param.type;
-                }
-                parametersInfo.push(paramInfo);
-                const newParam = ts.updateParameter(param, 
-                // Must pass 'undefined' to avoid emitting decorator metadata.
-                decoratorsToKeep.length ? decoratorsToKeep : undefined, param.modifiers, param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer);
-                newParameters.push(newParam);
-            }
-            const updated = ts.updateConstructor(ctor, ctor.decorators, ctor.modifiers, newParameters, ts.visitFunctionBody(ctor.body, decoratorDownlevelVisitor, context));
-            return [updated, parametersInfo];
-        }
-        /**
-         * Transforms a single class declaration:
-         * - dispatches to strip decorators on members
-         * - converts decorators on the class to annotations
-         * - creates a ctorParameters property
-         * - creates a propDecorators property
-         */
-        function transformClassDeclaration(classDecl) {
-            classDecl = ts.getMutableClone(classDecl);
-            const newMembers = [];
-            const decoratedProperties = new Map();
-            let classParameters = null;
-            for (const member of classDecl.members) {
-                switch (member.kind) {
-                    case ts.SyntaxKind.PropertyDeclaration:
-                    case ts.SyntaxKind.GetAccessor:
-                    case ts.SyntaxKind.SetAccessor:
-                    case ts.SyntaxKind.MethodDeclaration: {
-                        const [name, newMember, decorators] = transformClassElement(member);
-                        newMembers.push(newMember);
-                        if (name)
-                            decoratedProperties.set(name, decorators);
-                        continue;
-                    }
-                    case ts.SyntaxKind.Constructor: {
-                        const ctor = member;
-                        if (!ctor.body)
-                            break;
-                        const [newMember, parametersInfo] = transformConstructor(member);
-                        classParameters = parametersInfo;
-                        newMembers.push(newMember);
-                        continue;
-                    }
-                    default:
-                        break;
-                }
-                newMembers.push(ts.visitEachChild(member, decoratorDownlevelVisitor, context));
-            }
-            // The `ReflectionHost.getDecoratorsOfDeclaration()` method will not return certain kinds of
-            // decorators that will never be Angular decorators. So we cannot rely on it to capture all
-            // the decorators that should be kept. Instead we start off with a set of the raw decorators
-            // on the class, and only remove the ones that have been identified for downleveling.
-            const decoratorsToKeep = new Set(classDecl.decorators);
-            const possibleAngularDecorators = host.getDecoratorsOfDeclaration(classDecl) || [];
-            let hasAngularDecorator = false;
-            const decoratorsToLower = [];
-            for (const decorator of possibleAngularDecorators) {
-                // We only deal with concrete nodes in TypeScript sources, so we don't
-                // need to handle synthetically created decorators.
-                const decoratorNode = decorator.node;
-                const isNgDecorator = isAngularDecorator(decorator, isCore);
-                // Keep track if we come across an Angular class decorator. This is used
-                // for to determine whether constructor parameters should be captured or not.
-                if (isNgDecorator) {
-                    hasAngularDecorator = true;
-                }
-                if (isNgDecorator && !skipClassDecorators) {
-                    decoratorsToLower.push(extractMetadataFromSingleDecorator(decoratorNode, diagnostics));
-                    decoratorsToKeep.delete(decoratorNode);
-                }
-            }
-            if (decoratorsToLower.length) {
-                newMembers.push(createDecoratorClassProperty(decoratorsToLower));
-            }
-            if (classParameters) {
-                if (hasAngularDecorator || classParameters.some(p => !!p.decorators.length)) {
-                    // Capture constructor parameters if the class has Angular decorator applied,
-                    // or if any of the parameters has decorators applied directly.
-                    newMembers.push(createCtorParametersClassProperty(diagnostics, entityNameToExpression, classParameters, isClosureCompilerEnabled));
-                }
-            }
-            if (decoratedProperties.size) {
-                newMembers.push(createPropDecoratorsClassProperty(diagnostics, decoratedProperties));
-            }
-            const members = ts.setTextRange(ts.createNodeArray(newMembers, classDecl.members.hasTrailingComma), classDecl.members);
-            return ts.updateClassDeclaration(classDecl, decoratorsToKeep.size ? Array.from(decoratorsToKeep) : undefined, classDecl.modifiers, classDecl.name, classDecl.typeParameters, classDecl.heritageClauses, members);
-        }
-        /**
-         * Transformer visitor that looks for Angular decorators and replaces them with
-         * downleveled static properties. Also collects constructor type metadata for
-         * class declaration that are decorated with an Angular decorator.
-         */
-        function decoratorDownlevelVisitor(node) {
-            if (ts.isClassDeclaration(node)) {
-                return transformClassDeclaration(node);
-            }
-            return ts.visitEachChild(node, decoratorDownlevelVisitor, context);
-        }
-        return (sf) => {
-            // Downlevel decorators and constructor parameter types. We will keep track of all
-            // referenced constructor parameter types so that we can instruct TypeScript to
-            // not elide their imports if they previously were only type-only.
-            return ts.visitEachChild(sf, decoratorDownlevelVisitor, context);
-        };
-    };
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"downlevel_decorators_transform.js","sourceRoot":"","sources":["../../../../../../../packages/compiler-cli/src/transformers/downlevel_decorators_transform.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAC,wBAAwB,EAAE,qCAAqC,EAAC,MAAM,oCAAoC,CAAC;AAEnH;;;GAGG;AACH,SAAS,kBAAkB,CAAC,SAAoB,EAAE,MAAe;IAC/D,OAAO,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,IAAI,IAAI,SAAS,CAAC,MAAM,CAAC,IAAI,KAAK,eAAe,CAAC,CAAC;AAC5F,CAAC;AAED;;;;;;;;;;;;;;;;;;;;EAoBE;AAEF;;;GAGG;AACH,SAAS,6BAA6B;IACpC,MAAM,YAAY,GAAqB,EAAE,CAAC;IAC1C,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,uBAAuB,CACxC,SAAS,EAAE,MAAM,EAAE,SAAS,EAC5B,EAAE,CAAC,uBAAuB,CAAC,EAAE,CAAC,gBAAgB,CAAC,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;IACxF,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,uBAAuB,CACxC,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAC9D,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,qBAAqB,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;IAC5F,OAAO,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAC,CAAC;AACxE,CAAC;AAED;;;;;;GAMG;AACH,SAAS,kCAAkC,CACvC,SAAuB,EAAE,WAA4B;IACvD,MAAM,kBAAkB,GAAkC,EAAE,CAAC;IAC7D,MAAM,IAAI,GAAG,SAAS,CAAC,UAAU,CAAC;IAClC,QAAQ,IAAI,CAAC,IAAI,EAAE;QACjB,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU;YAC3B,kCAAkC;YAClC,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,wBAAwB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;YACnE,MAAM;QACR,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc;YAC/B,4CAA4C;YAC5C,MAAM,IAAI,GAAG,IAAyB,CAAC;YACvC,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,wBAAwB,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;YAC9E,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;gBACzB,MAAM,IAAI,GAAoB,EAAE,CAAC;gBACjC,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,SAAS,EAAE;oBAChC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;iBAChB;gBACD,MAAM,gBAAgB,GAAG,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;gBACrD,gBAAgB,CAAC,QAAQ,CAAC,gBAAgB,GAAG,IAAI,CAAC;gBAClD,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,wBAAwB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;aAChF;YACD,MAAM;QACR;YACE,WAAW,CAAC,IAAI,CAAC;gBACf,IAAI,EAAE,SAAS,CAAC,aAAa,EAAE;gBAC/B,KAAK,EAAE,SAAS,CAAC,QAAQ,EAAE;gBAC3B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,SAAS,CAAC,QAAQ,EAAE;gBACjD,WAAW,EACP,GAAG,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,mDAAmD;gBACvF,QAAQ,EAAE,EAAE,CAAC,kBAAkB,CAAC,KAAK;gBACrC,IAAI,EAAE,CAAC;aACR,CAAC,CAAC;YACH,MAAM;KACT;IACD,OAAO,EAAE,CAAC,mBAAmB,CAAC,kBAAkB,CAAC,CAAC;AACpD,CAAC;AAED;;;GAGG;AACH,SAAS,4BAA4B,CAAC,aAA2C;IAC/E,MAAM,QAAQ,GAAG,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;IAC7D,MAAM,IAAI,GAAG,6BAA6B,EAAE,CAAC;IAC7C,MAAM,WAAW,GAAG,EAAE,CAAC,kBAAkB,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;IAC/D,6EAA6E;IAC7E,6EAA6E;IAC7E,6EAA6E;IAC7E,6EAA6E;IAC7E,8EAA8E;IAC9E,iDAAiD;IACjD,OAAO,EAAE,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;AAC9F,CAAC;AAED;;;GAGG;AACH,SAAS,qCAAqC;IAC5C,gEAAgE;IAChE,MAAM,YAAY,GAAqB,EAAE,CAAC;IAC1C,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,uBAAuB,CACxC,SAAS,EAAE,MAAM,EAAE,SAAS,EAC5B,EAAE,CAAC,uBAAuB,CAAC,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;IACnF,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,uBAAuB,CACxC,SAAS,EAAE,YAAY,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EACpE,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,qBAAqB,CAAC;QAC9C,EAAE,CAAC,uBAAuB,CACtB,SAAS,EAAE,MAAM,EAAE,SAAS,EAC5B,EAAE,CAAC,uBAAuB,CAAC,EAAE,CAAC,gBAAgB,CAAC,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC;QACtF,EAAE,CAAC,uBAAuB,CACtB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAC9D,EAAE,CAAC,mBAAmB,CAClB,EAAE,CAAC,uBAAuB,CAAC,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC,EACtE,SAAS,CAAC;KACf,CAAC,CAAC,EACH,SAAS,CAAC,CAAC,CAAC;IAEhB,OAAO,EAAE,CAAC,sBAAsB,CAAC,SAAS,EAAE,EAAE,EAAE,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,CAAC;QAC5F,EAAE,CAAC,qBAAqB,CAAC,YAAY,CAAC;QACtC,EAAE,CAAC,qBAAqB,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC;KAC1C,CAAC,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;GAIG;AACH,SAAS,oBAAoB,CAAC,CAAU;IACtC,EAAE,CAAC,2BAA2B,CAAC,CAAC,EAAE,CAAC;YACF,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,sBAAsB;YAC1C,IAAI,EAAE,gBAAgB;YACtB,GAAG,EAAE,CAAC,CAAC;YACP,GAAG,EAAE,CAAC,CAAC;YACP,kBAAkB,EAAE,IAAI;SACzB,CAAC,CAAC,CAAC;AACrC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,iCAAiC,CACtC,WAA4B,EAC5B,sBAAuE,EACvE,cAAyC,EACzC,wBAAiC;IACnC,MAAM,MAAM,GAAoB,EAAE,CAAC;IAEnC,KAAK,MAAM,SAAS,IAAI,cAAc,EAAE;QACtC,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,SAAS,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;YACxD,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,CAAC;YAC7B,SAAS;SACV;QAED,MAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;YAC9B,yBAAyB,CAAC,sBAAsB,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;YACnE,SAAS,CAAC;QACd,MAAM,OAAO,GACT,CAAC,EAAE,CAAC,wBAAwB,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QAEzF,MAAM,UAAU,GAAiC,EAAE,CAAC;QACpD,KAAK,MAAM,IAAI,IAAI,SAAS,CAAC,UAAU,EAAE;YACvC,UAAU,CAAC,IAAI,CAAC,kCAAkC,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC;SACxE;QACD,IAAI,UAAU,CAAC,MAAM,EAAE;YACrB,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,wBAAwB,CAAC,YAAY,EAAE,EAAE,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;SAC5F;QACD,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC;KAC9C;IAED,MAAM,WAAW,GAAG,EAAE,CAAC,mBAAmB,CACtC,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,sBAAsB,CAAC,EACzF,EAAE,CAAC,kBAAkB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;IACzC,MAAM,IAAI,GAAG,qCAAqC,EAAE,CAAC;IACrD,MAAM,QAAQ,GAAG,EAAE,CAAC,cAAc,CAC9B,SAAS,EAAE,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,EAAE,gBAAgB,EAAE,SAAS,EAAE,IAAI,EAC3F,WAAW,CAAC,CAAC;IACjB,IAAI,wBAAwB,EAAE;QAC5B,oBAAoB,CAAC,QAAQ,CAAC,CAAC;KAChC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,iCAAiC,CACtC,WAA4B,EAAE,UAAuC;IACvE,8FAA8F;IAC9F,MAAM,OAAO,GAAkC,EAAE,CAAC;IAClD,KAAK,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,UAAU,CAAC,OAAO,EAAE,EAAE;QACrD,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,wBAAwB,CACpC,IAAI,EACJ,EAAE,CAAC,kBAAkB,CACjB,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,kCAAkC,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAC1F;IACD,MAAM,WAAW,GAAG,EAAE,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC1D,MAAM,IAAI,GAAG,EAAE,CAAC,qBAAqB,CAAC,CAAC,EAAE,CAAC,oBAAoB,CAC1D,SAAS,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,eAAe,CACf,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EACjD,EAAE,CAAC,uBAAuB,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,EACtF,6BAA6B,EAAE,CAAC,CAAC,CAAC,CAAC;IACvC,OAAO,EAAE,CAAC,cAAc,CACpB,SAAS,EAAE,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,EAAE,gBAAgB,EAAE,SAAS,EAAE,IAAI,EAC3F,WAAW,CAAC,CAAC;AACnB,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,yBAAyB,CAC9B,sBAAuE,EACvE,IAAiB;IACnB,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACrB,IAAI,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE;QAC9B,sEAAsE;QACtE,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;KAC1B;IACD,QAAQ,IAAI,EAAE;QACZ,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;QAChC,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe;YAChC,OAAO,EAAE,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;QACzC,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC;QAC7B,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS;YAC1B,OAAO,EAAE,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QACtC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;QACjC,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;QAC/B,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;QAChC,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc;YAC/B,OAAO,EAAE,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;QACxC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;QACjC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa;YAC9B,OAAO,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QACvC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa;YAC9B,OAAO,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QACvC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;QACjC,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc;YAC/B,OAAO,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QACvC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa;YAC9B,MAAM,OAAO,GAAG,IAA4B,CAAC;YAC7C,uDAAuD;YACvD,OAAO,sBAAsB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAClD,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS;YAC1B,MAAM,cAAc,GACf,IAAyB;iBACrB,KAAK,CAAC,MAAM,CACT,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC;YAC7F,OAAO,cAAc,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC;gBAChC,yBAAyB,CAAC,sBAAsB,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACtE,SAAS,CAAC;QAChB;YACE,OAAO,SAAS,CAAC;KACpB;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,oBAAoB,CAAC,WAA2B,EAAE,MAAiB;IAC1E,IAAI,MAAM,CAAC,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE;QACvC,MAAM,GAAG,WAAW,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;KAC/C;IAED,oDAAoD;IACpD,wDAAwD;IACxD,OAAO,CAAC,MAAM,CAAC,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;AACxF,CAAC;AAaD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,+BAA+B,CAC3C,WAA2B,EAAE,IAAoB,EAAE,WAA4B,EAC/E,MAAe,EAAE,wBAAiC,EAClD,mBAA4B;IAC9B,OAAO,CAAC,OAAiC,EAAE,EAAE;QAC3C,gFAAgF;QAChF,mFAAmF;QACnF,gFAAgF;QAChF,6EAA6E;QAC7E,6EAA6E;QAC7E,MAAM,wBAAwB,GAAG,qCAAqC,CAAC,OAAO,CAAC,CAAC;QAEhF;;;;;WAKG;QACH,SAAS,sBAAsB,CAAC,IAAmB;YACjD,MAAM,MAAM,GAAG,WAAW,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;YACrD,yFAAyF;YACzF,8DAA8D;YAC9D,IAAI,CAAC,MAAM,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY;gBAC7E,MAAM,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;gBACpC,OAAO,SAAS,CAAC;aAClB;YACD,0EAA0E;YAC1E,+CAA+C;YAC/C,IAAI,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE;gBAC5B,MAAM,aAAa,GAAG,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACxD,IAAI,aAAa,KAAK,SAAS,EAAE;oBAC/B,OAAO,SAAS,CAAC;iBAClB;gBACD,OAAO,EAAE,CAAC,oBAAoB,CAAC,aAAa,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;aAC3D;YACD,MAAM,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACpC,6EAA6E;YAC7E,6EAA6E;YAC7E,8CAA8C;YAC9C,IAAI,wBAAwB,CAAC,IAAI,CAAC,EAAE;gBAClC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACnC,+EAA+E;gBAC/E,+EAA+E;gBAC/E,+EAA+E;gBAC/E,oFAAoF;gBACpF,kFAAkF;gBAClF,6EAA6E;gBAC7E,kFAAkF;gBAClF,+EAA+E;gBAC/E,uFAAuF;gBACvF,gFAAgF;gBAChF,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE;oBAC3B,OAAO,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;iBACtC;aACF;YACD,gFAAgF;YAChF,gFAAgF;YAChF,iFAAiF;YACjF,OAAO,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAClC,CAAC;QAED;;;;WAIG;QACH,SAAS,qBAAqB,CAAC,OAAwB;YAErD,OAAO,GAAG,EAAE,CAAC,cAAc,CAAC,OAAO,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;YACzE,MAAM,gBAAgB,GAAmB,EAAE,CAAC;YAC5C,MAAM,OAAO,GAAmB,EAAE,CAAC;YACnC,MAAM,UAAU,GAAG,IAAI,CAAC,0BAA0B,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YAClE,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;gBAClC,sEAAsE;gBACtE,mDAAmD;gBACnD,MAAM,aAAa,GAAG,SAAS,CAAC,IAAqB,CAAC;gBACtD,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE;oBAC1C,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;oBACrC,SAAS;iBACV;gBACD,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;aAC7B;YACD,IAAI,CAAC,OAAO,CAAC,MAAM;gBAAE,OAAO,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;YAErD,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACnD,gCAAgC;gBAChC,yBAAyB;gBACzB,WAAW,CAAC,IAAI,CAAC;oBACf,IAAI,EAAE,OAAO,CAAC,aAAa,EAAE;oBAC7B,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE;oBACzB,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE;oBAC7C,WAAW,EAAE,uEAAuE;oBACpF,QAAQ,EAAE,EAAE,CAAC,kBAAkB,CAAC,KAAK;oBACrC,IAAI,EAAE,CAAC;iBACR,CAAC,CAAC;gBACH,OAAO,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;aACjC;YAED,MAAM,IAAI,GAAI,OAAO,CAAC,IAAsB,CAAC,IAAI,CAAC;YAClD,MAAM,OAAO,GAAG,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;YAC3C,OAAe,CAAC,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;gBACnD,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,eAAe,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;gBAC3E,SAAS,CAAC;YACd,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QAClC,CAAC;QAED;;;WAGG;QACH,SAAS,oBAAoB,CAAC,IAA+B;YAE3D,IAAI,GAAG,EAAE,CAAC,cAAc,CAAC,IAAI,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;YAEnE,MAAM,aAAa,GAA8B,EAAE,CAAC;YACpD,MAAM,aAAa,GACf,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;YAC/E,MAAM,cAAc,GAA8B,EAAE,CAAC;YACrD,KAAK,MAAM,KAAK,IAAI,aAAa,EAAE;gBACjC,MAAM,gBAAgB,GAAmB,EAAE,CAAC;gBAC5C,MAAM,SAAS,GAA4B,EAAC,UAAU,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAC,CAAC;gBACxE,MAAM,UAAU,GAAG,IAAI,CAAC,0BAA0B,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;gBAEhE,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;oBAClC,sEAAsE;oBACtE,mDAAmD;oBACnD,MAAM,aAAa,GAAG,SAAS,CAAC,IAAqB,CAAC;oBACtD,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE;wBAC1C,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;wBACrC,SAAS;qBACV;oBACD,SAAU,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;iBAC3C;gBACD,IAAI,KAAK,CAAC,IAAI,EAAE;oBACd,8CAA8C;oBAC9C,wFAAwF;oBACxF,gFAAgF;oBAChF,eAAe;oBACf,SAAU,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;iBAC9B;gBACD,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBAC/B,MAAM,QAAQ,GAAG,EAAE,CAAC,eAAe,CAC/B,KAAK;gBACL,8DAA8D;gBAC9D,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,EACvE,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;gBAC1F,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;aAC9B;YACD,MAAM,OAAO,GAAG,EAAE,CAAC,iBAAiB,CAChC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,SAAS,EAAE,aAAa,EACpD,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC,CAAC;YACzE,OAAO,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;QACnC,CAAC;QAED;;;;;;WAMG;QACH,SAAS,yBAAyB,CAAC,SAA8B;YAC/D,SAAS,GAAG,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;YAE1C,MAAM,UAAU,GAAsB,EAAE,CAAC;YACzC,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAA0B,CAAC;YAC9D,IAAI,eAAe,GAAmC,IAAI,CAAC;YAE3D,KAAK,MAAM,MAAM,IAAI,SAAS,CAAC,OAAO,EAAE;gBACtC,QAAQ,MAAM,CAAC,IAAI,EAAE;oBACnB,KAAK,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC;oBACvC,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;oBAC/B,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;oBAC/B,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;wBACpC,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,CAAC,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC;wBACpE,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;wBAC3B,IAAI,IAAI;4BAAE,mBAAmB,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;wBACpD,SAAS;qBACV;oBACD,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;wBAC9B,MAAM,IAAI,GAAG,MAAmC,CAAC;wBACjD,IAAI,CAAC,IAAI,CAAC,IAAI;4BAAE,MAAM;wBACtB,MAAM,CAAC,SAAS,EAAE,cAAc,CAAC,GAC7B,oBAAoB,CAAC,MAAmC,CAAC,CAAC;wBAC9D,eAAe,GAAG,cAAc,CAAC;wBACjC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;wBAC3B,SAAS;qBACV;oBACD;wBACE,MAAM;iBACT;gBACD,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,cAAc,CAAC,MAAM,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC,CAAC;aAChF;YAED,4FAA4F;YAC5F,2FAA2F;YAC3F,4FAA4F;YAC5F,qFAAqF;YACrF,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAe,SAAS,CAAC,UAAU,CAAC,CAAC;YACrE,MAAM,yBAAyB,GAAG,IAAI,CAAC,0BAA0B,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;YAEnF,IAAI,mBAAmB,GAAG,KAAK,CAAC;YAChC,MAAM,iBAAiB,GAAG,EAAE,CAAC;YAC7B,KAAK,MAAM,SAAS,IAAI,yBAAyB,EAAE;gBACjD,sEAAsE;gBACtE,mDAAmD;gBACnD,MAAM,aAAa,GAAG,SAAS,CAAC,IAAqB,CAAC;gBACtD,MAAM,aAAa,GAAG,kBAAkB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;gBAE5D,wEAAwE;gBACxE,6EAA6E;gBAC7E,IAAI,aAAa,EAAE;oBACjB,mBAAmB,GAAG,IAAI,CAAC;iBAC5B;gBAED,IAAI,aAAa,IAAI,CAAC,mBAAmB,EAAE;oBACzC,iBAAiB,CAAC,IAAI,CAAC,kCAAkC,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC;oBACvF,gBAAgB,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;iBACxC;aACF;YAED,IAAI,iBAAiB,CAAC,MAAM,EAAE;gBAC5B,UAAU,CAAC,IAAI,CAAC,4BAA4B,CAAC,iBAAiB,CAAC,CAAC,CAAC;aAClE;YACD,IAAI,eAAe,EAAE;gBACnB,IAAI,mBAAmB,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;oBAC3E,6EAA6E;oBAC7E,+DAA+D;oBAC/D,UAAU,CAAC,IAAI,CAAC,iCAAiC,CAC7C,WAAW,EAAE,sBAAsB,EAAE,eAAe,EAAE,wBAAwB,CAAC,CAAC,CAAC;iBACtF;aACF;YACD,IAAI,mBAAmB,CAAC,IAAI,EAAE;gBAC5B,UAAU,CAAC,IAAI,CAAC,iCAAiC,CAAC,WAAW,EAAE,mBAAmB,CAAC,CAAC,CAAC;aACtF;YAED,MAAM,OAAO,GAAG,EAAE,CAAC,YAAY,CAC3B,EAAE,CAAC,eAAe,CAAC,UAAU,EAAE,SAAS,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;YAE3F,OAAO,EAAE,CAAC,sBAAsB,CAC5B,SAAS,EAAE,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,SAAS,EAC3E,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,cAAc,EAAE,SAAS,CAAC,eAAe,EACxF,OAAO,CAAC,CAAC;QACf,CAAC;QAED;;;;WAIG;QACH,SAAS,yBAAyB,CAAC,IAAa;YAC9C,IAAI,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE;gBAC/B,OAAO,yBAAyB,CAAC,IAAI,CAAC,CAAC;aACxC;YACD,OAAO,EAAE,CAAC,cAAc,CAAC,IAAI,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;QACrE,CAAC;QAED,OAAO,CAAC,EAAiB,EAAE,EAAE;YAC3B,kFAAkF;YAClF,+EAA+E;YAC/E,kEAAkE;YAClE,OAAO,EAAE,CAAC,cAAc,CAAC,EAAE,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;QACnE,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC","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';\nimport {Decorator, ReflectionHost} from '../ngtsc/reflection';\nimport {isAliasImportDeclaration, loadIsReferencedAliasDeclarationPatch} from './patch_alias_reference_resolution';\n\n/**\n * Whether a given decorator should be treated as an Angular decorator.\n * Either it's used in @angular/core, or it's imported from there.\n */\nfunction isAngularDecorator(decorator: Decorator, isCore: boolean): boolean {\n  return isCore || (decorator.import !== null && decorator.import.from === '@angular/core');\n}\n\n/*\n #####################################################################\n  Code below has been extracted from the tsickle decorator downlevel transformer\n  and a few local modifications have been applied:\n\n    1. Tsickle by default processed all decorators that had the `@Annotation` JSDoc.\n       We modified the transform to only be concerned with known Angular decorators.\n    2. Tsickle by default added `@nocollapse` to all generated `ctorParameters` properties.\n       We only do this when `annotateForClosureCompiler` is enabled.\n    3. Tsickle does not handle union types for dependency injection. i.e. if a injected type\n       is denoted with `@Optional`, the actual type could be set to `T | null`.\n       See: https://github.com/angular/angular-cli/commit/826803d0736b807867caff9f8903e508970ad5e4.\n    4. Tsickle relied on `emitDecoratorMetadata` to be set to `true`. This is due to a limitation\n       in TypeScript transformers that never has been fixed. We were able to work around this\n       limitation so that `emitDecoratorMetadata` doesn't need to be specified.\n       See: `patchAliasReferenceResolution` for more details.\n\n  Here is a link to the tsickle revision on which this transformer is based:\n  https://github.com/angular/tsickle/blob/fae06becb1570f491806060d83f29f2d50c43cdd/src/decorator_downlevel_transformer.ts\n #####################################################################\n*/\n\n/**\n * Creates the AST for the decorator field type annotation, which has the form\n *     { type: Function, args?: any[] }[]\n */\nfunction createDecoratorInvocationType(): ts.TypeNode {\n  const typeElements: ts.TypeElement[] = [];\n  typeElements.push(ts.createPropertySignature(\n      undefined, 'type', undefined,\n      ts.createTypeReferenceNode(ts.createIdentifier('Function'), undefined), undefined));\n  typeElements.push(ts.createPropertySignature(\n      undefined, 'args', ts.createToken(ts.SyntaxKind.QuestionToken),\n      ts.createArrayTypeNode(ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)), undefined));\n  return ts.createArrayTypeNode(ts.createTypeLiteralNode(typeElements));\n}\n\n/**\n * Extracts the type of the decorator (the function or expression invoked), as well as all the\n * arguments passed to the decorator. Returns an AST with the form:\n *\n *     // For @decorator(arg1, arg2)\n *     { type: decorator, args: [arg1, arg2] }\n */\nfunction extractMetadataFromSingleDecorator(\n    decorator: ts.Decorator, diagnostics: ts.Diagnostic[]): ts.ObjectLiteralExpression {\n  const metadataProperties: ts.ObjectLiteralElementLike[] = [];\n  const expr = decorator.expression;\n  switch (expr.kind) {\n    case ts.SyntaxKind.Identifier:\n      // The decorator was a plain @Foo.\n      metadataProperties.push(ts.createPropertyAssignment('type', expr));\n      break;\n    case ts.SyntaxKind.CallExpression:\n      // The decorator was a call, like @Foo(bar).\n      const call = expr as ts.CallExpression;\n      metadataProperties.push(ts.createPropertyAssignment('type', call.expression));\n      if (call.arguments.length) {\n        const args: ts.Expression[] = [];\n        for (const arg of call.arguments) {\n          args.push(arg);\n        }\n        const argsArrayLiteral = ts.createArrayLiteral(args);\n        argsArrayLiteral.elements.hasTrailingComma = true;\n        metadataProperties.push(ts.createPropertyAssignment('args', argsArrayLiteral));\n      }\n      break;\n    default:\n      diagnostics.push({\n        file: decorator.getSourceFile(),\n        start: decorator.getStart(),\n        length: decorator.getEnd() - decorator.getStart(),\n        messageText:\n            `${ts.SyntaxKind[decorator.kind]} not implemented in gathering decorator metadata.`,\n        category: ts.DiagnosticCategory.Error,\n        code: 0,\n      });\n      break;\n  }\n  return ts.createObjectLiteral(metadataProperties);\n}\n\n/**\n * Takes a list of decorator metadata object ASTs and produces an AST for a\n * static class property of an array of those metadata objects.\n */\nfunction createDecoratorClassProperty(decoratorList: ts.ObjectLiteralExpression[]) {\n  const modifier = ts.createToken(ts.SyntaxKind.StaticKeyword);\n  const type = createDecoratorInvocationType();\n  const initializer = ts.createArrayLiteral(decoratorList, true);\n  // NB: the .decorators property does not get a @nocollapse property. There is\n  // no good reason why - it means .decorators is not runtime accessible if you\n  // compile with collapse properties, whereas propDecorators is, which doesn't\n  // follow any stringent logic. However this has been the case previously, and\n  // adding it back in leads to substantial code size increases as Closure fails\n  // to tree shake these props without @nocollapse.\n  return ts.createProperty(undefined, [modifier], 'decorators', undefined, type, initializer);\n}\n\n/**\n * Creates the AST for the 'ctorParameters' field type annotation:\n *   () => ({ type: any, decorators?: {type: Function, args?: any[]}[] }|null)[]\n */\nfunction createCtorParametersClassPropertyType(): ts.TypeNode {\n  // Sorry about this. Try reading just the string literals below.\n  const typeElements: ts.TypeElement[] = [];\n  typeElements.push(ts.createPropertySignature(\n      undefined, 'type', undefined,\n      ts.createTypeReferenceNode(ts.createIdentifier('any'), undefined), undefined));\n  typeElements.push(ts.createPropertySignature(\n      undefined, 'decorators', ts.createToken(ts.SyntaxKind.QuestionToken),\n      ts.createArrayTypeNode(ts.createTypeLiteralNode([\n        ts.createPropertySignature(\n            undefined, 'type', undefined,\n            ts.createTypeReferenceNode(ts.createIdentifier('Function'), undefined), undefined),\n        ts.createPropertySignature(\n            undefined, 'args', ts.createToken(ts.SyntaxKind.QuestionToken),\n            ts.createArrayTypeNode(\n                ts.createTypeReferenceNode(ts.createIdentifier('any'), undefined)),\n            undefined),\n      ])),\n      undefined));\n\n  return ts.createFunctionTypeNode(undefined, [], ts.createArrayTypeNode(ts.createUnionTypeNode([\n    ts.createTypeLiteralNode(typeElements),\n    ts.createLiteralTypeNode(ts.createNull()),\n  ])));\n}\n\n/**\n * Sets a Closure \\@nocollapse synthetic comment on the given node. This prevents Closure Compiler\n * from collapsing the apparently static property, which would make it impossible to find for code\n * trying to detect it at runtime.\n */\nfunction addNoCollapseComment(n: ts.Node) {\n  ts.setSyntheticLeadingComments(n, [{\n                                   kind: ts.SyntaxKind.MultiLineCommentTrivia,\n                                   text: '* @nocollapse ',\n                                   pos: -1,\n                                   end: -1,\n                                   hasTrailingNewLine: true\n                                 }]);\n}\n\n/**\n * createCtorParametersClassProperty creates a static 'ctorParameters' property containing\n * downleveled decorator information.\n *\n * The property contains an arrow function that returns an array of object literals of the shape:\n *     static ctorParameters = () => [{\n *       type: SomeClass|undefined,  // the type of the param that's decorated, if it's a value.\n *       decorators: [{\n *         type: DecoratorFn,  // the type of the decorator that's invoked.\n *         args: [ARGS],       // the arguments passed to the decorator.\n *       }]\n *     }];\n */\nfunction createCtorParametersClassProperty(\n    diagnostics: ts.Diagnostic[],\n    entityNameToExpression: (n: ts.EntityName) => ts.Expression | undefined,\n    ctorParameters: ParameterDecorationInfo[],\n    isClosureCompilerEnabled: boolean): ts.PropertyDeclaration {\n  const params: ts.Expression[] = [];\n\n  for (const ctorParam of ctorParameters) {\n    if (!ctorParam.type && ctorParam.decorators.length === 0) {\n      params.push(ts.createNull());\n      continue;\n    }\n\n    const paramType = ctorParam.type ?\n        typeReferenceToExpression(entityNameToExpression, ctorParam.type) :\n        undefined;\n    const members =\n        [ts.createPropertyAssignment('type', paramType || ts.createIdentifier('undefined'))];\n\n    const decorators: ts.ObjectLiteralExpression[] = [];\n    for (const deco of ctorParam.decorators) {\n      decorators.push(extractMetadataFromSingleDecorator(deco, diagnostics));\n    }\n    if (decorators.length) {\n      members.push(ts.createPropertyAssignment('decorators', ts.createArrayLiteral(decorators)));\n    }\n    params.push(ts.createObjectLiteral(members));\n  }\n\n  const initializer = ts.createArrowFunction(\n      undefined, undefined, [], undefined, ts.createToken(ts.SyntaxKind.EqualsGreaterThanToken),\n      ts.createArrayLiteral(params, true));\n  const type = createCtorParametersClassPropertyType();\n  const ctorProp = ts.createProperty(\n      undefined, [ts.createToken(ts.SyntaxKind.StaticKeyword)], 'ctorParameters', undefined, type,\n      initializer);\n  if (isClosureCompilerEnabled) {\n    addNoCollapseComment(ctorProp);\n  }\n  return ctorProp;\n}\n\n/**\n * createPropDecoratorsClassProperty creates a static 'propDecorators' property containing type\n * information for every property that has a decorator applied.\n *\n *     static propDecorators: {[key: string]: {type: Function, args?: any[]}[]} = {\n *       propA: [{type: MyDecorator, args: [1, 2]}, ...],\n *       ...\n *     };\n */\nfunction createPropDecoratorsClassProperty(\n    diagnostics: ts.Diagnostic[], properties: Map<string, ts.Decorator[]>): ts.PropertyDeclaration {\n  //  `static propDecorators: {[key: string]: ` + {type: Function, args?: any[]}[] + `} = {\\n`);\n  const entries: ts.ObjectLiteralElementLike[] = [];\n  for (const [name, decorators] of properties.entries()) {\n    entries.push(ts.createPropertyAssignment(\n        name,\n        ts.createArrayLiteral(\n            decorators.map(deco => extractMetadataFromSingleDecorator(deco, diagnostics)))));\n  }\n  const initializer = ts.createObjectLiteral(entries, true);\n  const type = ts.createTypeLiteralNode([ts.createIndexSignature(\n      undefined, undefined, [ts.createParameter(\n                                undefined, undefined, undefined, 'key', undefined,\n                                ts.createTypeReferenceNode('string', undefined), undefined)],\n      createDecoratorInvocationType())]);\n  return ts.createProperty(\n      undefined, [ts.createToken(ts.SyntaxKind.StaticKeyword)], 'propDecorators', undefined, type,\n      initializer);\n}\n\n/**\n * Returns an expression representing the (potentially) value part for the given node.\n *\n * This is a partial re-implementation of TypeScript's serializeTypeReferenceNode. This is a\n * workaround for https://github.com/Microsoft/TypeScript/issues/17516 (serializeTypeReferenceNode\n * not being exposed). In practice this implementation is sufficient for Angular's use of type\n * metadata.\n */\nfunction typeReferenceToExpression(\n    entityNameToExpression: (n: ts.EntityName) => ts.Expression | undefined,\n    node: ts.TypeNode): ts.Expression|undefined {\n  let kind = node.kind;\n  if (ts.isLiteralTypeNode(node)) {\n    // Treat literal types like their base type (boolean, string, number).\n    kind = node.literal.kind;\n  }\n  switch (kind) {\n    case ts.SyntaxKind.FunctionType:\n    case ts.SyntaxKind.ConstructorType:\n      return ts.createIdentifier('Function');\n    case ts.SyntaxKind.ArrayType:\n    case ts.SyntaxKind.TupleType:\n      return ts.createIdentifier('Array');\n    case ts.SyntaxKind.TypePredicate:\n    case ts.SyntaxKind.TrueKeyword:\n    case ts.SyntaxKind.FalseKeyword:\n    case ts.SyntaxKind.BooleanKeyword:\n      return ts.createIdentifier('Boolean');\n    case ts.SyntaxKind.StringLiteral:\n    case ts.SyntaxKind.StringKeyword:\n      return ts.createIdentifier('String');\n    case ts.SyntaxKind.ObjectKeyword:\n      return ts.createIdentifier('Object');\n    case ts.SyntaxKind.NumberKeyword:\n    case ts.SyntaxKind.NumericLiteral:\n      return ts.createIdentifier('Number');\n    case ts.SyntaxKind.TypeReference:\n      const typeRef = node as ts.TypeReferenceNode;\n      // Ignore any generic types, just return the base type.\n      return entityNameToExpression(typeRef.typeName);\n    case ts.SyntaxKind.UnionType:\n      const childTypeNodes =\n          (node as ts.UnionTypeNode)\n              .types.filter(\n                  t => !(ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword));\n      return childTypeNodes.length === 1 ?\n          typeReferenceToExpression(entityNameToExpression, childTypeNodes[0]) :\n          undefined;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Checks whether a given symbol refers to a value that exists at runtime (as distinct from a type).\n *\n * Expands aliases, which is important for the case where\n *   import * as x from 'some-module';\n * and x is now a value (the module object).\n */\nfunction symbolIsRuntimeValue(typeChecker: ts.TypeChecker, symbol: ts.Symbol): boolean {\n  if (symbol.flags & ts.SymbolFlags.Alias) {\n    symbol = typeChecker.getAliasedSymbol(symbol);\n  }\n\n  // Note that const enums are a special case, because\n  // while they have a value, they don't exist at runtime.\n  return (symbol.flags & ts.SymbolFlags.Value & ts.SymbolFlags.ConstEnumExcludes) !== 0;\n}\n\n/** ParameterDecorationInfo describes the information for a single constructor parameter. */\ninterface ParameterDecorationInfo {\n  /**\n   * The type declaration for the parameter. Only set if the type is a value (e.g. a class, not an\n   * interface).\n   */\n  type: ts.TypeNode|null;\n  /** The list of decorators found on the parameter, null if none. */\n  decorators: ts.Decorator[];\n}\n\n/**\n * Gets a transformer for downleveling Angular decorators.\n * @param typeChecker Reference to the program's type checker.\n * @param host Reflection host that is used for determining decorators.\n * @param diagnostics List which will be populated with diagnostics if any.\n * @param isCore Whether the current TypeScript program is for the `@angular/core` package.\n * @param isClosureCompilerEnabled Whether closure annotations need to be added where needed.\n * @param skipClassDecorators Whether class decorators should be skipped from downleveling.\n *   This is useful for JIT mode where class decorators should be preserved as they could rely\n *   on immediate execution. e.g. downleveling `@Injectable` means that the injectable factory\n *   is not created, and injecting the token will not work. If this decorator would not be\n *   downleveled, the `Injectable` decorator will execute immediately on file load, and\n *   Angular will generate the corresponding injectable factory.\n */\nexport function getDownlevelDecoratorsTransform(\n    typeChecker: ts.TypeChecker, host: ReflectionHost, diagnostics: ts.Diagnostic[],\n    isCore: boolean, isClosureCompilerEnabled: boolean,\n    skipClassDecorators: boolean): ts.TransformerFactory<ts.SourceFile> {\n  return (context: ts.TransformationContext) => {\n    // Ensure that referenced type symbols are not elided by TypeScript. Imports for\n    // such parameter type symbols previously could be type-only, but now might be also\n    // used in the `ctorParameters` static property as a value. We want to make sure\n    // that TypeScript does not elide imports for such type references. Read more\n    // about this in the description for `loadIsReferencedAliasDeclarationPatch`.\n    const referencedParameterTypes = loadIsReferencedAliasDeclarationPatch(context);\n\n    /**\n     * Converts an EntityName (from a type annotation) to an expression (accessing a value).\n     *\n     * For a given qualified name, this walks depth first to find the leftmost identifier,\n     * and then converts the path into a property access that can be used as expression.\n     */\n    function entityNameToExpression(name: ts.EntityName): ts.Expression|undefined {\n      const symbol = typeChecker.getSymbolAtLocation(name);\n      // Check if the entity name references a symbol that is an actual value. If it is not, it\n      // cannot be referenced by an expression, so return undefined.\n      if (!symbol || !symbolIsRuntimeValue(typeChecker, symbol) || !symbol.declarations ||\n          symbol.declarations.length === 0) {\n        return undefined;\n      }\n      // If we deal with a qualified name, build up a property access expression\n      // that could be used in the JavaScript output.\n      if (ts.isQualifiedName(name)) {\n        const containerExpr = entityNameToExpression(name.left);\n        if (containerExpr === undefined) {\n          return undefined;\n        }\n        return ts.createPropertyAccess(containerExpr, name.right);\n      }\n      const decl = symbol.declarations[0];\n      // If the given entity name has been resolved to an alias import declaration,\n      // ensure that the alias declaration is not elided by TypeScript, and use its\n      // name identifier to reference it at runtime.\n      if (isAliasImportDeclaration(decl)) {\n        referencedParameterTypes.add(decl);\n        // If the entity name resolves to an alias import declaration, we reference the\n        // entity based on the alias import name. This ensures that TypeScript properly\n        // resolves the link to the import. Cloning the original entity name identifier\n        // could lead to an incorrect resolution at local scope. e.g. Consider the following\n        // snippet: `constructor(Dep: Dep) {}`. In such a case, the local `Dep` identifier\n        // would resolve to the actual parameter name, and not to the desired import.\n        // This happens because the entity name identifier symbol is internally considered\n        // as type-only and therefore TypeScript tries to resolve it as value manually.\n        // We can help TypeScript and avoid this non-reliable resolution by using an identifier\n        // that is not type-only and is directly linked to the import alias declaration.\n        if (decl.name !== undefined) {\n          return ts.getMutableClone(decl.name);\n        }\n      }\n      // Clone the original entity name identifier so that it can be used to reference\n      // its value at runtime. This is used when the identifier is resolving to a file\n      // local declaration (otherwise it would resolve to an alias import declaration).\n      return ts.getMutableClone(name);\n    }\n\n    /**\n     * Transforms a class element. Returns a three tuple of name, transformed element, and\n     * decorators found. Returns an undefined name if there are no decorators to lower on the\n     * element, or the element has an exotic name.\n     */\n    function transformClassElement(element: ts.ClassElement):\n        [string|undefined, ts.ClassElement, ts.Decorator[]] {\n      element = ts.visitEachChild(element, decoratorDownlevelVisitor, context);\n      const decoratorsToKeep: ts.Decorator[] = [];\n      const toLower: ts.Decorator[] = [];\n      const decorators = host.getDecoratorsOfDeclaration(element) || [];\n      for (const decorator of decorators) {\n        // We only deal with concrete nodes in TypeScript sources, so we don't\n        // need to handle synthetically created decorators.\n        const decoratorNode = decorator.node! as ts.Decorator;\n        if (!isAngularDecorator(decorator, isCore)) {\n          decoratorsToKeep.push(decoratorNode);\n          continue;\n        }\n        toLower.push(decoratorNode);\n      }\n      if (!toLower.length) return [undefined, element, []];\n\n      if (!element.name || !ts.isIdentifier(element.name)) {\n        // Method has a weird name, e.g.\n        //   [Symbol.foo]() {...}\n        diagnostics.push({\n          file: element.getSourceFile(),\n          start: element.getStart(),\n          length: element.getEnd() - element.getStart(),\n          messageText: `Cannot process decorators for class element with non-analyzable name.`,\n          category: ts.DiagnosticCategory.Error,\n          code: 0,\n        });\n        return [undefined, element, []];\n      }\n\n      const name = (element.name as ts.Identifier).text;\n      const mutable = ts.getMutableClone(element);\n      (mutable as any).decorators = decoratorsToKeep.length ?\n          ts.setTextRange(ts.createNodeArray(decoratorsToKeep), mutable.decorators) :\n          undefined;\n      return [name, mutable, toLower];\n    }\n\n    /**\n     * Transforms a constructor. Returns the transformed constructor and the list of parameter\n     * information collected, consisting of decorators and optional type.\n     */\n    function transformConstructor(ctor: ts.ConstructorDeclaration):\n        [ts.ConstructorDeclaration, ParameterDecorationInfo[]] {\n      ctor = ts.visitEachChild(ctor, decoratorDownlevelVisitor, context);\n\n      const newParameters: ts.ParameterDeclaration[] = [];\n      const oldParameters =\n          ts.visitParameterList(ctor.parameters, decoratorDownlevelVisitor, context);\n      const parametersInfo: ParameterDecorationInfo[] = [];\n      for (const param of oldParameters) {\n        const decoratorsToKeep: ts.Decorator[] = [];\n        const paramInfo: ParameterDecorationInfo = {decorators: [], type: null};\n        const decorators = host.getDecoratorsOfDeclaration(param) || [];\n\n        for (const decorator of decorators) {\n          // We only deal with concrete nodes in TypeScript sources, so we don't\n          // need to handle synthetically created decorators.\n          const decoratorNode = decorator.node! as ts.Decorator;\n          if (!isAngularDecorator(decorator, isCore)) {\n            decoratorsToKeep.push(decoratorNode);\n            continue;\n          }\n          paramInfo!.decorators.push(decoratorNode);\n        }\n        if (param.type) {\n          // param has a type provided, e.g. \"foo: Bar\".\n          // The type will be emitted as a value expression in entityNameToExpression, which takes\n          // care not to emit anything for types that cannot be expressed as a value (e.g.\n          // interfaces).\n          paramInfo!.type = param.type;\n        }\n        parametersInfo.push(paramInfo);\n        const newParam = ts.updateParameter(\n            param,\n            // Must pass 'undefined' to avoid emitting decorator metadata.\n            decoratorsToKeep.length ? decoratorsToKeep : undefined, param.modifiers,\n            param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer);\n        newParameters.push(newParam);\n      }\n      const updated = ts.updateConstructor(\n          ctor, ctor.decorators, ctor.modifiers, newParameters,\n          ts.visitFunctionBody(ctor.body, decoratorDownlevelVisitor, context));\n      return [updated, parametersInfo];\n    }\n\n    /**\n     * Transforms a single class declaration:\n     * - dispatches to strip decorators on members\n     * - converts decorators on the class to annotations\n     * - creates a ctorParameters property\n     * - creates a propDecorators property\n     */\n    function transformClassDeclaration(classDecl: ts.ClassDeclaration): ts.ClassDeclaration {\n      classDecl = ts.getMutableClone(classDecl);\n\n      const newMembers: ts.ClassElement[] = [];\n      const decoratedProperties = new Map<string, ts.Decorator[]>();\n      let classParameters: ParameterDecorationInfo[]|null = null;\n\n      for (const member of classDecl.members) {\n        switch (member.kind) {\n          case ts.SyntaxKind.PropertyDeclaration:\n          case ts.SyntaxKind.GetAccessor:\n          case ts.SyntaxKind.SetAccessor:\n          case ts.SyntaxKind.MethodDeclaration: {\n            const [name, newMember, decorators] = transformClassElement(member);\n            newMembers.push(newMember);\n            if (name) decoratedProperties.set(name, decorators);\n            continue;\n          }\n          case ts.SyntaxKind.Constructor: {\n            const ctor = member as ts.ConstructorDeclaration;\n            if (!ctor.body) break;\n            const [newMember, parametersInfo] =\n                transformConstructor(member as ts.ConstructorDeclaration);\n            classParameters = parametersInfo;\n            newMembers.push(newMember);\n            continue;\n          }\n          default:\n            break;\n        }\n        newMembers.push(ts.visitEachChild(member, decoratorDownlevelVisitor, context));\n      }\n\n      // The `ReflectionHost.getDecoratorsOfDeclaration()` method will not return certain kinds of\n      // decorators that will never be Angular decorators. So we cannot rely on it to capture all\n      // the decorators that should be kept. Instead we start off with a set of the raw decorators\n      // on the class, and only remove the ones that have been identified for downleveling.\n      const decoratorsToKeep = new Set<ts.Decorator>(classDecl.decorators);\n      const possibleAngularDecorators = host.getDecoratorsOfDeclaration(classDecl) || [];\n\n      let hasAngularDecorator = false;\n      const decoratorsToLower = [];\n      for (const decorator of possibleAngularDecorators) {\n        // We only deal with concrete nodes in TypeScript sources, so we don't\n        // need to handle synthetically created decorators.\n        const decoratorNode = decorator.node! as ts.Decorator;\n        const isNgDecorator = isAngularDecorator(decorator, isCore);\n\n        // Keep track if we come across an Angular class decorator. This is used\n        // for to determine whether constructor parameters should be captured or not.\n        if (isNgDecorator) {\n          hasAngularDecorator = true;\n        }\n\n        if (isNgDecorator && !skipClassDecorators) {\n          decoratorsToLower.push(extractMetadataFromSingleDecorator(decoratorNode, diagnostics));\n          decoratorsToKeep.delete(decoratorNode);\n        }\n      }\n\n      if (decoratorsToLower.length) {\n        newMembers.push(createDecoratorClassProperty(decoratorsToLower));\n      }\n      if (classParameters) {\n        if (hasAngularDecorator || classParameters.some(p => !!p.decorators.length)) {\n          // Capture constructor parameters if the class has Angular decorator applied,\n          // or if any of the parameters has decorators applied directly.\n          newMembers.push(createCtorParametersClassProperty(\n              diagnostics, entityNameToExpression, classParameters, isClosureCompilerEnabled));\n        }\n      }\n      if (decoratedProperties.size) {\n        newMembers.push(createPropDecoratorsClassProperty(diagnostics, decoratedProperties));\n      }\n\n      const members = ts.setTextRange(\n          ts.createNodeArray(newMembers, classDecl.members.hasTrailingComma), classDecl.members);\n\n      return ts.updateClassDeclaration(\n          classDecl, decoratorsToKeep.size ? Array.from(decoratorsToKeep) : undefined,\n          classDecl.modifiers, classDecl.name, classDecl.typeParameters, classDecl.heritageClauses,\n          members);\n    }\n\n    /**\n     * Transformer visitor that looks for Angular decorators and replaces them with\n     * downleveled static properties. Also collects constructor type metadata for\n     * class declaration that are decorated with an Angular decorator.\n     */\n    function decoratorDownlevelVisitor(node: ts.Node): ts.Node {\n      if (ts.isClassDeclaration(node)) {\n        return transformClassDeclaration(node);\n      }\n      return ts.visitEachChild(node, decoratorDownlevelVisitor, context);\n    }\n\n    return (sf: ts.SourceFile) => {\n      // Downlevel decorators and constructor parameter types. We will keep track of all\n      // referenced constructor parameter types so that we can instruct TypeScript to\n      // not elide their imports if they previously were only type-only.\n      return ts.visitEachChild(sf, decoratorDownlevelVisitor, context);\n    };\n  };\n}\n"]}

package/src/transformers/entry_points.mjs

@@ -1,10 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export { createCompilerHost } from './compiler_host';
-export { createProgram } from './program';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50cnlfcG9pbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXItY2xpL3NyYy90cmFuc2Zvcm1lcnMvZW50cnlfcG9pbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQU1ILE9BQU8sRUFBQyxrQkFBa0IsRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQ25ELE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0ICogYXMgdHMgZnJvbSAndHlwZXNjcmlwdCc7XG5cbmltcG9ydCB7Q29tcGlsZXJIb3N0LCBDb21waWxlck9wdGlvbnMsIFByb2dyYW19IGZyb20gJy4vYXBpJztcblxuZXhwb3J0IHtjcmVhdGVDb21waWxlckhvc3R9IGZyb20gJy4vY29tcGlsZXJfaG9zdCc7XG5leHBvcnQge2NyZWF0ZVByb2dyYW19IGZyb20gJy4vcHJvZ3JhbSc7XG4iXX0=