static-injector 1.0.6 → 1.0.10

package/import/{di → es2015/di}/provider_token.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -6,4 +5,4 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/import/{di → es2015/di}/r3_injector.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -6,20 +5,17 @@
  * 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.isClassProvider = exports.isTypeProvider = exports.providerToFactory = exports.R3Injector = exports.createInjectorWithoutInjectorInstances = exports.createInjector = void 0;
-const definition_factory_1 = require("../render3/definition_factory");
-const array_utils_1 = require("../util/array_utils");
-const empty_1 = require("../util/empty");
-const stringify_1 = require("../util/stringify");
-const forward_ref_1 = require("./forward_ref");
-const injection_token_1 = require("./injection_token");
-const injector_compatibility_1 = require("./injector_compatibility");
-const injector_token_1 = require("./injector_token");
-const defs_1 = require("./interface/defs");
-const injector_1 = require("./interface/injector");
-const null_injector_1 = require("./null_injector");
-const scope_1 = require("./scope");
+import { getFactoryDef } from '../render3/definition_factory';
+import { deepForEach, newArray } from '../util/array_utils';
+import { stringify } from '../util/stringify';
+import { resolveForwardRef } from './forward_ref';
+import { InjectionToken } from './injection_token';
+import { catchInjectorError, injectArgs, NG_TEMP_TOKEN_PATH, setCurrentInjector, THROW_IF_NOT_FOUND, USE_VALUE, ɵɵinject, } from './injector_compatibility';
+import { INJECTOR } from './injector_token';
+import { getInjectableDef, } from './interface/defs';
+import { InjectFlags } from './interface/injector';
+import { NullInjector } from './null_injector';
+import { INJECTOR_SCOPE } from './scope';
 /**
  * Marker which indicates that a value has not yet been created from the factory function.
  */
@@ -38,7 +34,7 @@ const CIRCULAR = {};
 let NULL_INJECTOR = undefined;
 function getNullInjector() {
     if (NULL_INJECTOR === undefined) {
-        NULL_INJECTOR = new null_injector_1.NullInjector();
+        NULL_INJECTOR = new NullInjector();
     }
     return NULL_INJECTOR;
 }
