D-Net

import * as tslib_1 from "tslib";

/**

 * @license Angular v4.4.6

 * (c) 2010-2017 Google, Inc. https://angular.io/

 * License: MIT

 */

import { Observable } from 'rxjs/Observable';

import { merge } from 'rxjs/observable/merge';

import { share } from 'rxjs/operator/share';

import { Subject } from 'rxjs/Subject';

/**

 * Creates a token that can be used in a DI Provider.

 *

 * ### Example ([live demo](http://plnkr.co/edit/Ys9ezXpj2Mnoy3Uc8KBp?p=preview))

 *

 * ```typescript

 * var t = new OpaqueToken("value");

 *

 * var injector = Injector.resolveAndCreate([

 *   {provide: t, useValue: "bindingValue"}

 * ]);

 *

 * expect(injector.get(t)).toEqual("bindingValue");

 * ```

 *

 * Using an `OpaqueToken` is preferable to using strings as tokens because of possible collisions

 * caused by multiple providers using the same string as two different tokens.

 *

 * Using an `OpaqueToken` is preferable to using an `Object` as tokens because it provides better

 * error messages.

 * @deprecated since v4.0.0 because it does not support type information, use `InjectionToken<?>`

 * instead.

 */

var OpaqueToken = (function () {

    /**

     * @param {?} _desc

     */

    function OpaqueToken(_desc) {

        this._desc = _desc;

    }

    /**

     * @return {?}

     */

    OpaqueToken.prototype.toString = function () { return "Token " + this._desc; };

    return OpaqueToken;

}());

/**

 * Creates a token that can be used in a DI Provider.

 *

 * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a

 * runtime representation) such as when injecting an interface, callable type, array or

 * parametrized type.

 *

 * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by

 * the `Injector`. This provides additional level of type safety.

 *

 * ```

 * interface MyInterface {...}

 * var myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));

 * // myInterface is inferred to be MyInterface.

 * ```

 *

 * ### Example

 *

 * {\@example core/di/ts/injector_spec.ts region='InjectionToken'}

 *

 * \@stable

 */

var InjectionToken = (function (_super) {

    tslib_1.__extends(InjectionToken, _super);

    /**

     * @param {?} desc

     */

    function InjectionToken(desc) {

        return _super.call(this, desc) || this;

    }

    /**

     * @return {?}

     */

    InjectionToken.prototype.toString = function () { return "InjectionToken " + this._desc; };

    return InjectionToken;

}(OpaqueToken));

/**

 * @license

 * Copyright Google Inc. All Rights Reserved.

 *

 * Use of this source code is governed by an MIT-style license that can be

 * found in the LICENSE file at https://angular.io/license

 */

var __window = typeof window !== 'undefined' && window;

var __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&

    self instanceof WorkerGlobalScope && self;

var __global = typeof global !== 'undefined' && global;

var _global = __window || __global || __self;

var _symbolIterator = null;

/**

 * @return {?}

 */

function getSymbolIterator() {

    if (!_symbolIterator) {

        var /** @type {?} */ Symbol = _global['Symbol'];

        if (Symbol && Symbol.iterator) {

            _symbolIterator = Symbol.iterator;

        }

        else {

            // es6-shim specific logic

            var /** @type {?} */ keys = Object.getOwnPropertyNames(Map.prototype);

            for (var /** @type {?} */ i = 0; i < keys.length; ++i) {

                var /** @type {?} */ key = keys[i];

                if (key !== 'entries' && key !== 'size' &&

                    ((Map)).prototype[key] === Map.prototype['entries']) {

                    _symbolIterator = key;

                }

            }

        }

    }

    return _symbolIterator;

}

/**

 * @param {?} fn

 * @return {?}

 */

function scheduleMicroTask(fn) {

    Zone.current.scheduleMicroTask('scheduleMicrotask', fn);

}

/**

 * @param {?} a

 * @param {?} b

 * @return {?}

 */

function looseIdentical(a, b) {

    return a === b || typeof a === 'number' && typeof b === 'number' && isNaN(a) && isNaN(b);

}

/**

 * @param {?} token

 * @return {?}

 */

