static-injector 4.0.2 → 5.0.0

package/transform/compiler/src/parse_util.d.ts

@@ -1,50 +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 declare class ParseLocation {
-    file: ParseSourceFile;
-    offset: number;
-    line: number;
-    col: number;
-    constructor(file: ParseSourceFile, offset: number, line: number, col: number);
-}
-export declare class ParseSourceFile {
-    content: string;
-    url: string;
-    constructor(content: string, url: string);
-}
-export declare class ParseSourceSpan {
-    start: ParseLocation;
-    end: ParseLocation;
-    fullStart: ParseLocation;
-    details: string | null;
-    /**
-     * Create an object that holds information about spans of tokens/nodes captured during
-     * lexing/parsing of text.
-     *
-     * @param start
-     * The location of the start of the span (having skipped leading trivia).
-     * Skipping leading trivia makes source-spans more "user friendly", since things like HTML
-     * elements will appear to begin at the start of the opening tag, rather than at the start of any
-     * leading trivia, which could include newlines.
-     *
-     * @param end
-     * The location of the end of the span.
-     *
-     * @param fullStart
-     * The start of the token without skipping the leading trivia.
-     * This is used by tooling that splits tokens further, such as extracting Angular interpolations
-     * from text tokens. Such tooling creates new source-spans relative to the original token's
-     * source-span. If leading trivia characters have been skipped then the new source-spans may be
-     * incorrectly offset.
-     *
-     * @param details
-     * Additional information (such as identifier names) that should be associated with the span.
-     */
-    constructor(start: ParseLocation, end: ParseLocation, fullStart?: ParseLocation, details?: string | null);
-    toString(): string;
-}

package/transform/compiler/src/parse_util.js

@@ -1,71 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParseSourceSpan = exports.ParseSourceFile = exports.ParseLocation = void 0;
-class ParseLocation {
-    file;
-    offset;
-    line;
-    col;
-    constructor(file, offset, line, col) {
-        this.file = file;
-        this.offset = offset;
-        this.line = line;
-        this.col = col;
-    }
-}
-exports.ParseLocation = ParseLocation;
-class ParseSourceFile {
-    content;
-    url;
-    constructor(content, url) {
-        this.content = content;
-        this.url = url;
-    }
-}
-exports.ParseSourceFile = ParseSourceFile;
-class ParseSourceSpan {
-    start;
-    end;
-    fullStart;
-    details;
-    /**
-     * Create an object that holds information about spans of tokens/nodes captured during
-     * lexing/parsing of text.
-     *
-     * @param start
-     * The location of the start of the span (having skipped leading trivia).
-     * Skipping leading trivia makes source-spans more "user friendly", since things like HTML
-     * elements will appear to begin at the start of the opening tag, rather than at the start of any
-     * leading trivia, which could include newlines.
-     *
-     * @param end
-     * The location of the end of the span.
-     *
-     * @param fullStart
-     * The start of the token without skipping the leading trivia.
-     * This is used by tooling that splits tokens further, such as extracting Angular interpolations
-     * from text tokens. Such tooling creates new source-spans relative to the original token's
-     * source-span. If leading trivia characters have been skipped then the new source-spans may be
-     * incorrectly offset.
-     *
-     * @param details
-     * Additional information (such as identifier names) that should be associated with the span.
-     */
-    constructor(start, end, fullStart = start, details = null) {
-        this.start = start;
-        this.end = end;
-        this.fullStart = fullStart;
-        this.details = details;
-    }
-    toString() {
-        return this.start.file.content.substring(this.start.offset, this.end.offset);
-    }
-}
-exports.ParseSourceSpan = ParseSourceSpan;

package/transform/compiler/src/render3/partial/api.d.ts