@@ -47,22 +43,20 @@ function getNullInjector() {
  *
  * @publicApi
  */
-function createInjector(defType, parent = null, additionalProviders = null, name) {
+export function createInjector(defType, parent = null, additionalProviders = null, name) {
     const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
     injector._resolveInjectorDefTypes();
     return injector;
 }
-exports.createInjector = createInjector;
 /**
  * Creates a new injector without eagerly resolving its injector types. Can be used in places
  * where resolving the injector types immediately can lead to an infinite loop. The injector types
  * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
  */
-function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name) {
+export function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name) {
     return new R3Injector(defType, additionalProviders, parent || getNullInjector(), name);
 }
-exports.createInjectorWithoutInjectorInstances = createInjectorWithoutInjectorInstances;
-class R3Injector {
+export class R3Injector {
     constructor(def, additionalProviders, parent, source = null) {
         this.parent = parent;
         /**
@@ -80,21 +74,19 @@ class R3Injector {
          */
         this.onDestroy = new Set();
         this._destroyed = false;
-        const dedupStack = [];
         // Start off by creating Records for every provider declared in every InjectorType
         // included transitively in additional providers then do the same for `def`. This order is
         // important because `def` may include providers that override ones in additionalProviders.
         additionalProviders &&
-            array_utils_1.deepForEach(additionalProviders, (provider) => this.processProvider(provider, def, additionalProviders));
-        array_utils_1.deepForEach([def], (injectorDef) => this.processInjectorType(injectorDef, [], dedupStack));
+            deepForEach(additionalProviders, (provider) => this.processProvider(provider, def, additionalProviders));
         // Make sure the INJECTOR token provides this injector.
-        this.records.set(injector_token_1.INJECTOR, makeRecord(undefined, this));
+        this.records.set(INJECTOR, makeRecord(undefined, this));
         // Detect whether this injector has the APP_ROOT_SCOPE token and thus should provide
         // any injectable scoped to APP_ROOT_SCOPE.
-        const record = this.records.get(scope_1.INJECTOR_SCOPE);
+        const record = this.records.get(INJECTOR_SCOPE);
         this.scope = record != null ? record.value : null;
         // Source name, used for debugging
-        this.source = source || (typeof def === 'object' ? null : stringify_1.stringify(def));
+        this.source = source || (typeof def === 'object' ? null : stringify(def));
     }
     /**
      * Flag indicating that this injector was previously destroyed.
@@ -123,19 +115,19 @@ class R3Injector {
             this.injectorDefTypes.clear();
         }
     }
-    get(token, notFoundValue = injector_compatibility_1.THROW_IF_NOT_FOUND, flags = injector_1.InjectFlags.Default) {
+    get(token, notFoundValue = THROW_IF_NOT_FOUND, flags = InjectFlags.Default) {
         this.assertNotDestroyed();
         // Set the injection context.
-        const previousInjector = injector_compatibility_1.setCurrentInjector(this);
+        const previousInjector = setCurrentInjector(this);
         try {
             // Check for the SkipSelf flag.
-            if (!(flags & injector_1.InjectFlags.SkipSelf)) {
+            if (!(flags & InjectFlags.SkipSelf)) {
                 // SkipSelf isn't set, check if the record belongs to this injector.
                 let record = this.records.get(token);
                 if (record === undefined) {
                     // No record, but maybe the token is scoped to this injector. Look for an injectable
                     // def with a scope matching this injector.
-                    const def = couldBeInjectableType(token) && defs_1.getInjectableDef(token);
+                    const def = couldBeInjectableType(token) && getInjectableDef(token);
                     if (def && this.injectableDefInScope(def)) {
                         // Found an injectable def and it's scoped to this injector. Pretend as if it was here
                         // all along.
@@ -153,29 +145,29 @@ class R3Injector {
             }
             // Select the next injector based on the Self flag - if self is set, the next injector is
             // the NullInjector, otherwise it's the parent.
-            const nextInjector = !(flags & injector_1.InjectFlags.Self)
+            const nextInjector = !(flags & InjectFlags.Self)
                 ? this.parent
                 : getNullInjector();
             // Set the notFoundValue based on the Optional flag - if optional is set and notFoundValue
             // is undefined, the value is null, otherwise it's the notFoundValue.
             notFoundValue =
-                flags & injector_1.InjectFlags.Optional && notFoundValue === injector_compatibility_1.THROW_IF_NOT_FOUND
+                flags & InjectFlags.Optional && notFoundValue === THROW_IF_NOT_FOUND
                     ? null
                     : notFoundValue;
             return nextInjector.get(token, notFoundValue);
         }
         catch (e) {
             if (e.name === 'NullInjectorError') {
-                const path = (e[injector_compatibility_1.NG_TEMP_TOKEN_PATH] =
-                    e[injector_compatibility_1.NG_TEMP_TOKEN_PATH] || []);
-                path.unshift(stringify_1.stringify(token));
+                const path = (e[NG_TEMP_TOKEN_PATH] =
+                    e[NG_TEMP_TOKEN_PATH] || []);
+                path.unshift(stringify(token));
                 if (previousInjector) {
                     // We still have a parent injector, keep throwing
                     throw e;
                 }
                 else {
                     // Format & throw the final error message when we don't have any previous injector
-                    return injector_compatibility_1.catchInjectorError(e, token, 'R3InjectorError', this.source);
+                    return catchInjectorError(e, token, 'R3InjectorError', this.source);
                 }
             }
             else {
@@ -184,7 +176,7 @@ class R3Injector {
         }
         finally {
             // Lastly, restore the previous injection context.
-            injector_compatibility_1.setCurrentInjector(previousInjector);
+            setCurrentInjector(previousInjector);
         }
     }
     /** @internal */
@@ -193,7 +185,7 @@ class R3Injector {
     }
     toString() {
         const tokens = [], records = this.records;
-        records.forEach((v, token) => tokens.push(stringify_1.stringify(token)));
+        records.forEach((v, token) => tokens.push(stringify(token)));
         return `R3Injector[${tokens.join(', ')}]`;
     }
     assertNotDestroyed() {
@@ -210,101 +202,16 @@ class R3Injector {
      * to be processed. This allows us to process providers of injector types after all imports of
      * an injector definition are processed. (following View Engine semantics: see FW-1349)
      */
-    processInjectorType(defOrWrappedDef, parents, dedupStack) {
-        defOrWrappedDef = forward_ref_1.resolveForwardRef(defOrWrappedDef);
-        if (!defOrWrappedDef)
-            return false;
-        // Either the defOrWrappedDef is an InjectorType (with injector def) or an
-        // InjectorDefTypeWithProviders (aka ModuleWithProviders). Detecting either is a megamorphic
-        // read, so care is taken to only do the read once.
-        // First attempt to read the injector def (`ɵinj`).
-        let def = defs_1.getInjectorDef(defOrWrappedDef);
-        // If that's not present, then attempt to read ngModule from the InjectorDefTypeWithProviders.
-        const ngModule = (def == null &&
-            defOrWrappedDef.ngModule) ||
-            undefined;
-        // Determine the InjectorType. In the case where `defOrWrappedDef` is an `InjectorType`,
-        // then this is easy. In the case of an InjectorDefTypeWithProviders, then the definition type
-        // is the `ngModule`.
-        const defType = ngModule === undefined
-            ? defOrWrappedDef
-            : ngModule;
-        // Check for circular dependencies.
-        // if (ngDevMode && parents.indexOf(defType) !== -1) {
-        //   const defName = stringify(defType);
-        //   const path = parents.map(stringify);
-        //   throwCyclicDependencyError(defName, path);
-        // }
-        // Check for multiple imports of the same module
-        const isDuplicate = dedupStack.indexOf(defType) !== -1;
-        // Finally, if defOrWrappedType was an `InjectorDefTypeWithProviders`, then the actual
-        // `InjectorDef` is on its `ngModule`.
-        if (ngModule !== undefined) {
-            def = defs_1.getInjectorDef(ngModule);
-        }
-        // If no definition was found, it might be from exports. Remove it.
-        if (def == null) {
-            return false;
-        }
-        // Add providers in the same way that @NgModule resolution did:
-        // First, include providers from any imports.
-        if (def.imports != null && !isDuplicate) {
-            // Before processing defType's imports, add it to the set of parents. This way, if it ends
-            // up deeply importing itself, this can be detected.
-            // ngDevMode && parents.push(defType);
-            // Add it to the set of dedups. This way we can detect multiple imports of the same module
-            dedupStack.push(defType);
-            let importTypesWithProviders;
-            try {
-                array_utils_1.deepForEach(def.imports, (imported) => {
-                    if (this.processInjectorType(imported, parents, dedupStack)) {
-                        if (importTypesWithProviders === undefined)
-                            importTypesWithProviders = [];
-                        // If the processed import is an injector type with providers, we store it in the
-                        // list of import types with providers, so that we can process those afterwards.
-                        importTypesWithProviders.push(imported);
-                    }
-                });
-            }
-            finally {
-                // Remove it from the parents set when finished.
-                // ngDevMode && parents.pop();
-            }
-            // Imports which are declared with providers (TypeWithProviders) need to be processed
-            // after all imported modules are processed. This is similar to how View Engine
-            // processes/merges module imports in the metadata resolver. See: FW-1349.
-            if (importTypesWithProviders !== undefined) {
-                for (let i = 0; i < importTypesWithProviders.length; i++) {
-                    const { ngModule, providers } = importTypesWithProviders[i];
-                    array_utils_1.deepForEach(providers, (provider) => this.processProvider(provider, ngModule, providers || empty_1.EMPTY_ARRAY));
-                }
-            }
-        }
-        // Track the InjectorType and add a provider for it. It's important that this is done after the
-        // def's imports.
-        this.injectorDefTypes.add(defType);
-        const factory = definition_factory_1.getFactoryDef(defType) || (() => new defType());
-        this.records.set(defType, makeRecord(factory, NOT_YET));
-        // Next, include providers listed on the definition itself.
-        const defProviders = def.providers;
-        if (defProviders != null && !isDuplicate) {
-            const injectorType = defOrWrappedDef;
-            array_utils_1.deepForEach(defProviders, (provider) => this.processProvider(provider, injectorType, defProviders));
-        }
-        return (ngModule !== undefined &&
-            defOrWrappedDef.providers !==
-                undefined);
-    }
     /**
      * Process a `SingleProvider` and add it.
      */
     processProvider(provider, ngModuleType, providers) {
         // Determine the token from the provider. Either it's its own token, or has a {provide: ...}
         // property.
-        provider = forward_ref_1.resolveForwardRef(provider);
+        provider = resolveForwardRef(provider);
         let token = isTypeProvider(provider)
             ? provider
-            : forward_ref_1.resolveForwardRef(provider && provider.provide);
+            : resolveForwardRef(provider && provider.provide);
         // Construct a `Record` for the provider.
         const record = providerToRecord(provider, ngModuleType, providers);
         if (!isTypeProvider(provider) && provider.multi === true) {
@@ -319,7 +226,7 @@ class R3Injector {
             }
             else {
                 multiRecord = makeRecord(undefined, NOT_YET, true);
-                multiRecord.factory = () => injector_compatibility_1.injectArgs(multiRecord.multi);
+                multiRecord.factory = () => injectArgs(multiRecord.multi);
                 this.records.set(token, multiRecord);
             }
             token = provider;
@@ -352,7 +259,7 @@ class R3Injector {
         if (!def.providedIn) {
             return false;
         }
-        const providedIn = forward_ref_1.resolveForwardRef(def.providedIn);
+        const providedIn = resolveForwardRef(def.providedIn);
         if (typeof providedIn === 'string') {
             return providedIn === 'any' || providedIn === this.scope;
         }
@@ -361,18 +268,17 @@ class R3Injector {
         }
     }
 }
-exports.R3Injector = R3Injector;
 function injectableDefOrInjectorDefFactory(token) {
     // Most tokens will have an injectable def directly on them, which specifies a factory directly.
-    const injectableDef = defs_1.getInjectableDef(token);
-    const factory = injectableDef !== null ? injectableDef.factory : definition_factory_1.getFactoryDef(token);
+    const injectableDef = getInjectableDef(token);
+    const factory = injectableDef !== null ? injectableDef.factory : getFactoryDef(token);
     if (factory !== null) {
         return factory;
     }
     // InjectionTokens should have an injectable def (ɵprov) and thus should be handled above.
     // If it's missing that, it's an error.
-    if (token instanceof injection_token_1.InjectionToken) {
-        throw new Error(`Token ${stringify_1.stringify(token)} is missing a ɵprov definition.`);
+    if (token instanceof InjectionToken) {
+        throw new Error(`Token ${stringify(token)} is missing a ɵprov definition.`);
     }
     // Undecorated types can sometimes be created if they have no constructor arguments.
     if (token instanceof Function) {
@@ -385,8 +291,8 @@ function getUndecoratedInjectableFactory(token) {
     // If the token has parameters then it has dependencies that we cannot resolve implicitly.
     const paramLength = token.length;
     if (paramLength > 0) {
-        const args = array_utils_1.newArray(paramLength, '?');
-        throw new Error(`Can't resolve all parameters for ${stringify_1.stringify(token)}: (${args.join(', ')}).`);
+        const args = newArray(paramLength, '?');
+        throw new Error(`Can't resolve all parameters for ${stringify(token)}: (${args.join(', ')}).`);
     }
     // The constructor function appears to have no parameters.
     // This might be because it inherits from a super-class. In which case, use an injectable
@@ -409,41 +315,40 @@ function providerToRecord(provider, ngModuleType, providers) {
  *
  * @param provider provider to convert to factory
  */
-function providerToFactory(provider, ngModuleType, providers) {
+export function providerToFactory(provider, ngModuleType, providers) {
     let factory = undefined;
     if (isTypeProvider(provider)) {
-        const unwrappedProvider = forward_ref_1.resolveForwardRef(provider);
-        return (definition_factory_1.getFactoryDef(unwrappedProvider) ||
+        const unwrappedProvider = resolveForwardRef(provider);
+        return (getFactoryDef(unwrappedProvider) ||
             injectableDefOrInjectorDefFactory(unwrappedProvider));
     }
     else {
         if (isValueProvider(provider)) {
-            factory = () => forward_ref_1.resolveForwardRef(provider.useValue);
+            factory = () => resolveForwardRef(provider.useValue);
         }
         else if (isFactoryProvider(provider)) {
-            factory = () => provider.useFactory(...injector_compatibility_1.injectArgs(provider.deps || []));
+            factory = () => provider.useFactory(...injectArgs(provider.deps || []));
         }
         else if (isExistingProvider(provider)) {
-            factory = () => injector_compatibility_1.ɵɵinject(forward_ref_1.resolveForwardRef(provider.useExisting));
+            factory = () => ɵɵinject(resolveForwardRef(provider.useExisting));
         }
         else {
-            const classRef = forward_ref_1.resolveForwardRef(provider &&
+            const classRef = resolveForwardRef(provider &&
                 (provider.useClass ||
                     provider.provide));
             // if (ngDevMode && !classRef) {
             //   throwInvalidProviderError(ngModuleType, providers, provider);
             // }
             if (hasDeps(provider)) {
-                factory = () => new classRef(...injector_compatibility_1.injectArgs(provider.deps));
+                factory = () => new classRef(...injectArgs(provider.deps));
             }
             else {
-                return (definition_factory_1.getFactoryDef(classRef) || injectableDefOrInjectorDefFactory(classRef));
+                return (getFactoryDef(classRef) || injectableDefOrInjectorDefFactory(classRef));
             }
         }
     }
     return factory;
 }
-exports.providerToFactory = providerToFactory;
 function makeRecord(factory, value, multi = false) {
     return {
         factory: factory,
@@ -452,7 +357,7 @@ function makeRecord(factory, value, multi = false) {
     };
 }
 function isValueProvider(value) {
-    return value !== null && typeof value == 'object' && injector_compatibility_1.USE_VALUE in value;
+    return value !== null && typeof value == 'object' && USE_VALUE in value;
 }
 function isExistingProvider(value) {
     return !!(value && value.useExisting);
@@ -460,14 +365,9 @@ function isExistingProvider(value) {
 function isFactoryProvider(value) {
     return !!(value && value.useFactory);
 }
-function isTypeProvider(value) {
+export function isTypeProvider(value) {
     return typeof value === 'function';
 }
-exports.isTypeProvider = isTypeProvider;
-function isClassProvider(value) {
-    return !!value.useClass;
-}
-exports.isClassProvider = isClassProvider;
 function hasDeps(value) {
     return !!value.deps;
 }
@@ -478,5 +378,5 @@ function hasOnDestroy(value) {
 }
 function couldBeInjectableType(value) {
     return (typeof value === 'function' ||
-        (typeof value === 'object' && value instanceof injection_token_1.InjectionToken));
+        (typeof value === 'object' && value instanceof InjectionToken));
 }

package/import/{di → es2015/di}/scope.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -6,12 +5,10 @@
  * 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.INJECTOR_SCOPE = void 0;
-const injection_token_1 = require("./injection_token");
+import { InjectionToken } from "./injection_token";
 /**
  * An internal token whose presence in an injector indicates that the injector should treat itself
  * as a root scoped injector when processing requests for unknown tokens which may indicate
  * they are provided in the root scope.
  */
-exports.INJECTOR_SCOPE = new injection_token_1.InjectionToken("Set Injector scope.");
+export const INJECTOR_SCOPE = new InjectionToken("Set Injector scope.");

package/import/es2015/index.js

@@ -0,0 +1,12 @@
+export * from './decorator/injectable';
+export * from './di/metadata';
+export * from './di/r3_injector';
+export * from './di/interface/defs';
+export * from './di/injector_compatibility';
+export * from './di/injection_token';
+export * from './di/null_injector';
+export * from './di/injector';
+export * from './di/interface/injector';
+export * from './di/scope';
+export * from './render3/instructions/di';
+export * from './render3/di';

package/import/{interface → es2015/interface}/lifecycle_hooks.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -6,4 +5,4 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/import/es2015/interface/type.js

@@ -0,0 +1,8 @@
+/**
+ * @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 {};

package/import/es2015/render3/definition_factory.js

@@ -0,0 +1,15 @@
+/**
+ * @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 { NG_FACTORY_DEF } from './fields';
+export function getFactoryDef(type, throwNotFound) {
+    const hasFactoryDef = type.hasOwnProperty(NG_FACTORY_DEF);
+    // if (!hasFactoryDef && throwNotFound === true && ngDevMode) {
+    //   throw new Error(`Type ${stringify(type)} does not have 'ɵfac' property.`);
+    // }
+    return hasFactoryDef ? type[NG_FACTORY_DEF] : null;
+}

package/import/es2015/render3/di.js

@@ -0,0 +1,49 @@
+/**
+ * @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 { isForwardRef, resolveForwardRef } from '../di/forward_ref';
+import { noSideEffects } from '../util/closure';
+import { getFactoryDef } from './definition_factory';
+import { NG_FACTORY_DEF } from './fields';
+/**
+ * @codeGenApi
+ */
+export function ɵɵgetInheritedFactory(type) {
+    return noSideEffects(() => {
+        const ownConstructor = type.prototype.constructor;
+        const ownFactory = ownConstructor[NG_FACTORY_DEF] || getFactoryOf(ownConstructor);
+        const objectPrototype = Object.prototype;
+        let parent = Object.getPrototypeOf(type.prototype).constructor;
+        // Go up the prototype until we hit `Object`.
+        while (parent && parent !== objectPrototype) {
+            const factory = parent[NG_FACTORY_DEF] || getFactoryOf(parent);
+            // If we hit something that has a factory and the factory isn't the same as the type,
+            // we've found the inherited factory. Note the check that the factory isn't the type's
+            // own factory is redundant in most cases, but if the user has custom decorators on the
+            // class, this lookup will start one level down in the prototype chain, causing us to
+            // find the own factory first and potentially triggering an infinite loop downstream.
+            if (factory && factory !== ownFactory) {
+                return factory;
+            }
+            parent = Object.getPrototypeOf(parent);
+        }
+        // There is no factory defined. Either this was improper usage of inheritance
+        // (no Angular decorator on the superclass) or there is no constructor at all
+        // in the inheritance chain. Since the two cases cannot be distinguished, the
+        // latter has to be assumed.
+        return (t) => new t();
+    });
+}
+function getFactoryOf(type) {
+    if (isForwardRef(type)) {
+        return () => {
+            const factory = getFactoryOf(resolveForwardRef(type));
+            return factory && factory();
+        };
+    }
+    return getFactoryDef(type);
+}

package/import/{render3 → es2015/render3}/error_code.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -6,18 +5,15 @@
  * 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.formatRuntimeError = exports.RuntimeError = void 0;
-class RuntimeError extends Error {
+export class RuntimeError extends Error {
     constructor(code, message) {
         super(formatRuntimeError(code, message));
         this.code = code;
     }
 }
-exports.RuntimeError = RuntimeError;
 /* tslint:enable:no-toplevel-property-access */
 /** Called to format a runtime error */
-function formatRuntimeError(code, message) {
+export function formatRuntimeError(code, message) {
     const fullCode = code ? `NG0${code}: ` : '';
     let errorMessage = `${fullCode}${message}`;
     // Some runtime errors are still thrown without `ngDevMode` (for example
@@ -31,4 +27,3 @@ function formatRuntimeError(code, message) {
     // }
     return errorMessage;
 }
-exports.formatRuntimeError = formatRuntimeError;

package/import/es2015/render3/errors_di.js

@@ -0,0 +1,14 @@
+/**
+ * @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 { RuntimeError } from './error_code';
+import { stringifyForError } from './util/stringify_utils';
+/** Throws an error when a token is not found in DI. */
+export function throwProviderNotFoundError(token, injectorName) {
+    const injectorDetails = injectorName ? ` in ${injectorName}` : '';
+    throw new RuntimeError("201" /* PROVIDER_NOT_FOUND */, `No provider for ${stringifyForError(token)} found${injectorDetails}`);
+}

package/import/es2015/render3/fields.js

@@ -0,0 +1,11 @@
+/**
+ * @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 { getClosureSafeProperty } from '../util/property';
+export const NG_FACTORY_DEF = getClosureSafeProperty({
+    ɵfac: getClosureSafeProperty,
+});

package/import/{render3 → es2015/render3}/instructions/di.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -6,8 +5,6 @@
  * 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.ɵɵinvalidFactory = void 0;
 /**
  * Throws an error indicating that a factory function could not be generated by the compiler for a
  * particular class.
@@ -20,8 +17,7 @@ exports.ɵɵinvalidFactory = void 0;
  *
  * @codeGenApi
  */
-function ɵɵinvalidFactory() {
+export function ɵɵinvalidFactory() {
     const msg = 'invalid';
     throw new Error(msg);
 }
-exports.ɵɵinvalidFactory = ɵɵinvalidFactory;