function stringify(token) {

    if (typeof token === 'string') {

        return token;

    }

    if (token == null) {

        return '' + token;

    }

    if (token.overriddenName) {

        return "" + token.overriddenName;

    }

    if (token.name) {

        return "" + token.name;

    }

    var /** @type {?} */ res = token.toString();

    if (res == null) {

        return '' + res;

    }

    var /** @type {?} */ newLineIndex = res.indexOf('\n');

    return newLineIndex === -1 ? res : res.substring(0, newLineIndex);

}

/**

 * @license

 * Copyright Google Inc. All Rights Reserved.

 *

 * Use of this source code is governed by an MIT-style license that can be

 * found in the LICENSE file at https://angular.io/license

 */

var _nextClassId = 0;

var Reflect = _global['Reflect'];

/**

 * @param {?} annotation

 * @return {?}

 */

function extractAnnotation(annotation) {

    if (typeof annotation === 'function' && annotation.hasOwnProperty('annotation')) {

        // it is a decorator, extract annotation

        annotation = annotation.annotation;

    }

    return annotation;

}

/**

 * @param {?} fnOrArray

 * @param {?} key

 * @return {?}

 */

function applyParams(fnOrArray, key) {

    if (fnOrArray === Object || fnOrArray === String || fnOrArray === Function ||

        fnOrArray === Number || fnOrArray === Array) {

        throw new Error("Can not use native " + stringify(fnOrArray) + " as constructor");

    }

    if (typeof fnOrArray === 'function') {

        return fnOrArray;

    }

    if (Array.isArray(fnOrArray)) {

        var /** @type {?} */ annotations = (fnOrArray);

        var /** @type {?} */ annoLength = annotations.length - 1;

        var /** @type {?} */ fn = fnOrArray[annoLength];

        if (typeof fn !== 'function') {

            throw new Error("Last position of Class method array must be Function in key " + key + " was '" + stringify(fn) + "'");

        }

        if (annoLength != fn.length) {

            throw new Error("Number of annotations (" + annoLength + ") does not match number of arguments (" + fn.length + ") in the function: " + stringify(fn));

        }

        var /** @type {?} */ paramsAnnotations = [];

        for (var /** @type {?} */ i = 0, /** @type {?} */ ii = annotations.length - 1; i < ii; i++) {

            var /** @type {?} */ paramAnnotations = [];

            paramsAnnotations.push(paramAnnotations);

            var /** @type {?} */ annotation = annotations[i];

            if (Array.isArray(annotation)) {

                for (var /** @type {?} */ j = 0; j < annotation.length; j++) {

                    paramAnnotations.push(extractAnnotation(annotation[j]));

                }

            }

            else if (typeof annotation === 'function') {

                paramAnnotations.push(extractAnnotation(annotation));

            }

            else {

                paramAnnotations.push(annotation);

            }

        }

        Reflect.defineMetadata('parameters', paramsAnnotations, fn);

        return fn;

    }

    throw new Error("Only Function or Array is supported in Class definition for key '" + key + "' is '" + stringify(fnOrArray) + "'");

}

/**

 * Provides a way for expressing ES6 classes with parameter annotations in ES5.

 *

 * ## Basic Example

 *

 * ```

 * var Greeter = ng.Class({

 *   constructor: function(name) {

 *     this.name = name;

 *   },

 *

 *   greet: function() {

 *     alert('Hello ' + this.name + '!');

 *   }

 * });

 * ```

 *

 * is equivalent to ES6:

 *

 * ```

 * class Greeter {

 *   constructor(name) {

 *     this.name = name;

 *   }

 *

 *   greet() {

 *     alert('Hello ' + this.name + '!');

 *   }

 * }

 * ```

 *

 * or equivalent to ES5:

 *

 * ```

 * var Greeter = function (name) {

 *   this.name = name;

 * }

 *

 * Greeter.prototype.greet = function () {

 *   alert('Hello ' + this.name + '!');

 * }

 * ```

 *

 * ### Example with parameter annotations

 *

 * ```

 * var MyService = ng.Class({

 *   constructor: [String, [new Optional(), Service], function(name, myService) {

 *     ...

 *   }]

 * });

 * ```

 *

 * is equivalent to ES6:

 *

 * ```

 * class MyService {

 *   constructor(name: string, \@Optional() myService: Service) {

 *     ...

 *   }

 * }

 * ```

 *

 * ### Example with inheritance

 *

 * ```

 * var Shape = ng.Class({

 *   constructor: (color) {

 *     this.color = color;

 *   }

 * });

 *

 * var Square = ng.Class({

 *   extends: Shape,

 *   constructor: function(color, size) {

 *     Shape.call(this, color);

 *     this.size = size;

 *   }

 * });

 * ```

 * @suppress {globalThis}

 * \@stable

 * @param {?} clsDef

 * @return {?}

 */