@@ -1,171 +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 o from '../../output/output_ast';
-export interface R3PartialDeclaration {
-    /**
-     * The minimum version of the compiler that can process this partial declaration.
-     */
-    minVersion: string;
-    /**
-     * Version number of the Angular compiler that was used to compile this declaration. The linker
-     * will be able to detect which version a library is using and interpret its metadata accordingly.
-     */
-    version: string;
-    /**
-     * A reference to the `@angular/core` ES module, which allows access
-     * to all Angular exports, including Ivy instructions.
-     */
-    ngImport: o.Expression;
-    /**
-     * Reference to the decorated class, which is subject to this partial declaration.
-     */
-    type: o.Expression;
-}
-export type LegacyInputPartialMapping = string | [
-    bindingPropertyName: string,
-    classPropertyName: string,
-    transformFunction?: o.Expression
-];
-/**
- * Describes the shape of the objects that the `ɵɵngDeclareInjector()` accepts.
- */
-export interface R3DeclareInjectorMetadata extends R3PartialDeclaration {
-    /**
-     * The list of providers provided by the injector.
-     */
-    providers?: o.Expression;
-    /**
-     * The list of imports into the injector.
-     */
-    imports?: o.Expression[];
-}
-/**
- * Describes the shape of the object that the `ɵɵngDeclareFactory()` function accepts.
- *
- * This interface serves primarily as documentation, as conformance to this interface is not
- * enforced during linking.
- */
-export interface R3DeclareFactoryMetadata extends R3PartialDeclaration {
-    /**
-     * A collection of dependencies that this factory relies upon.
-     *
-     * If this is `null`, then the type's constructor is nonexistent and will be inherited from an
-     * ancestor of the type.
-     *
-     * If this is `'invalid'`, then one or more of the parameters wasn't resolvable and any attempt to
-     * use these deps will result in a runtime error.
-     */
-    deps: R3DeclareDependencyMetadata[] | 'invalid' | null;
-    /**
-     * Type of the target being created by the factory.
-     */
-    target: FactoryTarget;
-}
-export declare enum FactoryTarget {
-    Directive = 0,
-    Component = 1,
-    Injectable = 2,
-    Pipe = 3,
-    NgModule = 4
-}
-/**
- * Describes the shape of the object that the `ɵɵngDeclareInjectable()` function accepts.
- *
- * This interface serves primarily as documentation, as conformance to this interface is not
- * enforced during linking.
- */
-export interface R3DeclareInjectableMetadata extends R3PartialDeclaration {
-    /**
-     * If provided, specifies that the declared injectable belongs to a particular injector:
-     * - `InjectorType` such as `NgModule`,
-     * - `'root'` the root injector
-     * - `'any'` all injectors.
-     * If not provided, then it does not belong to any injector. Must be explicitly listed in the
-     * providers of an injector.
-     */
-    providedIn?: o.Expression;
-    /**
-     * If provided, an expression that evaluates to a class to use when creating an instance of this
-     * injectable.
-     */
-    useClass?: o.Expression;
-    /**
-     * If provided, an expression that evaluates to a function to use when creating an instance of
-     * this injectable.
-     */
-    useFactory?: o.Expression;
-    /**
-     * If provided, an expression that evaluates to a token of another injectable that this injectable
-     * aliases.
-     */
-    useExisting?: o.Expression;
-    /**
-     * If provided, an expression that evaluates to the value of the instance of this injectable.
-     */
-    useValue?: o.Expression;
-    /**
-     * An array of dependencies to support instantiating this injectable via `useClass` or
-     * `useFactory`.
-     */
-    deps?: R3DeclareDependencyMetadata[];
-}
-/**
- * Metadata indicating how a dependency should be injected into a factory.
- */
-export interface R3DeclareDependencyMetadata {
-    /**
-     * An expression representing the token or value to be injected, or `null` if the dependency is
-     * not valid.
-     *
-     * If this dependency is due to the `@Attribute()` decorator, then this is an expression
-     * evaluating to the name of the attribute.
-     */
-    token: o.Expression | null;
-    /**
-     * Whether the dependency is injecting an attribute value.
-     * Default: false.
-     */
-    attribute?: boolean;
-    /**
-     * Whether the dependency has an @Optional qualifier.
-     * Default: false,
-     */
-    optional?: boolean;
-    /**
-     * Whether the dependency has an @Self qualifier.
-     * Default: false,
-     */
-    self?: boolean;
-    /**
-     * Whether the dependency has an @SkipSelf qualifier.
-     * Default: false,
-     */
-    skipSelf?: boolean;
-}
-/**
- * Describes the shape of the object that the `ɵɵngDeclareClassMetadata()` function accepts.
- *
- * This interface serves primarily as documentation, as conformance to this interface is not
- * enforced during linking.
- */
-export interface R3DeclareClassMetadata extends R3PartialDeclaration {
-    /**
-     * The Angular decorators of the class.
-     */
-    decorators: o.Expression;
-    /**
-     * Optionally specifies the constructor parameters, their types and the Angular decorators of each
-     * parameter. This property is omitted if the class does not have a constructor.
-     */
-    ctorParameters?: o.Expression;
-    /**
-     * Optionally specifies the Angular decorators applied to the class properties. This property is
-     * omitted if no properties have any decorators.
-     */
-    propDecorators?: o.Expression;
-}

package/transform/compiler/src/render3/partial/api.js

