{
  "version": 3,
  "sources": ["../ui/web_modules/common/ui-router-rx-04f7f595.js", "../ui/web_modules/@uirouter/angular.js"],
  "sourcesContent": ["import { m as mergeMap, e as map } from './mergeMap-64c6f393.js';\nimport { R as ReplaySubject } from './ReplaySubject-8316d9c1.js';\nimport { f as filter } from './filter-d76a729c.js';\n\n/** @module rx */\n/** Augments UIRouterGlobals with observables for transition starts, successful transitions, and state parameters */\nvar UIRouterRx = /** @class */ (function () {\n    function UIRouterRx(router) {\n        this.name = '@uirouter/rx';\n        this.deregisterFns = [];\n        var start$ = new ReplaySubject(1);\n        var success$ = start$.pipe(mergeMap(function (t) { return t.promise.then(function () { return t; }, function () { return null; }); }), filter(function (t) { return !!t; }));\n        var params$ = success$.pipe(map(function (transition) { return transition.params(); }));\n        var states$ = new ReplaySubject(1);\n        function onStatesChangedEvent(event, states) {\n            var changeEvent = {\n                currentStates: router.stateRegistry.get(),\n                registered: [],\n                deregistered: [],\n            };\n            if (event)\n                changeEvent[event] = states;\n            states$.next(changeEvent);\n        }\n        this.deregisterFns.push(router.transitionService.onStart({}, function (transition) { return start$.next(transition); }));\n        this.deregisterFns.push(router.stateRegistry.onStatesChanged(onStatesChangedEvent));\n        onStatesChangedEvent(null, null);\n        Object.assign(router.globals, { start$: start$, success$: success$, params$: params$, states$: states$ });\n    }\n    UIRouterRx.prototype.dispose = function () {\n        this.deregisterFns.forEach(function (deregisterFn) { return deregisterFn(); });\n        this.deregisterFns = [];\n    };\n    return UIRouterRx;\n}());\nvar UIRouterRxPlugin = UIRouterRx;\n\nexport { UIRouterRx as U, UIRouterRxPlugin as a };\n", "import { _ as __decorate, a as __metadata, c as __param, b as __extends, g as __spread } from '../common/tslib.es6-c4a4947b.js';\nimport { g as from, e as map } from '../common/mergeMap-64c6f393.js';\nimport '../common/merge-183efbc7.js';\nimport { a as concat, B as BehaviorSubject, c as combineLatest } from '../common/concat-981db672.js';\nimport '../common/Notification-9e07e457.js';\nimport { R as ReplaySubject } from '../common/ReplaySubject-8316d9c1.js';\nimport { o as of } from '../common/filter-d76a729c.js';\nimport '../common/share-d41e3509.js';\nimport { s as switchMap } from '../common/switchMap-c513d696.js';\nimport { ComponentFactoryResolver, ReflectiveInjector, ViewChild, ViewContainerRef, Input, Component, Inject, Directive, HostListener, Optional, Output, ContentChildren, Host, Self, InjectionToken, ANALYZE_FOR_ENTRY_COMPONENTS, APP_INITIALIZER, NgModule, NgModuleFactoryLoader, Compiler, NgModuleFactory, PLATFORM_ID, Injector, ElementRef, Renderer2, EventEmitter, QueryList } from '../@angular/core.js';\nimport { LocationStrategy, HashLocationStrategy, PathLocationStrategy, CommonModule, isPlatformBrowser } from '../@angular/common.js';\nimport { p as pick, f as forEach, V as ViewService, s as services, a as parse, i as isFunction, R as ResolveContext, u as unnestR, b as filter, t as trace, N as NATIVE_INJECTOR_TOKEN, c as inArray, d as isDefined, e as extend, g as isNumber, h as identity, j as uniqR, P as PathUtils, k as anyTrueR, T as TransitionService, l as isString, U as UIRouter, m as Resolvable, n as parseUrl, B as BaseLocationServices, o as servicesPlugin, S as StateRegistry, q as StateService, r as UrlMatcherFactory, v as UrlRouter, w as UrlService, x as UIRouterGlobals, y as is, z as BrowserLocationConfig, A as tail, C as Param } from '../common/interface-c1256a29.js';\nexport { bu as $injector, bt as $q, B as BaseLocationServices, bs as BaseUrlRule, z as BrowserLocationConfig, aY as Category, a_ as DefType, ak as Glob, bv as HashLocationService, bd as HookBuilder, by as MemoryLocationConfig, bw as MemoryLocationService, N as NATIVE_INJECTOR_TOKEN, C as Param, bq as ParamFactory, b1 as ParamType, a$ as ParamTypes, b2 as PathNode, P as PathUtils, bx as PushStateLocationService, aI as Queue, bf as RegisteredHook, bh as RejectType, bi as Rejection, m as Resolvable, R as ResolveContext, b6 as StateBuilder, b8 as StateMatcher, b7 as StateObject, b0 as StateParams, b9 as StateQueueManager, S as StateRegistry, q as StateService, ba as TargetState, aZ as Trace, bj as Transition, bl as TransitionEventType, bk as TransitionHook, bb as TransitionHookPhase, bc as TransitionHookScope, T as TransitionService, U as UIRouter, x as UIRouterGlobals, bG as UIRouterPluginBase, bo as UrlConfig, bp as UrlMatcher, r as UrlMatcherFactory, v as UrlRouter, br as UrlRuleFactory, bn as UrlRules, w as UrlService, V as ViewService, ag as _extend, _ as _inArray, O as _pushTo, L as _removeFrom, at as all, a4 as allTrueR, Y as ancestors, ar as and, au as any, k as anyTrueR, ae as applyPairs, ad as arrayTuples, ab as assertFn, aa as assertMap, a9 as assertPredicate, aP as beforeAfterSubstr, bB as buildUrl, am as compose, af as copy, I as createProxyFunctions, al as curry, b4 as defaultResolvePolicy, bm as defaultTransOpts, W as defaults, Q as deregAll, av as eq, G as equals, e as extend, b as filter, a0 as find, a8 as flatten, a5 as flattenR, aN as fnToString, f as forEach, E as fromJson, aM as functionToString, bA as getParams, bD as hashLocationPlugin, aQ as hostRegex, h as identity, c as inArray, J as inherit, ax as invoke, y as is, aD as isArray, aE as isDate, d as isDefined, i as isFunction, aG as isInjectable, aA as isNull, aB as isNullOrUndefined, g as isNumber, aC as isObject, aH as isPromise, aF as isRegExp, l as isString, az as isUndefined, aX as joinNeighborsR, aL as kebobString, bz as keyValsToObjectR, bC as locationPluginFactory, bg as makeEvent, aj as makeStub, a2 as map, a1 as mapObj, be as matchState, aJ as maxLength, bF as memoryLocationPlugin, X as mergeR, H as noop, aq as not, Z as omit, as as or, aK as padString, ac as pairs, a as parse, n as parseUrl, ay as pattern, p as pick, an as pipe, $ as pluck, ao as prop, ap as propEq, a6 as pushR, bE as pushStateLocationPlugin, M as pushTo, K as removeFrom, b5 as resolvablesBuilder, b3 as resolvePolicies, D as root, s as services, o as servicesPlugin, ah as silenceUncaughtInPromise, ai as silentRejection, aU as splitEqual, aS as splitHash, aW as splitOnDelim, aT as splitQuery, aO as stringify, aR as stripLastPathElement, A as tail, F as toJson, t as trace, aV as trimHashVal, j as uniqR, a7 as unnest, u as unnestR, aw as val, a3 as values } from '../common/interface-c1256a29.js';\nimport { U as UIRouterRx } from '../common/ui-router-rx-04f7f595.js';\n\n/** @module ng2 */ /** */\n/**\n * This is a [[StateBuilder.builder]] function for Angular `views`.\n *\n * When the [[StateBuilder]] builds a [[State]] object from a raw [[StateDeclaration]], this builder\n * handles the `views` property with logic specific to @uirouter/angular.\n *\n * If no `views: {}` property exists on the [[StateDeclaration]], then it creates the `views` object and\n * applies the state-level configuration to a view named `$default`.\n */\nfunction ng2ViewsBuilder(state) {\n    var views = {}, viewsObject = state.views || { $default: pick(state, ['component', 'bindings']) };\n    forEach(viewsObject, function (config, name) {\n        name = name || '$default'; // Account for views: { \"\": { template... } }\n        if (isFunction(config))\n            config = { component: config };\n        if (Object.keys(config).length === 0)\n            return;\n        config.$type = 'ng2';\n        config.$context = state;\n        config.$name = name;\n        var normalized = ViewService.normalizeUIViewTarget(config.$context, config.$name);\n        config.$uiViewName = normalized.uiViewName;\n        config.$uiViewContextAnchor = normalized.uiViewContextAnchor;\n        views[name] = config;\n    });\n    return views;\n}\nvar id = 0;\nvar Ng2ViewConfig = /** @class */ (function () {\n    function Ng2ViewConfig(path, viewDecl) {\n        this.path = path;\n        this.viewDecl = viewDecl;\n        this.$id = id++;\n        this.loaded = true;\n    }\n    Ng2ViewConfig.prototype.load = function () {\n        return services.$q.when(this);\n    };\n    return Ng2ViewConfig;\n}());\n\n/**\n * Merge two injectors\n *\n * This class implements the Injector ng2 interface but delegates\n * to the Injectors provided in the constructor.\n */\nvar MergeInjector = /** @class */ (function () {\n    function MergeInjector() {\n        var injectors = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            injectors[_i] = arguments[_i];\n        }\n        if (injectors.length < 2)\n            throw new Error('pass at least two injectors');\n        this.injectors = injectors;\n    }\n    /**\n     * Get the token from the first injector which contains it.\n     *\n     * Delegates to the first Injector.get().\n     * If not found, then delegates to the second Injector (and so forth).\n     * If no Injector contains the token, return the `notFoundValue`, or throw.\n     *\n     * @param token the DI token\n     * @param notFoundValue the value to return if none of the Injectors contains the token.\n     * @returns {any} the DI value\n     */\n    MergeInjector.prototype.get = function (token, notFoundValue) {\n        for (var i = 0; i < this.injectors.length; i++) {\n            var val = this.injectors[i].get(token, MergeInjector.NOT_FOUND);\n            if (val !== MergeInjector.NOT_FOUND)\n                return val;\n        }\n        if (arguments.length >= 2)\n            return notFoundValue;\n        // This will throw the DI Injector error\n        this.injectors[0].get(token);\n    };\n    MergeInjector.NOT_FOUND = {};\n    return MergeInjector;\n}());\n\n/** @hidden */\nvar id$1 = 0;\n/**\n * Given a component class, gets the inputs of styles:\n *\n * - @Input('foo') _foo\n * - `inputs: ['foo']`\n *\n * @internalapi\n */\nvar ng2ComponentInputs = function (factory) {\n    return factory.inputs.map(function (input) { return ({ prop: input.propName, token: input.templateName }); });\n};\nvar \u02750 = ng2ComponentInputs;\n/**\n * A UI-Router viewport directive, which is filled in by a view (component) on a state.\n *\n * ### Selector\n *\n * A `ui-view` directive can be created as an element: `<ui-view></ui-view>` or as an attribute: `<div ui-view></div>`.\n *\n * ### Purpose\n *\n * This directive is used in a Component template (or as the root component) to create a viewport.  The viewport\n * is filled in by a view (as defined by a [[Ng2ViewDeclaration]] inside a [[Ng2StateDeclaration]]) when the view's\n * state has been activated.\n *\n * #### Example:\n * ```js\n * // This app has two states, 'foo' and 'bar'\n * stateRegistry.register({ name: 'foo', url: '/foo', component: FooComponent });\n * stateRegistry.register({ name: 'bar', url: '/bar', component: BarComponent });\n * ```\n * ```html\n * <!-- This ui-view will be filled in by the foo state's component or\n *      the bar state's component when the foo or bar state is activated -->\n * <ui-view></ui-view>\n * ```\n *\n * ### Named ui-views\n *\n * A `ui-view` may optionally be given a name via the attribute value: `<div ui-view='header'></div>`.  *Note:\n * an unnamed `ui-view` is internally named `$default`*.   When a `ui-view` has a name, it will be filled in\n * by a matching named view.\n *\n * #### Example:\n * ```js\n * stateRegistry.register({\n *   name: 'foo',\n *   url: '/foo',\n *   views: { header: HeaderComponent, $default: FooComponent });\n * ```\n * ```html\n * <!-- When 'foo' state is active, filled by HeaderComponent -->\n * <div ui-view=\"header\"></div>\n *\n * <!-- When 'foo' state is active, filled by FooComponent -->\n * <ui-view></ui-view>\n * ```\n */\nvar UIView = /** @class */ (function () {\n    function UIView(router, parent, viewContainerRef) {\n        this.router = router;\n        this.viewContainerRef = viewContainerRef;\n        /** Data about the this UIView */\n        this._uiViewData = {};\n        this._parent = parent;\n    }\n    UIView_1 = UIView;\n    Object.defineProperty(UIView.prototype, \"_name\", {\n        set: function (val) {\n            this.name = val;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UIView.prototype, \"state\", {\n        /**\n         * @returns the UI-Router `state` that is filling this uiView, or `undefined`.\n         */\n        get: function () {\n            return parse('_uiViewData.config.viewDecl.$context.self')(this);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    UIView.prototype.ngOnInit = function () {\n        var _this = this;\n        var router = this.router;\n        var parentFqn = this._parent.fqn;\n        var name = this.name || '$default';\n        this._uiViewData = {\n            $type: 'ng2',\n            id: id$1++,\n            name: name,\n            fqn: parentFqn ? parentFqn + '.' + name : name,\n            creationContext: this._parent.context,\n            configUpdated: this._viewConfigUpdated.bind(this),\n            config: undefined,\n        };\n        this._deregisterUiCanExitHook = router.transitionService.onBefore({}, function (trans) {\n            return _this._invokeUiCanExitHook(trans);\n        });\n        this._deregisterUiOnParamsChangedHook = router.transitionService.onSuccess({}, function (trans) {\n            return _this._invokeUiOnParamsChangedHook(trans);\n        });\n        this._deregisterUIView = router.viewService.registerUIView(this._uiViewData);\n    };\n    /**\n     * For each transition, checks the component loaded in the ui-view for:\n     *\n     * - has a uiCanExit() component hook\n     * - is being exited\n     *\n     * If both are true, adds the uiCanExit component function as a hook to that singular Transition.\n     */\n    UIView.prototype._invokeUiCanExitHook = function (trans) {\n        var instance = this._componentRef && this._componentRef.instance;\n        var uiCanExitFn = instance && instance.uiCanExit;\n        if (isFunction(uiCanExitFn)) {\n            var state = this.state;\n            if (trans.exiting().indexOf(state) !== -1) {\n                trans.onStart({}, function () {\n                    return uiCanExitFn.call(instance, trans);\n                });\n            }\n        }\n    };\n    /**\n     * For each transition, checks if any param values changed and notify component\n     */\n    UIView.prototype._invokeUiOnParamsChangedHook = function ($transition$) {\n        var instance = this._componentRef && this._componentRef.instance;\n        var uiOnParamsChanged = instance && instance.uiOnParamsChanged;\n        if (isFunction(uiOnParamsChanged)) {\n            var viewState = this.state;\n            var resolveContext = new ResolveContext(this._uiViewData.config.path);\n            var viewCreationTrans = resolveContext.getResolvable('$transition$').data;\n            // Exit early if the $transition$ is the same as the view was created within.\n            // Exit early if the $transition$ will exit the state the view is for.\n            if ($transition$ === viewCreationTrans || $transition$.exiting().indexOf(viewState) !== -1)\n                return;\n            var toParams_1 = $transition$.params('to');\n            var fromParams_1 = $transition$.params('from');\n            var getNodeSchema = function (node) { return node.paramSchema; };\n            var toSchema = $transition$\n                .treeChanges('to')\n                .map(getNodeSchema)\n                .reduce(unnestR, []);\n            var fromSchema_1 = $transition$\n                .treeChanges('from')\n                .map(getNodeSchema)\n                .reduce(unnestR, []);\n            // Find the to params that have different values than the from params\n            var changedToParams = toSchema.filter(function (param) {\n                var idx = fromSchema_1.indexOf(param);\n                return idx === -1 || !fromSchema_1[idx].type.equals(toParams_1[param.id], fromParams_1[param.id]);\n            });\n            // Only trigger callback if a to param has changed or is new\n            if (changedToParams.length) {\n                var changedKeys_1 = changedToParams.map(function (x) { return x.id; });\n                // Filter the params to only changed/new to params.  `$transition$.params()` may be used to get all params.\n                var newValues = filter(toParams_1, function (val, key) { return changedKeys_1.indexOf(key) !== -1; });\n                instance.uiOnParamsChanged(newValues, $transition$);\n            }\n        }\n    };\n    UIView.prototype._disposeLast = function () {\n        if (this._componentRef)\n            this._componentRef.destroy();\n        this._componentRef = null;\n    };\n    UIView.prototype.ngOnDestroy = function () {\n        if (this._deregisterUIView)\n            this._deregisterUIView();\n        if (this._deregisterUiCanExitHook)\n            this._deregisterUiCanExitHook();\n        if (this._deregisterUiOnParamsChangedHook)\n            this._deregisterUiOnParamsChangedHook();\n        this._deregisterUIView = this._deregisterUiCanExitHook = this._deregisterUiOnParamsChangedHook = null;\n        this._disposeLast();\n    };\n    /**\n     * The view service is informing us of an updated ViewConfig\n     * (usually because a transition activated some state and its views)\n     */\n    UIView.prototype._viewConfigUpdated = function (config) {\n        // The config may be undefined if there is nothing currently targeting this UIView.\n        // Dispose the current component, if there is one\n        if (!config)\n            return this._disposeLast();\n        // Only care about Ng2 configs\n        if (!(config instanceof Ng2ViewConfig))\n            return;\n        // The \"new\" viewconfig is already applied, so exit early\n        if (this._uiViewData.config === config)\n            return;\n        // This is a new ViewConfig.  Dispose the previous component\n        this._disposeLast();\n        trace.traceUIViewConfigUpdated(this._uiViewData, config && config.viewDecl.$context);\n        this._applyUpdatedConfig(config);\n        // Initiate change detection for the newly created component\n        this._componentRef.changeDetectorRef.markForCheck();\n    };\n    UIView.prototype._applyUpdatedConfig = function (config) {\n        this._uiViewData.config = config;\n        // Create the Injector for the routed component\n        var context = new ResolveContext(config.path);\n        var componentInjector = this._getComponentInjector(context);\n        // Get the component class from the view declaration. TODO: allow promises?\n        var componentClass = config.viewDecl.component;\n        // Create the component\n        var compFactoryResolver = componentInjector.get(ComponentFactoryResolver);\n        var compFactory = compFactoryResolver.resolveComponentFactory(componentClass);\n        this._componentRef = this._componentTarget.createComponent(compFactory, undefined, componentInjector);\n        // Wire resolves to @Input()s\n        this._applyInputBindings(compFactory, this._componentRef.instance, context, componentClass);\n    };\n    /**\n     * Creates a new Injector for a routed component.\n     *\n     * Adds resolve values to the Injector\n     * Adds providers from the NgModule for the state\n     * Adds providers from the parent Component in the component tree\n     * Adds a PARENT_INJECT view context object\n     *\n     * @returns an Injector\n     */\n    UIView.prototype._getComponentInjector = function (context) {\n        // Map resolves to \"useValue: providers\"\n        var resolvables = context\n            .getTokens()\n            .map(function (token) { return context.getResolvable(token); })\n            .filter(function (r) { return r.resolved; });\n        var newProviders = resolvables.map(function (r) { return ({ provide: r.token, useValue: context.injector().get(r.token) }); });\n        var parentInject = { context: this._uiViewData.config.viewDecl.$context, fqn: this._uiViewData.fqn };\n        newProviders.push({ provide: UIView_1.PARENT_INJECT, useValue: parentInject });\n        var parentComponentInjector = this.viewContainerRef.injector;\n        var moduleInjector = context.getResolvable(NATIVE_INJECTOR_TOKEN).data;\n        var mergedParentInjector = new MergeInjector(moduleInjector, parentComponentInjector);\n        return ReflectiveInjector.resolveAndCreate(newProviders, mergedParentInjector);\n    };\n    /**\n     * Supplies component inputs with resolve data\n     *\n     * Finds component inputs which match resolves (by name) and sets the input value\n     * to the resolve data.\n     */\n    UIView.prototype._applyInputBindings = function (factory, component, context, componentClass) {\n        var bindings = this._uiViewData.config.viewDecl['bindings'] || {};\n        var explicitBoundProps = Object.keys(bindings);\n        // Returns the actual component property for a renamed an input renamed using `@Input('foo') _foo`.\n        // return the `_foo` property\n        var renamedInputProp = function (prop) {\n            var input = factory.inputs.find(function (i) { return i.templateName === prop; });\n            return (input && input.propName) || prop;\n        };\n        // Supply resolve data to component as specified in the state's `bindings: {}`\n        var explicitInputTuples = explicitBoundProps.reduce(function (acc, key) { return acc.concat([{ prop: renamedInputProp(key), token: bindings[key] }]); }, []);\n        // Supply resolve data to matching @Input('prop') or inputs: ['prop']\n        var implicitInputTuples = ng2ComponentInputs(factory).filter(function (tuple) { return !inArray(explicitBoundProps, tuple.prop); });\n        var addResolvable = function (tuple) { return ({\n            prop: tuple.prop,\n            resolvable: context.getResolvable(tuple.token),\n        }); };\n        var injector = context.injector();\n        explicitInputTuples\n            .concat(implicitInputTuples)\n            .map(addResolvable)\n            .filter(function (tuple) { return tuple.resolvable && tuple.resolvable.resolved; })\n            .forEach(function (tuple) {\n            component[tuple.prop] = injector.get(tuple.resolvable.token);\n        });\n    };\n    var UIView_1;\n    UIView.PARENT_INJECT = 'UIView.PARENT_INJECT';\n    __decorate([\n        ViewChild('componentTarget', { read: ViewContainerRef, static: true }),\n        __metadata(\"design:type\", ViewContainerRef)\n    ], UIView.prototype, \"_componentTarget\", void 0);\n    __decorate([\n        Input('name'),\n        __metadata(\"design:type\", String)\n    ], UIView.prototype, \"name\", void 0);\n    __decorate([\n        Input('ui-view'),\n        __metadata(\"design:type\", String),\n        __metadata(\"design:paramtypes\", [String])\n    ], UIView.prototype, \"_name\", null);\n    UIView = UIView_1 = __decorate([\n        Component({\n            selector: 'ui-view, [ui-view]',\n            exportAs: 'uiView',\n            template: \"\\n    <ng-template #componentTarget></ng-template>\\n    <ng-content *ngIf=\\\"!_componentRef\\\"></ng-content>\\n  \"\n        }),\n        __param(1, Inject(UIView_1.PARENT_INJECT)),\n        __metadata(\"design:paramtypes\", [UIRouter, Object, ViewContainerRef])\n    ], UIView);\n    return UIView;\n}());\n\n/** @module ng2 */ /** */\nfunction applyModuleConfig(uiRouter, injector, module) {\n    if (module === void 0) { module = {}; }\n    if (isFunction(module.config)) {\n        module.config(uiRouter, injector, module);\n    }\n    var states = module.states || [];\n    return states.map(function (state) { return uiRouter.stateRegistry.register(state); });\n}\nfunction applyRootModuleConfig(uiRouter, injector, module) {\n    isDefined(module.deferIntercept) && uiRouter.urlService.deferIntercept(module.deferIntercept);\n    isDefined(module.otherwise) && uiRouter.urlService.rules.otherwise(module.otherwise);\n    isDefined(module.initial) && uiRouter.urlService.rules.initial(module.initial);\n}\n\n/**\n * @internalapi\n * # blah blah blah\n */\nvar AnchorUISref = /** @class */ (function () {\n    function AnchorUISref(_el, _renderer) {\n        this._el = _el;\n        this._renderer = _renderer;\n    }\n    AnchorUISref.prototype.openInNewTab = function () {\n        return this._el.nativeElement.target === '_blank';\n    };\n    AnchorUISref.prototype.update = function (href) {\n        if (href && href !== '') {\n            this._renderer.setProperty(this._el.nativeElement, 'href', href);\n        }\n        else {\n            this._renderer.removeAttribute(this._el.nativeElement, 'href');\n        }\n    };\n    AnchorUISref = __decorate([\n        Directive({ selector: 'a[uiSref]' }),\n        __metadata(\"design:paramtypes\", [ElementRef, Renderer2])\n    ], AnchorUISref);\n    return AnchorUISref;\n}());\n/**\n * A directive when clicked, initiates a [[Transition]] to a [[TargetState]].\n *\n * ### Purpose\n *\n * This directive is applied to anchor tags (`<a>`) or any other clickable element.  It is a state reference (or sref --\n * similar to an href).  When clicked, the directive will transition to that state by calling [[StateService.go]],\n * and optionally supply state parameter values and transition options.\n *\n * When this directive is on an anchor tag, it will also add an `href` attribute to the anchor.\n *\n * ### Selector\n *\n * - `[uiSref]`: The directive is created as an attribute on an element, e.g., `<a uiSref></a>`\n *\n * ### Inputs\n *\n * - `uiSref`: the target state's name, e.g., `uiSref=\"foostate\"`.  If a component template uses a relative `uiSref`,\n * e.g., `uiSref=\".child\"`, the reference is relative to that component's state.\n *\n * - `uiParams`: any target state parameter values, as an object, e.g., `[uiParams]=\"{ fooId: bar.fooId }\"`\n *\n * - `uiOptions`: [[TransitionOptions]], e.g., `[uiOptions]=\"{ inherit: false }\"`\n *\n * @example\n * ```html\n *\n * <!-- Targets bar state' -->\n * <a uiSref=\"bar\">Bar</a>\n *\n * <!-- Assume this component's state is \"foo\".\n *      Relatively targets \"foo.child\" -->\n * <a uiSref=\".child\">Foo Child</a>\n *\n * <!-- Targets \"bar\" state and supplies parameter value -->\n * <a uiSref=\"bar\" [uiParams]=\"{ barId: foo.barId }\">Bar {{foo.barId}}</a>\n *\n * <!-- Targets \"bar\" state and parameter, doesn't inherit existing parameters-->\n * <a uiSref=\"bar\" [uiParams]=\"{ barId: foo.barId }\" [uiOptions]=\"{ inherit: false }\">Bar {{foo.barId}}</a>\n * ```\n */\nvar UISref = /** @class */ (function () {\n    function UISref(_router, _anchorUISref, parent) {\n        var _this = this;\n        /**\n         * An observable (ReplaySubject) of the state this UISref is targeting.\n         * When the UISref is clicked, it will transition to this [[TargetState]].\n         */\n        this.targetState$ = new ReplaySubject(1);\n        /** @internalapi */ this._emit = false;\n        this._router = _router;\n        this._anchorUISref = _anchorUISref;\n        this._parent = parent;\n        this._statesSub = _router.globals.states$.subscribe(function () { return _this.update(); });\n    }\n    Object.defineProperty(UISref.prototype, \"uiSref\", {\n        /** @internalapi */\n        set: function (val) {\n            this.state = val;\n            this.update();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UISref.prototype, \"uiParams\", {\n        /** @internalapi */\n        set: function (val) {\n            this.params = val;\n            this.update();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UISref.prototype, \"uiOptions\", {\n        /** @internalapi */\n        set: function (val) {\n            this.options = val;\n            this.update();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    UISref.prototype.ngOnInit = function () {\n        this._emit = true;\n        this.update();\n    };\n    UISref.prototype.ngOnChanges = function (changes) {\n        this.update();\n    };\n    UISref.prototype.ngOnDestroy = function () {\n        this._emit = false;\n        this._statesSub.unsubscribe();\n        this.targetState$.unsubscribe();\n    };\n    UISref.prototype.update = function () {\n        var $state = this._router.stateService;\n        if (this._emit) {\n            var newTarget = $state.target(this.state, this.params, this.getOptions());\n            this.targetState$.next(newTarget);\n        }\n        if (this._anchorUISref) {\n            var href = $state.href(this.state, this.params, this.getOptions());\n            this._anchorUISref.update(href);\n        }\n    };\n    UISref.prototype.getOptions = function () {\n        var defaultOpts = {\n            relative: this._parent && this._parent.context && this._parent.context.name,\n            inherit: true,\n            source: 'sref',\n        };\n        return extend(defaultOpts, this.options || {});\n    };\n    /** When triggered by a (click) event, this function transitions to the UISref's target state */\n    UISref.prototype.go = function (button, ctrlKey, metaKey) {\n        if ((this._anchorUISref &&\n            (this._anchorUISref.openInNewTab() || button || !isNumber(button) || ctrlKey || metaKey)) ||\n            !this.state) {\n            return;\n        }\n        this._router.stateService.go(this.state, this.params, this.getOptions());\n        return false;\n    };\n    __decorate([\n        Input('uiSref'),\n        __metadata(\"design:type\", String)\n    ], UISref.prototype, \"state\", void 0);\n    __decorate([\n        Input('uiParams'),\n        __metadata(\"design:type\", Object)\n    ], UISref.prototype, \"params\", void 0);\n    __decorate([\n        Input('uiOptions'),\n        __metadata(\"design:type\", Object)\n    ], UISref.prototype, \"options\", void 0);\n    __decorate([\n        HostListener('click', ['$event.button', '$event.ctrlKey', '$event.metaKey']),\n        __metadata(\"design:type\", Function),\n        __metadata(\"design:paramtypes\", [Number, Boolean, Boolean]),\n        __metadata(\"design:returntype\", void 0)\n    ], UISref.prototype, \"go\", null);\n    UISref = __decorate([\n        Directive({\n            selector: '[uiSref]',\n            exportAs: 'uiSref',\n        }),\n        __param(1, Optional()),\n        __param(2, Inject(UIView.PARENT_INJECT)),\n        __metadata(\"design:paramtypes\", [UIRouter,\n            AnchorUISref, Object])\n    ], UISref);\n    return UISref;\n}());\n\n/** @internalapi */\nvar inactiveStatus = {\n    active: false,\n    exact: false,\n    entering: false,\n    exiting: false,\n    targetStates: [],\n};\n/**\n * Returns a Predicate<PathNode[]>\n *\n * The predicate returns true when the target state (and param values)\n * match the (tail of) the path, and the path's param values\n *\n * @internalapi\n */\nvar pathMatches = function (target) {\n    if (!target.exists())\n        return function () { return false; };\n    var state = target.$state();\n    var targetParamVals = target.params();\n    var targetPath = PathUtils.buildPath(target);\n    var paramSchema = targetPath\n        .map(function (node) { return node.paramSchema; })\n        .reduce(unnestR, [])\n        .filter(function (param) { return targetParamVals.hasOwnProperty(param.id); });\n    return function (path) {\n        var tailNode = tail(path);\n        if (!tailNode || tailNode.state !== state)\n            return false;\n        var paramValues = PathUtils.paramValues(path);\n        return Param.equals(paramSchema, paramValues, targetParamVals);\n    };\n};\n/**\n * Given basePath: [a, b], appendPath: [c, d]),\n * Expands the path to [c], [c, d]\n * Then appends each to [a,b,] and returns: [a, b, c], [a, b, c, d]\n *\n * @internalapi\n */\nfunction spreadToSubPaths(basePath, appendPath) {\n    return appendPath.map(function (node) { return basePath.concat(PathUtils.subPath(appendPath, function (n) { return n.state === node.state; })); });\n}\n/**\n * Given a TransEvt (Transition event: started, success, error)\n * and a UISref Target State, return a SrefStatus object\n * which represents the current status of that Sref:\n * active, activeEq (exact match), entering, exiting\n *\n * @internalapi\n */\nfunction getSrefStatus(event, srefTarget) {\n    var pathMatchesTarget = pathMatches(srefTarget);\n    var tc = event.trans.treeChanges();\n    var isStartEvent = event.evt === 'start';\n    var isSuccessEvent = event.evt === 'success';\n    var activePath = isSuccessEvent ? tc.to : tc.from;\n    var isActive = function () {\n        return spreadToSubPaths([], activePath)\n            .map(pathMatchesTarget)\n            .reduce(anyTrueR, false);\n    };\n    var isExact = function () { return pathMatchesTarget(activePath); };\n    var isEntering = function () {\n        return spreadToSubPaths(tc.retained, tc.entering)\n            .map(pathMatchesTarget)\n            .reduce(anyTrueR, false);\n    };\n    var isExiting = function () {\n        return spreadToSubPaths(tc.retained, tc.exiting)\n            .map(pathMatchesTarget)\n            .reduce(anyTrueR, false);\n    };\n    return {\n        active: isActive(),\n        exact: isExact(),\n        entering: isStartEvent ? isEntering() : false,\n        exiting: isStartEvent ? isExiting() : false,\n        targetStates: [srefTarget],\n    };\n}\n/** @internalapi */\nfunction mergeSrefStatus(left, right) {\n    return {\n        active: left.active || right.active,\n        exact: left.exact || right.exact,\n        entering: left.entering || right.entering,\n        exiting: left.exiting || right.exiting,\n        targetStates: left.targetStates.concat(right.targetStates),\n    };\n}\n/**\n * A directive which emits events when a paired [[UISref]] status changes.\n *\n * This directive is primarily used by the [[UISrefActive]] directives to monitor `UISref`(s).\n *\n * This directive shares two attribute selectors with `UISrefActive`:\n *\n * - `[uiSrefActive]`\n * - `[uiSrefActiveEq]`.\n *\n * Thus, whenever a `UISrefActive` directive is created, a `UISrefStatus` directive is also created.\n *\n * Most apps should simply use `UISrefActive`, but some advanced components may want to process the\n * [[SrefStatus]] events directly.\n *\n * ```js\n * <li (uiSrefStatus)=\"onSrefStatusChanged($event)\">\n *   <a uiSref=\"book\" [uiParams]=\"{ bookId: book.id }\">Book {{ book.name }}</a>\n * </li>\n * ```\n *\n * The `uiSrefStatus` event is emitted whenever an enclosed `uiSref`'s status changes.\n * The event emitted is of type [[SrefStatus]], and has boolean values for `active`, `exact`, `entering`, and `exiting`; also has a [[StateOrName]] `identifier`value.\n *\n * The values from this event can be captured and stored on a component (then applied, e.g., using ngClass).\n *\n * ---\n *\n * A single `uiSrefStatus` can enclose multiple `uiSref`.\n * Each status boolean (`active`, `exact`, `entering`, `exiting`) will be true if *any of the enclosed `uiSref` status is true*.\n * In other words, all enclosed `uiSref` statuses  are merged to a single status using `||` (logical or).\n *\n * ```js\n * <li (uiSrefStatus)=\"onSrefStatus($event)\" uiSref=\"admin\">\n *   Home\n *   <ul>\n *     <li> <a uiSref=\"admin.users\">Users</a> </li>\n *     <li> <a uiSref=\"admin.groups\">Groups</a> </li>\n *   </ul>\n * </li>\n * ```\n *\n * In the above example, `$event.active === true` when either `admin.users` or `admin.groups` is active.\n *\n * ---\n *\n * This API is subject to change.\n */\nvar UISrefStatus = /** @class */ (function () {\n    function UISrefStatus(_hostUiSref, _globals) {\n        /** current statuses of the state/params the uiSref directive is linking to */\n        this.uiSrefStatus = new EventEmitter(false);\n        this._globals = _globals;\n        this._hostUiSref = _hostUiSref;\n        this.status = Object.assign({}, inactiveStatus);\n    }\n    UISrefStatus.prototype.ngAfterContentInit = function () {\n        var _this = this;\n        // Map each transition start event to a stream of:\n        // start -> (success|error)\n        var transEvents$ = this._globals.start$.pipe(switchMap(function (trans) {\n            var event = function (evt) { return ({ evt: evt, trans: trans }); };\n            var transStart$ = of(event('start'));\n            var transResult = trans.promise.then(function () { return event('success'); }, function () { return event('error'); });\n            var transFinish$ = from(transResult);\n            return concat(transStart$, transFinish$);\n        }));\n        var withHostSref = function (childrenSrefs) {\n            return childrenSrefs\n                .concat(_this._hostUiSref)\n                .filter(identity)\n                .reduce(uniqR, []);\n        };\n        // Watch the @ContentChildren UISref[] components and get their target states\n        this._srefs$ = new BehaviorSubject(withHostSref(this._srefs.toArray()));\n        this._srefChangesSub = this._srefs.changes.subscribe(function (srefs) { return _this._srefs$.next(withHostSref(srefs)); });\n        var targetStates$ = this._srefs$.pipe(switchMap(function (srefs) { return combineLatest(srefs.map(function (sref) { return sref.targetState$; })); }));\n        // Calculate the status of each UISref based on the transition event.\n        // Reduce the statuses (if multiple) by or-ing each flag.\n        this._subscription = transEvents$\n            .pipe(switchMap(function (evt) {\n            return targetStates$.pipe(map(function (targets) {\n                var statuses = targets.map(function (target) { return getSrefStatus(evt, target); });\n                return statuses.reduce(mergeSrefStatus);\n            }));\n        }))\n            .subscribe(this._setStatus.bind(this));\n    };\n    UISrefStatus.prototype.ngOnDestroy = function () {\n        if (this._subscription)\n            this._subscription.unsubscribe();\n        if (this._srefChangesSub)\n            this._srefChangesSub.unsubscribe();\n        if (this._srefs$)\n            this._srefs$.unsubscribe();\n        this._subscription = this._srefChangesSub = this._srefs$ = undefined;\n    };\n    UISrefStatus.prototype._setStatus = function (status) {\n        this.status = status;\n        this.uiSrefStatus.emit(status);\n    };\n    __decorate([\n        Output('uiSrefStatus'),\n        __metadata(\"design:type\", Object)\n    ], UISrefStatus.prototype, \"uiSrefStatus\", void 0);\n    __decorate([\n        ContentChildren(UISref, { descendants: true }),\n        __metadata(\"design:type\", QueryList)\n    ], UISrefStatus.prototype, \"_srefs\", void 0);\n    UISrefStatus = __decorate([\n        Directive({\n            selector: '[uiSrefStatus],[uiSrefActive],[uiSrefActiveEq]',\n            exportAs: 'uiSrefStatus',\n        }),\n        __param(0, Host()), __param(0, Self()), __param(0, Optional()),\n        __metadata(\"design:paramtypes\", [UISref, UIRouterGlobals])\n    ], UISrefStatus);\n    return UISrefStatus;\n}());\n\n/**\n * A directive that adds a CSS class when its associated `uiSref` link is active.\n *\n * ### Purpose\n *\n * This directive should be paired with one (or more) [[UISref]] directives.\n * It will apply a CSS class to its element when the state the `uiSref` targets is activated.\n *\n * This can be used to create navigation UI where the active link is highlighted.\n *\n * ### Selectors\n *\n * - `[uiSrefActive]`: When this selector is used, the class is added when the target state or any\n * child of the target state is active\n * - `[uiSrefActiveEq]`: When this selector is used, the class is added when the target state is\n * exactly active (the class is not added if a child of the target state is active).\n *\n * ### Inputs\n *\n * - `uiSrefActive`/`uiSrefActiveEq`: one or more CSS classes to add to the element, when the `uiSref` is active\n *\n * #### Example:\n * The anchor tag has the `active` class added when the `foo` state is active.\n * ```html\n * <a uiSref=\"foo\" uiSrefActive=\"active\">Foo</a>\n * ```\n *\n * ### Matching parameters\n *\n * If the `uiSref` includes parameters, the current state must be active, *and* the parameter values must match.\n *\n * #### Example:\n * The first anchor tag has the `active` class added when the `foo.bar` state is active and the `id` parameter\n * equals 25.\n * The second anchor tag has the `active` class added when the `foo.bar` state is active and the `id` parameter\n * equals 32.\n * ```html\n * <a uiSref=\"foo.bar\" [uiParams]=\"{ id: 25 }\" uiSrefActive=\"active\">Bar #25</a>\n * <a uiSref=\"foo.bar\" [uiParams]=\"{ id: 32 }\" uiSrefActive=\"active\">Bar #32</a>\n * ```\n *\n * #### Example:\n * A list of anchor tags are created for a list of `bar` objects.\n * An anchor tag will have the `active` class when `foo.bar` state is active and the `id` parameter matches\n * that object's `id`.\n * ```html\n * <li *ngFor=\"let bar of bars\">\n *   <a uiSref=\"foo.bar\" [uiParams]=\"{ id: bar.id }\" uiSrefActive=\"active\">Bar #{{ bar.id }}</a>\n * </li>\n * ```\n *\n * ### Multiple uiSrefs\n *\n * A single `uiSrefActive` can be used for multiple `uiSref` links.\n * This can be used to create (for example) a drop down navigation menu, where the menui is highlighted\n * if *any* of its inner links are active.\n *\n * The `uiSrefActive` should be placed on an ancestor element of the `uiSref` list.\n * If anyof the `uiSref` links are activated, the class will be added to the ancestor element.\n *\n * #### Example:\n * This is a dropdown nagivation menu for \"Admin\" states.\n * When any of `admin.users`, `admin.groups`, `admin.settings` are active, the `<li>` for the dropdown\n * has the `dropdown-child-active` class applied.\n * Additionally, the active anchor tag has the `active` class applied.\n * ```html\n * <ul class=\"dropdown-menu\">\n *   <li uiSrefActive=\"dropdown-child-active\" class=\"dropdown admin\">\n *     Admin\n *     <ul>\n *       <li><a uiSref=\"admin.users\" uiSrefActive=\"active\">Users</a></li>\n *       <li><a uiSref=\"admin.groups\" uiSrefActive=\"active\">Groups</a></li>\n *       <li><a uiSref=\"admin.settings\" uiSrefActive=\"active\">Settings</a></li>\n *     </ul>\n *   </li>\n * </ul>\n * ```\n */\nvar UISrefActive = /** @class */ (function () {\n    function UISrefActive(uiSrefStatus, rnd, host) {\n        var _this = this;\n        this._classes = [];\n        this._classesEq = [];\n        this._subscription = uiSrefStatus.uiSrefStatus.subscribe(function (next) {\n            _this._classes.forEach(function (cls) {\n                if (next.active) {\n                    rnd.addClass(host.nativeElement, cls);\n                }\n                else {\n                    rnd.removeClass(host.nativeElement, cls);\n                }\n            });\n            _this._classesEq.forEach(function (cls) {\n                if (next.exact) {\n                    rnd.addClass(host.nativeElement, cls);\n                }\n                else {\n                    rnd.removeClass(host.nativeElement, cls);\n                }\n            });\n        });\n    }\n    Object.defineProperty(UISrefActive.prototype, \"active\", {\n        set: function (val) {\n            this._classes = val.split(/\\s+/);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UISrefActive.prototype, \"activeEq\", {\n        set: function (val) {\n            this._classesEq = val.split(/\\s+/);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    UISrefActive.prototype.ngOnDestroy = function () {\n        this._subscription.unsubscribe();\n    };\n    __decorate([\n        Input('uiSrefActive'),\n        __metadata(\"design:type\", String),\n        __metadata(\"design:paramtypes\", [String])\n    ], UISrefActive.prototype, \"active\", null);\n    __decorate([\n        Input('uiSrefActiveEq'),\n        __metadata(\"design:type\", String),\n        __metadata(\"design:paramtypes\", [String])\n    ], UISrefActive.prototype, \"activeEq\", null);\n    UISrefActive = __decorate([\n        Directive({\n            selector: '[uiSrefActive],[uiSrefActiveEq]',\n        }),\n        __param(2, Host()),\n        __metadata(\"design:paramtypes\", [UISrefStatus, Renderer2, ElementRef])\n    ], UISrefActive);\n    return UISrefActive;\n}());\n\n/**\n * The UI-Router for Angular directives:\n *\n * - [[UIView]]: A viewport for routed components\n * - [[UISref]]: A state ref to a target state; navigates when clicked\n * - [[UISrefActive]]: (and `UISrefActiveEq`) Adds a css class when a UISref's target state (or a child state) is active\n *\n * @ng2api\n * @preferred\n * @module directives\n */ /** */\n/** @internalapi */\nvar _UIROUTER_DIRECTIVES = [UISref, AnchorUISref, UIView, UISrefActive, UISrefStatus];\n/**\n * References to the UI-Router directive classes, for use within a @Component's `directives:` property\n * @deprecated use [[UIRouterModule]]\n * @internalapi\n */\nvar UIROUTER_DIRECTIVES = _UIROUTER_DIRECTIVES;\n\n/** @hidden */ var UIROUTER_ROOT_MODULE = new InjectionToken('UIRouter Root Module');\n/** @hidden */ var UIROUTER_MODULE_TOKEN = new InjectionToken('UIRouter Module');\n/** @hidden */ var UIROUTER_STATES = new InjectionToken('UIRouter States');\n// Delay angular bootstrap until first transition is successful, for SSR.\n// See https://github.com/ui-router/angular/pull/127\nfunction onTransitionReady(transitionService, root) {\n    var mod = root[0];\n    if (!mod || !mod.deferInitialRender) {\n        return function () { return Promise.resolve(); };\n    }\n    return function () {\n        return new Promise(function (resolve) {\n            var hook = function (trans) {\n                trans.promise.then(resolve, resolve);\n            };\n            transitionService.onStart({}, hook, { invokeLimit: 1 });\n        });\n    };\n}\nfunction makeRootProviders(module) {\n    return [\n        { provide: UIROUTER_ROOT_MODULE, useValue: module, multi: true },\n        { provide: UIROUTER_MODULE_TOKEN, useValue: module, multi: true },\n        { provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: module.states || [], multi: true },\n        {\n            provide: APP_INITIALIZER,\n            useFactory: onTransitionReady,\n            deps: [TransitionService, UIROUTER_ROOT_MODULE],\n            multi: true,\n        },\n    ];\n}\nfunction makeChildProviders(module) {\n    return [\n        { provide: UIROUTER_MODULE_TOKEN, useValue: module, multi: true },\n        { provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: module.states || [], multi: true },\n    ];\n}\nfunction locationStrategy(useHash) {\n    return { provide: LocationStrategy, useClass: useHash ? HashLocationStrategy : PathLocationStrategy };\n}\n/**\n * Creates UI-Router Modules\n *\n * This class has two static factory methods which create UIRouter Modules.\n * A UI-Router Module is an [Angular NgModule](https://angular.io/docs/ts/latest/guide/ngmodule.html)\n * with support for UI-Router.\n *\n * ### UIRouter Directives\n *\n * When a UI-Router Module is imported into a `NgModule`, that module's components\n * can use the UIRouter Directives such as [[UIView]], [[UISref]], [[UISrefActive]].\n *\n * ### State Definitions\n *\n * State definitions found in the `states:` property are provided to the Dependency Injector.\n * This enables UI-Router to automatically register the states with the [[StateRegistry]] at bootstrap (and during lazy load).\n *\n * ### Entry Components\n *\n * Any routed components are added as `entryComponents:` so they will get compiled.\n */\nvar UIRouterModule = /** @class */ (function () {\n    function UIRouterModule() {\n    }\n    UIRouterModule_1 = UIRouterModule;\n    /**\n     * Creates a UI-Router Module for the root (bootstrapped) application module to import\n     *\n     * This factory function creates an [Angular NgModule](https://angular.io/docs/ts/latest/guide/ngmodule.html)\n     * with UI-Router support.\n     *\n     * The `forRoot` module should be added to the `imports:` of the `NgModule` being bootstrapped.\n     * An application should only create and import a single `NgModule` using `forRoot()`.\n     * All other modules should be created using [[UIRouterModule.forChild]].\n     *\n     * Unlike `forChild`, an `NgModule` returned by this factory provides the [[UIRouter]] singleton object.\n     * This factory also accepts root-level router configuration.\n     * These are the only differences between `forRoot` and `forChild`.\n     *\n     * Example:\n     * ```js\n     * let routerConfig = {\n     *   otherwise: '/home',\n     *   states: [homeState, aboutState]\n     * };\n     *\n     * @ NgModule({\n     *   imports: [\n     *     BrowserModule,\n     *     UIRouterModule.forRoot(routerConfig),\n     *     FeatureModule1\n     *   ]\n     * })\n     * class MyRootAppModule {}\n     *\n     * browserPlatformDynamic.bootstrapModule(MyRootAppModule);\n     * ```\n     *\n     * @param config declarative UI-Router configuration\n     * @returns an `NgModule` which provides the [[UIRouter]] singleton instance\n     */\n    UIRouterModule.forRoot = function (config) {\n        if (config === void 0) { config = {}; }\n        return {\n            ngModule: UIRouterModule_1,\n            providers: __spread([\n                _UIROUTER_INSTANCE_PROVIDERS,\n                _UIROUTER_SERVICE_PROVIDERS,\n                locationStrategy(config.useHash)\n            ], makeRootProviders(config)),\n        };\n    };\n    /**\n     * Creates an `NgModule` for a UIRouter module\n     *\n     * This function creates an [Angular NgModule](https://angular.io/docs/ts/latest/guide/ngmodule.html)\n     * with UI-Router support.\n     *\n     * #### Example:\n     * ```js\n     * var homeState = { name: 'home', url: '/home', component: Home };\n     * var aboutState = { name: 'about', url: '/about', component: About };\n     *\n     * @ NgModule({\n     *   imports: [\n     *     UIRouterModule.forChild({ states: [ homeState, aboutState ] }),\n     *     SharedModule,\n     *   ],\n     *   declarations: [ Home, About ],\n     * })\n     * export class AppModule {};\n     * ```\n     *\n     * @param module UI-Router module options\n     * @returns an `NgModule`\n     */\n    UIRouterModule.forChild = function (module) {\n        if (module === void 0) { module = {}; }\n        return {\n            ngModule: UIRouterModule_1,\n            providers: makeChildProviders(module),\n        };\n    };\n    var UIRouterModule_1;\n    UIRouterModule = UIRouterModule_1 = __decorate([\n        NgModule({\n            imports: [CommonModule],\n            declarations: [_UIROUTER_DIRECTIVES],\n            exports: [_UIROUTER_DIRECTIVES],\n            entryComponents: [UIView],\n        })\n    ], UIRouterModule);\n    return UIRouterModule;\n}());\n\n/** @ng2api @module core */\n/**\n * Returns a function which lazy loads a nested module\n *\n * This is primarily used by the [[ng2LazyLoadBuilder]] when processing [[Ng2StateDeclaration.loadChildren]].\n *\n * It could also be used manually as a [[StateDeclaration.lazyLoad]] property to lazy load an `NgModule` and its state(s).\n *\n * #### Example:\n * Using `import()` and named export of `HomeModule`\n * ```js\n * declare var System;\n * var futureState = {\n *   name: 'home.**',\n *   url: '/home',\n *   lazyLoad: loadNgModule(() => import('./home/home.module').then(result => result.HomeModule))\n * }\n * ```\n *\n * #### Example:\n * Using a path (string) to the module\n * ```js\n * var futureState = {\n *   name: 'home.**',\n *   url: '/home',\n *   lazyLoad: loadNgModule('./home/home.module#HomeModule')\n * }\n * ```\n *\n *\n * @param moduleToLoad a path (string) to the NgModule to load.\n *    Or a function which loads the NgModule code which should\n *    return a reference to  the `NgModule` class being loaded (or a `Promise` for it).\n *\n * @returns A function which takes a transition, which:\n * - Gets the Injector (scoped properly for the destination state)\n * - Loads and creates the NgModule\n * - Finds the \"replacement state\" for the target state, and adds the new NgModule Injector to it (as a resolve)\n * - Returns the new states array\n */\nfunction loadNgModule(moduleToLoad) {\n    return function (transition, stateObject) {\n        var ng2Injector = transition.injector().get(NATIVE_INJECTOR_TOKEN);\n        var createModule = function (factory) { return factory.create(ng2Injector); };\n        var applyModule = function (moduleRef) { return applyNgModule(transition, moduleRef, ng2Injector, stateObject); };\n        return loadModuleFactory(moduleToLoad, ng2Injector)\n            .then(createModule)\n            .then(applyModule);\n    };\n}\n/**\n * Returns the module factory that can be used to instantiate a module\n *\n * For strings this:\n * - Finds the correct NgModuleFactoryLoader\n * - Loads the new NgModuleFactory from the path string (async)\n *\n * For a Type<any> or Promise<Type<any>> this:\n * - Compiles the component type (if not running with AOT)\n * - Returns the NgModuleFactory resulting from compilation (or direct loading if using AOT) as a Promise\n *\n * @internalapi\n */\nfunction loadModuleFactory(moduleToLoad, ng2Injector) {\n    if (isString(moduleToLoad)) {\n        return ng2Injector.get(NgModuleFactoryLoader).load(moduleToLoad);\n    }\n    var compiler = ng2Injector.get(Compiler);\n    var unwrapEsModuleDefault = function (x) { return (x && x.__esModule && x['default'] ? x['default'] : x); };\n    return Promise.resolve(moduleToLoad())\n        .then(unwrapEsModuleDefault)\n        .then(function (t) {\n        if (t instanceof NgModuleFactory) {\n            return t;\n        }\n        return compiler.compileModuleAsync(t);\n    });\n}\n/**\n * Apply the UI-Router Modules found in the lazy loaded module.\n *\n * Apply the Lazy Loaded NgModule's newly created Injector to the right state in the state tree.\n *\n * Lazy loading uses a placeholder state which is removed (and replaced) after the module is loaded.\n * The NgModule should include a state with the same name as the placeholder.\n *\n * Find the *newly loaded state* with the same name as the *placeholder state*.\n * The NgModule's Injector (and ComponentFactoryResolver) will be added to that state.\n * The Injector/Factory are used when creating Components for the `replacement` state and all its children.\n *\n * @internalapi\n */\nfunction applyNgModule(transition, ng2Module, parentInjector, lazyLoadState) {\n    var injector = ng2Module.injector;\n    var uiRouter = injector.get(UIRouter);\n    var registry = uiRouter.stateRegistry;\n    var originalName = lazyLoadState.name;\n    var originalState = registry.get(originalName);\n    // Check if it's a future state (ends with .**)\n    var isFuture = /^(.*)\\.\\*\\*$/.exec(originalName);\n    // Final name (without the .**)\n    var replacementName = isFuture && isFuture[1];\n    var newRootModules = multiProviderParentChildDelta(parentInjector, injector, UIROUTER_ROOT_MODULE).reduce(uniqR, []);\n    var newChildModules = multiProviderParentChildDelta(parentInjector, injector, UIROUTER_MODULE_TOKEN).reduce(uniqR, []);\n    if (newRootModules.length) {\n        console.log(newRootModules); // tslint:disable-line:no-console\n        throw new Error('Lazy loaded modules should not contain a UIRouterModule.forRoot() module');\n    }\n    var newStateObjects = newChildModules\n        .map(function (module) { return applyModuleConfig(uiRouter, injector, module); })\n        .reduce(unnestR, [])\n        .reduce(uniqR, []);\n    if (isFuture) {\n        var replacementState = registry.get(replacementName);\n        if (!replacementState || replacementState === originalState) {\n            throw new Error(\"The Future State named '\" + originalName + \"' lazy loaded an NgModule. \" +\n                (\"The lazy loaded NgModule must have a state named '\" + replacementName + \"' \") +\n                (\"which replaces the (placeholder) '\" + originalName + \"' Future State. \") +\n                (\"Add a '\" + replacementName + \"' state to the lazy loaded NgModule \") +\n                \"using UIRouterModule.forChild({ states: CHILD_STATES }).\");\n        }\n    }\n    // Supply the newly loaded states with the Injector from the lazy loaded NgModule.\n    // If a tree of states is lazy loaded, only add the injector to the root of the lazy loaded tree.\n    // The children will get the injector by resolve inheritance.\n    var newParentStates = newStateObjects.filter(function (state) { return !inArray(newStateObjects, state.parent); });\n    // Add the Injector to the top of the lazy loaded state tree as a resolve\n    newParentStates.forEach(function (state) { return state.resolvables.push(Resolvable.fromData(NATIVE_INJECTOR_TOKEN, injector)); });\n    return {};\n}\n/**\n * Returns the new dependency injection values from the Child Injector\n *\n * When a DI token is defined as multi: true, the child injector\n * can add new values for the token.\n *\n * This function returns the values added by the child injector,  and excludes all values from the parent injector.\n *\n * @internalapi\n */\nfunction multiProviderParentChildDelta(parent, child, token) {\n    var childVals = child.get(token, []);\n    var parentVals = parent.get(token, []);\n    return childVals.filter(function (val) { return parentVals.indexOf(val) === -1; });\n}\n\n/**\n * This is a [[StateBuilder.builder]] function for ngModule lazy loading in Angular.\n *\n * When the [[StateBuilder]] builds a [[State]] object from a raw [[StateDeclaration]], this builder\n * decorates the `lazyLoad` property for states that have a [[Ng2StateDeclaration.ngModule]] declaration.\n *\n * If the state has a [[Ng2StateDeclaration.ngModule]], it will create a `lazyLoad` function\n * that in turn calls `loadNgModule(loadNgModuleFn)`.\n *\n * #### Example:\n * A state that has a `ngModule`\n * ```js\n * var decl = {\n *   ngModule: () => import('./childModule.ts')\n * }\n * ```\n * would build a state with a `lazyLoad` function like:\n * ```js\n * import { loadNgModule } from \"@uirouter/angular\";\n * var decl = {\n *   lazyLoad: loadNgModule(() => import('./childModule.ts')\n * }\n * ```\n *\n * If the state has both a `ngModule:` *and* a `lazyLoad`, then the `lazyLoad` is run first.\n *\n * #### Example:\n * ```js\n * var decl = {\n *   lazyLoad: () => import('third-party-library'),\n *   ngModule: () => import('./childModule.ts')\n * }\n * ```\n * would build a state with a `lazyLoad` function like:\n * ```js\n * import { loadNgModule } from \"@uirouter/angular\";\n * var decl = {\n *   lazyLoad: () => import('third-party-library')\n *       .then(() => loadNgModule(() => import('./childModule.ts'))\n * }\n * ```\n *\n */\nfunction ng2LazyLoadBuilder(state, parent) {\n    var loadNgModuleFn = state['loadChildren'];\n    return loadNgModuleFn ? loadNgModule(loadNgModuleFn) : state.lazyLoad;\n}\n\n/** A `LocationServices` that delegates to the Angular LocationStrategy */\nvar Ng2LocationServices = /** @class */ (function (_super) {\n    __extends(Ng2LocationServices, _super);\n    function Ng2LocationServices(router, _locationStrategy, isBrowser) {\n        var _this = _super.call(this, router, isBrowser) || this;\n        _this._locationStrategy = _locationStrategy;\n        _this._locationStrategy.onPopState(function (evt) {\n            if (evt.type !== 'hashchange') {\n                _this._listener(evt);\n            }\n        });\n        return _this;\n    }\n    Ng2LocationServices.prototype._get = function () {\n        return this._locationStrategy.path(true).replace(this._locationStrategy.getBaseHref().replace(/\\/$/, ''), '');\n    };\n    Ng2LocationServices.prototype._set = function (state, title, url, replace) {\n        var _a = parseUrl(url), path = _a.path, search = _a.search, hash = _a.hash;\n        var urlWithHash = path + (hash ? '#' + hash : '');\n        if (replace) {\n            this._locationStrategy.replaceState(state, title, urlWithHash, search);\n        }\n        else {\n            this._locationStrategy.pushState(state, title, urlWithHash, search);\n        }\n    };\n    Ng2LocationServices.prototype.dispose = function (router) {\n        _super.prototype.dispose.call(this, router);\n    };\n    return Ng2LocationServices;\n}(BaseLocationServices));\n\n/** @module ng2 */\nvar Ng2LocationConfig = /** @class */ (function (_super) {\n    __extends(Ng2LocationConfig, _super);\n    function Ng2LocationConfig(router, _locationStrategy) {\n        var _this = _super.call(this, router, is(PathLocationStrategy)(_locationStrategy)) || this;\n        _this._locationStrategy = _locationStrategy;\n        return _this;\n    }\n    Ng2LocationConfig.prototype.baseHref = function (href) {\n        return this._locationStrategy.getBaseHref();\n    };\n    return Ng2LocationConfig;\n}(BrowserLocationConfig));\n\n/**\n * # UI-Router for Angular (v2+)\n *\n * - [@uirouter/angular home page](https://ui-router.github.io/ng2)\n * - [tutorials](https://ui-router.github.io/tutorial/ng2/helloworld)\n * - [quick start repository](http://github.com/ui-router/quickstart-ng2)\n *\n * Getting started:\n *\n * - Use npm. Add a dependency on latest `@uirouter/angular`\n * - Import UI-Router classes directly from `\"@uirouter/angular\"`\n *\n * ```js\n * import {StateRegistry} from \"@uirouter/angular\";\n * ```\n *\n * - Create application states (as defined by [[Ng2StateDeclaration]]).\n *\n * ```js\n * export let state1: Ng2StateDeclaration = {\n *   name: 'state1',\n *   component: State1Component,\n *   url: '/one'\n * }\n *\n * export let state2: Ng2StateDeclaration = {\n *   name: 'state2',\n *   component: State2Component,\n *   url: '/two'\n * }\n * ```\n *\n * - Import a [[UIRouterModule.forChild]] module into your feature `NgModule`s.\n *\n * ```js\n * @ NgModule({\n *   imports: [\n *     SharedModule,\n *     UIRouterModule.forChild({ states: [state1, state2 ] })\n *   ],\n *   declarations: [\n *     State1Component,\n *     State2Component,\n *   ]\n * })\n * export class MyFeatureModule {}\n * ```\n *\n * - Import a [[UIRouterModule.forRoot]] module into your application root `NgModule`\n * - Either bootstrap a [[UIView]] component, or add a `<ui-view></ui-view>` viewport to your root component.\n *\n * ```js\n * @ NgModule({\n *   imports: [\n *     BrowserModule,\n *     UIRouterModule.forRoot({ states: [ homeState ] }),\n *     MyFeatureModule,\n *   ],\n *   declarations: [\n *     HomeComponent\n *   ]\n *   bootstrap: [ UIView ]\n * })\n * class RootAppModule {}\n *\n * browserPlatformDynamic.bootstrapModule(RootAppModule);\n * ```\n *\n * - Optionally specify a configuration class [[ChildModule.configClass]] for any module\n * to perform any router configuration during bootstrap or lazyload.\n * Pass the class to [[UIRouterModule.forRoot]] or [[UIRouterModule.forChild]].\n *\n * ```js\n * import {UIRouter} from \"@uirouter/angular\";\n *\n * @ Injectable()\n * export class MyUIRouterConfig {\n *   // Constructor is injectable\n *   constructor(uiRouter: UIRouter) {\n *     uiRouter.urlMatcherFactory.type('datetime', myDateTimeParamType);\n *   }\n * }\n * ```\n *\n * @preferred @module ng2\n */\n/**\n * This is a factory function for a UIRouter instance\n *\n * Creates a UIRouter instance and configures it for Angular, then invokes router bootstrap.\n * This function is used as an Angular `useFactory` Provider.\n */\nfunction uiRouterFactory(locationStrategy, rootModules, modules, injector) {\n    if (rootModules.length !== 1) {\n        throw new Error(\"Exactly one UIRouterModule.forRoot() should be in the bootstrapped app module's imports: []\");\n    }\n    // ----------------- Create router -----------------\n    // Create a new ng2 UIRouter and configure it for ng2\n    var router = new UIRouter();\n    // Add RxJS plugin\n    router.plugin(UIRouterRx);\n    // Add $q-like and $injector-like service APIs\n    router.plugin(servicesPlugin);\n    // ----------------- Monkey Patches ----------------\n    // Monkey patch the services.$injector to use the root ng2 Injector\n    services.$injector.get = injector.get.bind(injector);\n    // ----------------- Configure for ng2 -------------\n    router.locationService = new Ng2LocationServices(router, locationStrategy, isPlatformBrowser(injector.get(PLATFORM_ID)));\n    router.locationConfig = new Ng2LocationConfig(router, locationStrategy);\n    // Apply ng2 ui-view handling code\n    var viewConfigFactory = function (path, config) { return new Ng2ViewConfig(path, config); };\n    router.viewService._pluginapi._viewConfigFactory('ng2', viewConfigFactory);\n    // Apply statebuilder decorator for ng2 NgModule registration\n    var registry = router.stateRegistry;\n    registry.decorator('views', ng2ViewsBuilder);\n    registry.decorator('lazyLoad', ng2LazyLoadBuilder);\n    // Prep the tree of NgModule by placing the root NgModule's Injector on the root state.\n    var ng2InjectorResolvable = Resolvable.fromData(NATIVE_INJECTOR_TOKEN, injector);\n    registry.root().resolvables.push(ng2InjectorResolvable);\n    // Auto-flush the parameter type queue\n    router.urlMatcherFactory.$get();\n    // ----------------- Initialize router -------------\n    rootModules.forEach(function (moduleConfig) { return applyRootModuleConfig(router, injector, moduleConfig); });\n    modules.forEach(function (moduleConfig) { return applyModuleConfig(router, injector, moduleConfig); });\n    return router;\n}\n// Start monitoring the URL when the app starts\nfunction appInitializer(router) {\n    return function () {\n        if (!router.urlRouter.interceptDeferred) {\n            router.urlService.listen();\n            router.urlService.sync();\n        }\n    };\n}\nfunction parentUIViewInjectFactory(r) {\n    return { fqn: null, context: r.root() };\n}\nvar _UIROUTER_INSTANCE_PROVIDERS = [\n    {\n        provide: UIRouter,\n        useFactory: uiRouterFactory,\n        deps: [LocationStrategy, UIROUTER_ROOT_MODULE, UIROUTER_MODULE_TOKEN, Injector],\n    },\n    { provide: UIView.PARENT_INJECT, useFactory: parentUIViewInjectFactory, deps: [StateRegistry] },\n    { provide: APP_INITIALIZER, useFactory: appInitializer, deps: [UIRouter], multi: true },\n];\nfunction fnStateService(r) {\n    return r.stateService;\n}\nfunction fnTransitionService(r) {\n    return r.transitionService;\n}\nfunction fnUrlMatcherFactory(r) {\n    return r.urlMatcherFactory;\n}\nfunction fnUrlRouter(r) {\n    return r.urlRouter;\n}\nfunction fnUrlService(r) {\n    return r.urlService;\n}\nfunction fnViewService(r) {\n    return r.viewService;\n}\nfunction fnStateRegistry(r) {\n    return r.stateRegistry;\n}\nfunction fnGlobals(r) {\n    return r.globals;\n}\nvar _UIROUTER_SERVICE_PROVIDERS = [\n    { provide: StateService, useFactory: fnStateService, deps: [UIRouter] },\n    { provide: TransitionService, useFactory: fnTransitionService, deps: [UIRouter] },\n    { provide: UrlMatcherFactory, useFactory: fnUrlMatcherFactory, deps: [UIRouter] },\n    { provide: UrlRouter, useFactory: fnUrlRouter, deps: [UIRouter] },\n    { provide: UrlService, useFactory: fnUrlService, deps: [UIRouter] },\n    { provide: ViewService, useFactory: fnViewService, deps: [UIRouter] },\n    { provide: StateRegistry, useFactory: fnStateRegistry, deps: [UIRouter] },\n    { provide: UIRouterGlobals, useFactory: fnGlobals, deps: [UIRouter] },\n];\n/**\n * The UI-Router providers, for use in your application bootstrap\n *\n * @deprecated use [[UIRouterModule.forRoot]]\n */\nvar UIROUTER_PROVIDERS = _UIROUTER_INSTANCE_PROVIDERS.concat(_UIROUTER_SERVICE_PROVIDERS);\n\nexport { AnchorUISref, Ng2ViewConfig, UIROUTER_DIRECTIVES, UIROUTER_MODULE_TOKEN, UIROUTER_PROVIDERS, UIROUTER_ROOT_MODULE, UIROUTER_STATES, UIRouterModule, UISref, UISrefActive, UISrefStatus, UIView, _UIROUTER_DIRECTIVES, _UIROUTER_INSTANCE_PROVIDERS, _UIROUTER_SERVICE_PROVIDERS, appInitializer, applyModuleConfig, applyNgModule, applyRootModuleConfig, fnGlobals, fnStateRegistry, fnStateService, fnTransitionService, fnUrlMatcherFactory, fnUrlRouter, fnUrlService, fnViewService, loadModuleFactory, loadNgModule, locationStrategy, makeChildProviders, makeRootProviders, multiProviderParentChildDelta, ng2LazyLoadBuilder, ng2ViewsBuilder, onTransitionReady, parentUIViewInjectFactory, uiRouterFactory, \u02750 };\n"],
  "mappings": "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",
  "names": []
}