function Class(clsDef) {

    var /** @type {?} */ constructor = applyParams(clsDef.hasOwnProperty('constructor') ? clsDef.constructor : undefined, 'constructor');

    var /** @type {?} */ proto = constructor.prototype;

    if (clsDef.hasOwnProperty('extends')) {

        if (typeof clsDef.extends === 'function') {

            ((constructor)).prototype = proto =

                Object.create(((clsDef.extends)).prototype);

        }

        else {

            throw new Error("Class definition 'extends' property must be a constructor function was: " + stringify(clsDef.extends));

        }

    }

    for (var /** @type {?} */ key in clsDef) {

        if (key !== 'extends' && key !== 'prototype' && clsDef.hasOwnProperty(key)) {

            proto[key] = applyParams(clsDef[key], key);

        }

    }

    if (this && this.annotations instanceof Array) {

        Reflect.defineMetadata('annotations', this.annotations, constructor);

    }

    var /** @type {?} */ constructorName = constructor['name'];

    if (!constructorName || constructorName === 'constructor') {

        ((constructor))['overriddenName'] = "class" + _nextClassId++;

    }

    return (constructor);

}

/**

 * @suppress {globalThis}

 * @param {?} name

 * @param {?=} props

 * @param {?=} parentClass

 * @param {?=} chainFn

 * @return {?}

 */

function makeDecorator(name, props, parentClass, chainFn) {

    var /** @type {?} */ metaCtor = makeMetadataCtor(props);

    /**

     * @param {?} objOrType

     * @return {?}

     */

    function DecoratorFactory(objOrType) {

        if (!(Reflect && Reflect.getOwnMetadata)) {

            throw 'reflect-metadata shim is required when using class decorators';

        }

        if (this instanceof DecoratorFactory) {

            metaCtor.call(this, objOrType);

            return this;

        }

        var /** @type {?} */ annotationInstance = new ((DecoratorFactory))(objOrType);

        var /** @type {?} */ chainAnnotation = typeof this === 'function' && Array.isArray(this.annotations) ? this.annotations : [];

        chainAnnotation.push(annotationInstance);

        var /** @type {?} */ TypeDecorator = (function TypeDecorator(cls) {

            var /** @type {?} */ annotations = Reflect.getOwnMetadata('annotations', cls) || [];

            annotations.push(annotationInstance);

            Reflect.defineMetadata('annotations', annotations, cls);

            return cls;

        });

        TypeDecorator.annotations = chainAnnotation;

        TypeDecorator.Class = Class;

        if (chainFn)

            chainFn(TypeDecorator);

        return TypeDecorator;

    }

    if (parentClass) {

        DecoratorFactory.prototype = Object.create(parentClass.prototype);

    }

    DecoratorFactory.prototype.toString = function () { return "@" + name; };

    ((DecoratorFactory)).annotationCls = DecoratorFactory;

    return DecoratorFactory;

}

/**

 * @param {?=} props

 * @return {?}

 */

function makeMetadataCtor(props) {

    return function ctor() {

        var args = [];

        for (var _i = 0; _i < arguments.length; _i++) {

            args[_i] = arguments[_i];

        }

        if (props) {

            var /** @type {?} */ values = props.apply(void 0, args);

            for (var /** @type {?} */ propName in values) {

                this[propName] = values[propName];

            }

        }

    };

}

/**

 * @param {?} name

 * @param {?=} props

 * @param {?=} parentClass

 * @return {?}

 */