@@ -1,18 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FactoryTarget = void 0;
-var FactoryTarget;
-(function (FactoryTarget) {
-    FactoryTarget[FactoryTarget["Directive"] = 0] = "Directive";
-    FactoryTarget[FactoryTarget["Component"] = 1] = "Component";
-    FactoryTarget[FactoryTarget["Injectable"] = 2] = "Injectable";
-    FactoryTarget[FactoryTarget["Pipe"] = 3] = "Pipe";
-    FactoryTarget[FactoryTarget["NgModule"] = 4] = "NgModule";
-})(FactoryTarget || (exports.FactoryTarget = FactoryTarget = {}));

package/transform/compiler/src/render3/r3_factory.d.ts

@@ -1,82 +0,0 @@
-import * as o from '../output/output_ast';
-import { R3CompiledExpression, R3Reference } from './util';
-/**
- * Metadata required by the factory generator to generate a `factory` function for a type.
- */
-export interface R3ConstructorFactoryMetadata {
-    /**
-     * String name of the type being generated (used to name the factory function).
-     */
-    name: string;
-    /**
-     * An expression representing the interface type being constructed.
-     */
-    type: R3Reference;
-    /** Number of arguments for the `type`. */
-    typeArgumentCount: number;
-    /**
-     * Regardless of whether `fnOrClass` is a constructor function or a user-defined factory, it
-     * may have 0 or more parameters, which will be injected according to the `R3DependencyMetadata`
-     * for those parameters. If this is `null`, then the type's constructor is nonexistent and will
-     * be inherited from `fnOrClass` which is interpreted as the current type. If this is `'invalid'`,
-     * then one or more of the parameters wasn't resolvable and any attempt to use these deps will
-     * result in a runtime error.
-     */
-    deps: R3DependencyMetadata[] | 'invalid' | null;
-    /**
-     * Type of the target being created by the factory.
-     */
-    target: FactoryTarget;
-}
-export declare enum R3FactoryDelegateType {
-    Class = 0,
-    Function = 1
-}
-export interface R3DelegatedFnOrClassMetadata extends R3ConstructorFactoryMetadata {
-    delegate: o.Expression;
-    delegateType: R3FactoryDelegateType;
-    delegateDeps: R3DependencyMetadata[];
-}
-export interface R3ExpressionFactoryMetadata extends R3ConstructorFactoryMetadata {
-    expression: o.Expression;
-}
-export type R3FactoryMetadata = R3ConstructorFactoryMetadata | R3DelegatedFnOrClassMetadata | R3ExpressionFactoryMetadata;
-export declare enum FactoryTarget {
-    Directive = 0,
-    Component = 1,
-    Injectable = 2,
-    Pipe = 3,
-    NgModule = 4
-}
-export interface R3DependencyMetadata {
-    /**
-     * An expression representing the token or value to be injected.
-     * Or `null` if the dependency could not be resolved - making it invalid.
-     */
-    token: o.Expression | null;
-    /**
-     * If an @Attribute decorator is present, this is the literal type of the attribute name, or
-     * the unknown type if no literal type is available (e.g. the attribute name is an expression).
-     * Otherwise it is null;
-     */
-    attributeNameType: o.Expression | null;
-    /**
-     * Whether the dependency has an @Optional qualifier.
-     */
-    optional: boolean;
-    /**
-     * Whether the dependency has an @Self qualifier.
-     */
-    self: boolean;
-    /**
-     * Whether the dependency has an @SkipSelf qualifier.
-     */
-    skipSelf: boolean;
-}
-/**
- * Construct a factory function expression for the given `R3FactoryMetadata`.
- */
-export declare function compileFactoryFunction(meta: R3FactoryMetadata): R3CompiledExpression;
-export declare function createFactoryType(meta: R3FactoryMetadata): o.ExpressionType;
-export declare function isDelegatedFactoryMetadata(meta: R3FactoryMetadata): meta is R3DelegatedFnOrClassMetadata;
-export declare function isExpressionFactoryMetadata(meta: R3FactoryMetadata): meta is R3ExpressionFactoryMetadata;

package/transform/compiler/src/render3/r3_factory.js