function makeParamDecorator(name, props, parentClass) {

    var /** @type {?} */ metaCtor = makeMetadataCtor(props);

    /**

     * @param {...?} args

     * @return {?}

     */

    function ParamDecoratorFactory() {

        var args = [];

        for (var _i = 0; _i < arguments.length; _i++) {

            args[_i] = arguments[_i];

        }

        if (this instanceof ParamDecoratorFactory) {

            metaCtor.apply(this, args);

            return this;

        }

        var /** @type {?} */ annotationInstance = new (((ParamDecoratorFactory)).bind.apply(((ParamDecoratorFactory)), [void 0].concat(args)))();

        ((ParamDecorator)).annotation = annotationInstance;

        return ParamDecorator;

        /**

         * @param {?} cls

         * @param {?} unusedKey

         * @param {?} index

         * @return {?}

         */

        function ParamDecorator(cls, unusedKey, index) {

            var /** @type {?} */ parameters = Reflect.getOwnMetadata('parameters', cls) || [];

            // there might be gaps if some in between parameters do not have annotations.

            // we pad with nulls.

            while (parameters.length <= index) {

                parameters.push(null);

            }

            parameters[index] = parameters[index] || []; /** @type {?} */

            ((parameters[index])).push(annotationInstance);

            Reflect.defineMetadata('parameters', parameters, cls);

            return cls;

        }

    }

    if (parentClass) {

        ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);

    }

    ParamDecoratorFactory.prototype.toString = function () { return "@" + name; };

    ((ParamDecoratorFactory)).annotationCls = ParamDecoratorFactory;

    return ParamDecoratorFactory;

}

/**

 * @param {?} name

 * @param {?=} props

 * @param {?=} parentClass

 * @return {?}

 */

function makePropDecorator(name, props, parentClass) {

    var /** @type {?} */ metaCtor = makeMetadataCtor(props);

    /**

     * @param {...?} args

     * @return {?}

     */

    function PropDecoratorFactory() {

        var args = [];

        for (var _i = 0; _i < arguments.length; _i++) {

            args[_i] = arguments[_i];

        }

        if (this instanceof PropDecoratorFactory) {

            metaCtor.apply(this, args);

            return this;

        }

        var /** @type {?} */ decoratorInstance = new (((PropDecoratorFactory)).bind.apply(((PropDecoratorFactory)), [void 0].concat(args)))();

        return function PropDecorator(target, name) {

            var /** @type {?} */ meta = Reflect.getOwnMetadata('propMetadata', target.constructor) || {};

            meta[name] = meta.hasOwnProperty(name) && meta[name] || [];

            meta[name].unshift(decoratorInstance);

            Reflect.defineMetadata('propMetadata', meta, target.constructor);

        };

    }

    if (parentClass) {

        PropDecoratorFactory.prototype = Object.create(parentClass.prototype);

    }

    PropDecoratorFactory.prototype.toString = function () { return "@" + name; };

    ((PropDecoratorFactory)).annotationCls = PropDecoratorFactory;

    return PropDecoratorFactory;

}

/**

 * @license

 * Copyright Google Inc. 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

 */

/**

 * This token can be used to create a virtual provider that will populate the

 * `entryComponents` fields of components and ng modules based on its `useValue`.

 * All components that are referenced in the `useValue` value (either directly

 * or in a nested array or map) will be added to the `entryComponents` property.

 *

 * ### Example

 * The following example shows how the router can populate the `entryComponents`

 * field of an NgModule based on the router configuration which refers

 * to components.

 *

 * ```typescript

 * // helper function inside the router

 * function provideRoutes(routes) {

 *   return [

 *     {provide: ROUTES, useValue: routes},

 *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}

 *   ];

 * }

 *

 * // user code

 * let routes = [

 *   {path: '/root', component: RootComp},

 *   {path: '/teams', component: TeamsComp}

 * ];

 *

 * \@NgModule({

 *   providers: [provideRoutes(routes)]

 * })

 * class ModuleWithRoutes {}

 * ```

 *

 * \@experimental

 */

var ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken('AnalyzeForEntryComponents');

/**

 * Attribute decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var Attribute = makeParamDecorator('Attribute', function (attributeName) { return ({ attributeName: attributeName }); });

/**

 * Base class for query metadata.

 *

 * See {\@link ContentChildren}, {\@link ContentChild}, {\@link ViewChildren}, {\@link ViewChild} for

 * more information.

 *

 * \@stable

 * @abstract

 */

var Query = (function () {

    function Query() {

    }

    return Query;

}());

/**

 * ContentChildren decorator and metadata.

 *

 *  \@stable

 *  \@Annotation

 */

var ContentChildren = makePropDecorator('ContentChildren', function (selector, data) {

    if (data === void 0) { data = {}; }

    return (Object.assign({ selector: selector, first: false, isViewQuery: false, descendants: false }, data));

}, Query);