@@ -1,225 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExpressionFactoryMetadata = exports.isDelegatedFactoryMetadata = exports.createFactoryType = exports.compileFactoryFunction = exports.FactoryTarget = exports.R3FactoryDelegateType = void 0;
-const o = __importStar(require("../output/output_ast"));
-const r3_identifiers_1 = require("../render3/r3_identifiers");
-const util_1 = require("./util");
-var R3FactoryDelegateType;
-(function (R3FactoryDelegateType) {
-    R3FactoryDelegateType[R3FactoryDelegateType["Class"] = 0] = "Class";
-    R3FactoryDelegateType[R3FactoryDelegateType["Function"] = 1] = "Function";
-})(R3FactoryDelegateType || (exports.R3FactoryDelegateType = R3FactoryDelegateType = {}));
-var FactoryTarget;
-(function (FactoryTarget) {
-    FactoryTarget[FactoryTarget["Directive"] = 0] = "Directive";
-    FactoryTarget[FactoryTarget["Component"] = 1] = "Component";
-    FactoryTarget[FactoryTarget["Injectable"] = 2] = "Injectable";
-    FactoryTarget[FactoryTarget["Pipe"] = 3] = "Pipe";
-    FactoryTarget[FactoryTarget["NgModule"] = 4] = "NgModule";
-})(FactoryTarget || (exports.FactoryTarget = FactoryTarget = {}));
-/**
- * Construct a factory function expression for the given `R3FactoryMetadata`.
- */
-function compileFactoryFunction(meta) {
-    const t = o.variable('t');
-    let baseFactoryVar = null;
-    // The type to instantiate via constructor invocation. If there is no delegated factory, meaning
-    // this type is always created by constructor invocation, then this is the type-to-create
-    // parameter provided by the user (t) if specified, or the current type if not. If there is a
-    // delegated factory (which is used to create the current type) then this is only the type-to-
-    // create parameter (t).
-    const typeForCtor = !isDelegatedFactoryMetadata(meta)
-        ? new o.BinaryOperatorExpr(o.BinaryOperator.Or, t, meta.type.value)
-        : t;
-    let ctorExpr = null;
-    if (meta.deps !== null) {
-        // There is a constructor (either explicitly or implicitly defined).
-        if (meta.deps !== 'invalid') {
-            ctorExpr = new o.InstantiateExpr(typeForCtor, injectDependencies(meta.deps, meta.target));
-        }
-    }
-    else {
-        // There is no constructor, use the base class' factory to construct typeForCtor.
-        baseFactoryVar = o.variable(`ɵ${meta.name}_BaseFactory`);
-        ctorExpr = baseFactoryVar.callFn([typeForCtor]);
-    }
-    const body = [];
-    let retExpr = null;
-    function makeConditionalFactory(nonCtorExpr) {
-        const r = o.variable('r');
-        body.push(r.set(o.NULL_EXPR).toDeclStmt());
-        const ctorStmt = ctorExpr !== null
-            ? r.set(ctorExpr).toStmt()
-            : o.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt();
-        body.push(o.ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()]));
-        return r;
-    }
-    if (isDelegatedFactoryMetadata(meta)) {
-        // This type is created with a delegated factory. If a type parameter is not specified, call
-        // the factory instead.
-        const delegateArgs = injectDependencies(meta.delegateDeps, meta.target);
-        // Either call `new delegate(...)` or `delegate(...)` depending on meta.delegateType.
-        const factoryExpr = new (meta.delegateType === R3FactoryDelegateType.Class
-            ? o.InstantiateExpr
-            : o.InvokeFunctionExpr)(meta.delegate, delegateArgs);
-        retExpr = makeConditionalFactory(factoryExpr);
-    }
-    else if (isExpressionFactoryMetadata(meta)) {
-        // TODO(alxhub): decide whether to lower the value here or in the caller
-        retExpr = makeConditionalFactory(meta.expression);
-    }
-    else {
-        retExpr = ctorExpr;
-    }
-    if (retExpr === null) {
-        // The expression cannot be formed so render an `ɵɵinvalidFactory()` call.
-        body.push(o.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt());
-    }
-    else if (baseFactoryVar !== null) {
-        // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it.
-        const getInheritedFactoryCall = o
-            .importExpr(r3_identifiers_1.Identifiers.getInheritedFactory)
-            .callFn([meta.type.value]);
-        // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`
-        const baseFactory = new o.BinaryOperatorExpr(o.BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
-        body.push(new o.ReturnStatement(baseFactory.callFn([typeForCtor])));
-    }
-    else {
-        // This is straightforward factory, just return it.
-        body.push(new o.ReturnStatement(retExpr));
-    }
-    let factoryFn = o.fn([new o.FnParam('t', o.DYNAMIC_TYPE)], body, o.INFERRED_TYPE, undefined, `${meta.name}_Factory`);
-    if (baseFactoryVar !== null) {
-        // There is a base factory variable so wrap its declaration along with the factory function into
-        // an IIFE.
-        factoryFn = o
-            .arrowFn([], [
-            new o.DeclareVarStmt(baseFactoryVar.name),
-            new o.ReturnStatement(factoryFn),
-        ])
-            .callFn([], /* sourceSpan */ undefined, /* pure */ true);
-    }
-    return {
-        expression: factoryFn,
-        statements: [],
-        type: createFactoryType(meta),
-    };
-}
-exports.compileFactoryFunction = compileFactoryFunction;
-function createFactoryType(meta) {
-    const ctorDepsType = meta.deps !== null && meta.deps !== 'invalid'
-        ? createCtorDepsType(meta.deps)
-        : o.NONE_TYPE;
-    return o.expressionType(o.importExpr(r3_identifiers_1.Identifiers.FactoryDeclaration, [
-        (0, util_1.typeWithParameters)(meta.type.type, meta.typeArgumentCount),
-        ctorDepsType,
-    ]));
-}
-exports.createFactoryType = createFactoryType;
-function injectDependencies(deps, target) {
-    return deps.map((dep, index) => compileInjectDependency(dep, target, index));
-}
-function compileInjectDependency(dep, target, index) {
-    // Interpret the dependency according to its resolved type.
-    if (dep.token === null) {
-        return o.importExpr(r3_identifiers_1.Identifiers.invalidFactoryDep).callFn([o.literal(index)]);
-    }
-    else if (dep.attributeNameType === null) {
-        // Build up the injection flags according to the metadata.
-        const flags = 0 /* InjectFlags.Default */ |
-            (dep.self ? 2 /* InjectFlags.Self */ : 0) |
-            (dep.skipSelf ? 4 /* InjectFlags.SkipSelf */ : 0) |
-            0 |
-            (dep.optional ? 8 /* InjectFlags.Optional */ : 0) |
-            0;
-        // If this dependency is optional or otherwise has non-default flags, then additional
-        // parameters describing how to inject the dependency must be passed to the inject function
-        // that's being used.
-        let flagsParam = flags !== 0 /* InjectFlags.Default */ || dep.optional ? o.literal(flags) : null;
-        // Build up the arguments to the injectFn call.
-        const injectArgs = [dep.token];
-        if (flagsParam) {
-            injectArgs.push(flagsParam);
-        }
-        const injectFn = getInjectFn(target);
-        return o.importExpr(injectFn).callFn(injectArgs);
-    }
-    else {
-        throw new Error('compileInjectDependency');
-    }
-}
-function createCtorDepsType(deps) {
-    let hasTypes = false;
-    const attributeTypes = deps.map((dep) => {
-        const type = createCtorDepType(dep);
-        if (type !== null) {
-            hasTypes = true;
-            return type;
-        }
-        else {
-            return o.literal(null);
-        }
-    });
-    if (hasTypes) {
-        return o.expressionType(o.literalArr(attributeTypes));
-    }
-    else {
-        return o.NONE_TYPE;
-    }
-}
-function createCtorDepType(dep) {
-    const entries = [];
-    if (dep.optional) {
-        entries.push({ key: 'optional', value: o.literal(true), quoted: false });
-    }
-    if (dep.self) {
-        entries.push({ key: 'self', value: o.literal(true), quoted: false });
-    }
-    if (dep.skipSelf) {
-        entries.push({ key: 'skipSelf', value: o.literal(true), quoted: false });
-    }
-    return entries.length > 0 ? o.literalMap(entries) : null;
-}
-function isDelegatedFactoryMetadata(meta) {
-    return meta.delegateType !== undefined;
-}
-exports.isDelegatedFactoryMetadata = isDelegatedFactoryMetadata;
-function isExpressionFactoryMetadata(meta) {
-    return meta.expression !== undefined;
-}
-exports.isExpressionFactoryMetadata = isExpressionFactoryMetadata;
-function getInjectFn(target) {
-    switch (target) {
-        case FactoryTarget.Component:
-        case FactoryTarget.Directive:
-        case FactoryTarget.Pipe:
-            return r3_identifiers_1.Identifiers.directiveInject;
-        case FactoryTarget.NgModule:
-        case FactoryTarget.Injectable:
-        default:
-            return r3_identifiers_1.Identifiers.inject;
-    }
-}

package/transform/compiler/src/render3/r3_identifiers.d.ts

@@ -1,20 +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 o from '../output/output_ast';
-export declare class Identifiers {
-    static inject: o.ExternalReference;
-    static directiveInject: o.ExternalReference;
-    static invalidFactory: o.ExternalReference;
-    static invalidFactoryDep: o.ExternalReference;
-    static forwardRef: o.ExternalReference;
-    static resolveForwardRef: o.ExternalReference;
-    static ɵɵdefineInjectable: o.ExternalReference;
-    static InjectableDeclaration: o.ExternalReference;
-    static FactoryDeclaration: o.ExternalReference;
-    static getInheritedFactory: o.ExternalReference;
-}