/**

 * ContentChild decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var ContentChild = makePropDecorator('ContentChild', function (selector, data) {

    if (data === void 0) { data = {}; }

    return (Object.assign({ selector: selector, first: true, isViewQuery: false, descendants: true }, data));

}, Query);

/**

 * ViewChildren decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var ViewChildren = makePropDecorator('ViewChildren', function (selector, data) {

    if (data === void 0) { data = {}; }

    return (Object.assign({ selector: selector, first: false, isViewQuery: true, descendants: true }, data));

}, Query);

/**

 * ViewChild decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var ViewChild = makePropDecorator('ViewChild', function (selector, data) { return (Object.assign({ selector: selector, first: true, isViewQuery: true, descendants: true }, data)); }, Query);

var ChangeDetectionStrategy = {};

ChangeDetectionStrategy.OnPush = 0;

ChangeDetectionStrategy.Default = 1;

ChangeDetectionStrategy[ChangeDetectionStrategy.OnPush] = "OnPush";

ChangeDetectionStrategy[ChangeDetectionStrategy.Default] = "Default";

var ChangeDetectorStatus = {};

ChangeDetectorStatus.CheckOnce = 0;

ChangeDetectorStatus.Checked = 1;

ChangeDetectorStatus.CheckAlways = 2;

ChangeDetectorStatus.Detached = 3;

ChangeDetectorStatus.Errored = 4;

ChangeDetectorStatus.Destroyed = 5;

ChangeDetectorStatus[ChangeDetectorStatus.CheckOnce] = "CheckOnce";

ChangeDetectorStatus[ChangeDetectorStatus.Checked] = "Checked";

ChangeDetectorStatus[ChangeDetectorStatus.CheckAlways] = "CheckAlways";

ChangeDetectorStatus[ChangeDetectorStatus.Detached] = "Detached";

ChangeDetectorStatus[ChangeDetectorStatus.Errored] = "Errored";

ChangeDetectorStatus[ChangeDetectorStatus.Destroyed] = "Destroyed";

/**

 * @param {?} changeDetectionStrategy

 * @return {?}

 */

function isDefaultChangeDetectionStrategy(changeDetectionStrategy) {

    return changeDetectionStrategy == null ||

        changeDetectionStrategy === ChangeDetectionStrategy.Default;

}

/**

 * @license

 * Copyright Google Inc. 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

 */

/**

 * Directive decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var Directive = makeDecorator('Directive', function (dir) {

    if (dir === void 0) { dir = {}; }

    return dir;

});

/**

 * Component decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var Component = makeDecorator('Component', function (c) {

    if (c === void 0) { c = {}; }

    return (Object.assign({ changeDetection: ChangeDetectionStrategy.Default }, c));

}, Directive);

/**

 * Pipe decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var Pipe = makeDecorator('Pipe', function (p) { return (Object.assign({ pure: true }, p)); });

/**

 * Input decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var Input = makePropDecorator('Input', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });

/**

 * Output decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var Output = makePropDecorator('Output', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });

/**

 * HostBinding decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var HostBinding = makePropDecorator('HostBinding', function (hostPropertyName) { return ({ hostPropertyName: hostPropertyName }); });

/**

 * HostListener decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var HostListener = makePropDecorator('HostListener', function (eventName, args) { return ({ eventName: eventName, args: args }); });

/**

 * @license

 * Copyright Google Inc. 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

 */

/**

 * Defines a schema that will allow:

 * - any non-Angular elements with a `-` in their name,

 * - any properties on elements with a `-` in their name which is the common rule for custom

 * elements.

 *

 * \@stable

 */

var CUSTOM_ELEMENTS_SCHEMA = {

    name: 'custom-elements'

};

/**

 * Defines a schema that will allow any property on any element.

 *

 * \@experimental

 */

var NO_ERRORS_SCHEMA = {

    name: 'no-errors-schema'

};

/**

 * NgModule decorator and metadata.

 *

 * \@stable

 * \@Annotation

 */

var NgModule = makeDecorator('NgModule', function (ngModule) { return ngModule; });

var ViewEncapsulation = {};

ViewEncapsulation.Emulated = 0;

ViewEncapsulation.Native = 1;

ViewEncapsulation.None = 2;

ViewEncapsulation[ViewEncapsulation.Emulated] = "Emulated";

ViewEncapsulation[ViewEncapsulation.Native] = "Native";

ViewEncapsulation[ViewEncapsulation.None] = "None";