{
  "version": 3,
  "sources": ["../ui/web_modules/common/viewScroll-db255824.js", "../ui/web_modules/@uirouter/angularjs.js"],
  "sourcesContent": ["import { s as services, d as isDefined, p as pick, f as forEach, e as extend, V as ViewService, R as ResolveContext, t as trace, aG as isInjectable, aD as isArray, A as tail, m as Resolvable, l as isString, i as isFunction, u as unnestR, aC as isObject, aL as kebobString, I as createProxyFunctions, aw as val, K as removeFrom, bs as BaseUrlRule, h as identity, ae as applyPairs, U as UIRouter, H as noop, j as uniqR, c as inArray, a as parse, b as filter } from './interface-c1256a29.js';\nimport { n as ng_from_import } from './index-729b989c.js';\n\n/** @publicapi @module ng1 */ /** */\n/** @hidden */ var ng_from_global = angular;\n/** @hidden */ var ng = ng_from_import && undefined ? ng_from_import : ng_from_global;\n\n/** @internalapi */\nfunction getNg1ViewConfigFactory() {\n    var templateFactory = null;\n    return function (path, view) {\n        templateFactory = templateFactory || services.$injector.get('$templateFactory');\n        return [new Ng1ViewConfig(path, view, templateFactory)];\n    };\n}\n/** @internalapi */\nvar hasAnyKey = function (keys, obj) { return keys.reduce(function (acc, key) { return acc || isDefined(obj[key]); }, false); };\n/**\n * This is a [[StateBuilder.builder]] function for angular1 `views`.\n *\n * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder\n * handles the `views` property with logic specific to @uirouter/angularjs (ng1).\n *\n * If no `views: {}` property exists on the [[StateDeclaration]], then it creates the `views` object\n * and applies the state-level configuration to a view named `$default`.\n *\n * @internalapi\n */\nfunction ng1ViewsBuilder(state) {\n    // Do not process root state\n    if (!state.parent)\n        return {};\n    var tplKeys = ['templateProvider', 'templateUrl', 'template', 'notify', 'async'], ctrlKeys = ['controller', 'controllerProvider', 'controllerAs', 'resolveAs'], compKeys = ['component', 'bindings', 'componentProvider'], nonCompKeys = tplKeys.concat(ctrlKeys), allViewKeys = compKeys.concat(nonCompKeys);\n    // Do not allow a state to have both state-level props and also a `views: {}` property.\n    // A state without a `views: {}` property can declare properties for the `$default` view as properties of the state.\n    // However, the `$default` approach should not be mixed with a separate `views: ` block.\n    if (isDefined(state.views) && hasAnyKey(allViewKeys, state)) {\n        throw new Error(\"State '\" + state.name + \"' has a 'views' object. \" +\n            \"It cannot also have \\\"view properties\\\" at the state level.  \" +\n            \"Move the following properties into a view (in the 'views' object): \" +\n            (\" \" + allViewKeys.filter(function (key) { return isDefined(state[key]); }).join(', ')));\n    }\n    var views = {}, viewsObject = state.views || { $default: pick(state, allViewKeys) };\n    forEach(viewsObject, function (config, name) {\n        // Account for views: { \"\": { template... } }\n        name = name || '$default';\n        // Account for views: { header: \"headerComponent\" }\n        if (isString(config))\n            config = { component: config };\n        // Make a shallow copy of the config object\n        config = extend({}, config);\n        // Do not allow a view to mix props for component-style view with props for template/controller-style view\n        if (hasAnyKey(compKeys, config) && hasAnyKey(nonCompKeys, config)) {\n            throw new Error(\"Cannot combine: \" + compKeys.join('|') + \" with: \" + nonCompKeys.join('|') + \" in stateview: '\" + name + \"@\" + state.name + \"'\");\n        }\n        config.resolveAs = config.resolveAs || '$resolve';\n        config.$type = 'ng1';\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}\n/** @hidden */\nvar id = 0;\n/** @internalapi */\nvar Ng1ViewConfig = /** @class */ (function () {\n    function Ng1ViewConfig(path, viewDecl, factory) {\n        var _this = this;\n        this.path = path;\n        this.viewDecl = viewDecl;\n        this.factory = factory;\n        this.$id = id++;\n        this.loaded = false;\n        this.getTemplate = function (uiView, context) {\n            return _this.component\n                ? _this.factory.makeComponentTemplate(uiView, context, _this.component, _this.viewDecl.bindings)\n                : _this.template;\n        };\n    }\n    Ng1ViewConfig.prototype.load = function () {\n        var _this = this;\n        var $q = services.$q;\n        var context = new ResolveContext(this.path);\n        var params = this.path.reduce(function (acc, node) { return extend(acc, node.paramValues); }, {});\n        var promises = {\n            template: $q.when(this.factory.fromConfig(this.viewDecl, params, context)),\n            controller: $q.when(this.getController(context)),\n        };\n        return $q.all(promises).then(function (results) {\n            trace.traceViewServiceEvent('Loaded', _this);\n            _this.controller = results.controller;\n            extend(_this, results.template); // Either { template: \"tpl\" } or { component: \"cmpName\" }\n            return _this;\n        });\n    };\n    /**\n     * Gets the controller for a view configuration.\n     *\n     * @returns {Function|Promise.<Function>} Returns a controller, or a promise that resolves to a controller.\n     */\n    Ng1ViewConfig.prototype.getController = function (context) {\n        var provider = this.viewDecl.controllerProvider;\n        if (!isInjectable(provider))\n            return this.viewDecl.controller;\n        var deps = services.$injector.annotate(provider);\n        var providerFn = isArray(provider) ? tail(provider) : provider;\n        var resolvable = new Resolvable('', providerFn, deps);\n        return resolvable.get(context);\n    };\n    return Ng1ViewConfig;\n}());\n\n/** @publicapi @module view */ /** */\n/**\n * Service which manages loading of templates from a ViewConfig.\n */\nvar TemplateFactory = /** @class */ (function () {\n    function TemplateFactory() {\n        var _this = this;\n        /** @hidden */ this._useHttp = ng.version.minor < 3;\n        /** @hidden */ this.$get = [\n            '$http',\n            '$templateCache',\n            '$injector',\n            function ($http, $templateCache, $injector) {\n                _this.$templateRequest = $injector.has && $injector.has('$templateRequest') && $injector.get('$templateRequest');\n                _this.$http = $http;\n                _this.$templateCache = $templateCache;\n                return _this;\n            },\n        ];\n    }\n    /** @hidden */\n    TemplateFactory.prototype.useHttpService = function (value) {\n        this._useHttp = value;\n    };\n    /**\n     * Creates a template from a configuration object.\n     *\n     * @param config Configuration object for which to load a template.\n     * The following properties are search in the specified order, and the first one\n     * that is defined is used to create the template:\n     *\n     * @param params  Parameters to pass to the template function.\n     * @param context The resolve context associated with the template's view\n     *\n     * @return {string|object}  The template html as a string, or a promise for\n     * that string,or `null` if no template is configured.\n     */\n    TemplateFactory.prototype.fromConfig = function (config, params, context) {\n        var defaultTemplate = '<ui-view></ui-view>';\n        var asTemplate = function (result) { return services.$q.when(result).then(function (str) { return ({ template: str }); }); };\n        var asComponent = function (result) { return services.$q.when(result).then(function (str) { return ({ component: str }); }); };\n        return isDefined(config.template)\n            ? asTemplate(this.fromString(config.template, params))\n            : isDefined(config.templateUrl)\n                ? asTemplate(this.fromUrl(config.templateUrl, params))\n                : isDefined(config.templateProvider)\n                    ? asTemplate(this.fromProvider(config.templateProvider, params, context))\n                    : isDefined(config.component)\n                        ? asComponent(config.component)\n                        : isDefined(config.componentProvider)\n                            ? asComponent(this.fromComponentProvider(config.componentProvider, params, context))\n                            : asTemplate(defaultTemplate);\n    };\n    /**\n     * Creates a template from a string or a function returning a string.\n     *\n     * @param template html template as a string or function that returns an html template as a string.\n     * @param params Parameters to pass to the template function.\n     *\n     * @return {string|object} The template html as a string, or a promise for that\n     * string.\n     */\n    TemplateFactory.prototype.fromString = function (template, params) {\n        return isFunction(template) ? template(params) : template;\n    };\n    /**\n     * Loads a template from the a URL via `$http` and `$templateCache`.\n     *\n     * @param {string|Function} url url of the template to load, or a function\n     * that returns a url.\n     * @param {Object} params Parameters to pass to the url function.\n     * @return {string|Promise.<string>} The template html as a string, or a promise\n     * for that string.\n     */\n    TemplateFactory.prototype.fromUrl = function (url, params) {\n        if (isFunction(url))\n            url = url(params);\n        if (url == null)\n            return null;\n        if (this._useHttp) {\n            return this.$http\n                .get(url, { cache: this.$templateCache, headers: { Accept: 'text/html' } })\n                .then(function (response) {\n                return response.data;\n            });\n        }\n        return this.$templateRequest(url);\n    };\n    /**\n     * Creates a template by invoking an injectable provider function.\n     *\n     * @param provider Function to invoke via `locals`\n     * @param {Function} injectFn a function used to invoke the template provider\n     * @return {string|Promise.<string>} The template html as a string, or a promise\n     * for that string.\n     */\n    TemplateFactory.prototype.fromProvider = function (provider, params, context) {\n        var deps = services.$injector.annotate(provider);\n        var providerFn = isArray(provider) ? tail(provider) : provider;\n        var resolvable = new Resolvable('', providerFn, deps);\n        return resolvable.get(context);\n    };\n    /**\n     * Creates a component's template by invoking an injectable provider function.\n     *\n     * @param provider Function to invoke via `locals`\n     * @param {Function} injectFn a function used to invoke the template provider\n     * @return {string} The template html as a string: \"<component-name input1='::$resolve.foo'></component-name>\".\n     */\n    TemplateFactory.prototype.fromComponentProvider = function (provider, params, context) {\n        var deps = services.$injector.annotate(provider);\n        var providerFn = isArray(provider) ? tail(provider) : provider;\n        var resolvable = new Resolvable('', providerFn, deps);\n        return resolvable.get(context);\n    };\n    /**\n     * Creates a template from a component's name\n     *\n     * This implements route-to-component.\n     * It works by retrieving the component (directive) metadata from the injector.\n     * It analyses the component's bindings, then constructs a template that instantiates the component.\n     * The template wires input and output bindings to resolves or from the parent component.\n     *\n     * @param uiView {object} The parent ui-view (for binding outputs to callbacks)\n     * @param context The ResolveContext (for binding outputs to callbacks returned from resolves)\n     * @param component {string} Component's name in camel case.\n     * @param bindings An object defining the component's bindings: {foo: '<'}\n     * @return {string} The template as a string: \"<component-name input1='::$resolve.foo'></component-name>\".\n     */\n    TemplateFactory.prototype.makeComponentTemplate = function (uiView, context, component, bindings) {\n        bindings = bindings || {};\n        // Bind once prefix\n        var prefix = ng.version.minor >= 3 ? '::' : '';\n        // Convert to kebob name. Add x- prefix if the string starts with `x-` or `data-`\n        var kebob = function (camelCase) {\n            var kebobed = kebobString(camelCase);\n            return /^(x|data)-/.exec(kebobed) ? \"x-\" + kebobed : kebobed;\n        };\n        var attributeTpl = function (input) {\n            var name = input.name, type = input.type;\n            var attrName = kebob(name);\n            // If the ui-view has an attribute which matches a binding on the routed component\n            // then pass that attribute through to the routed component template.\n            // Prefer ui-view wired mappings to resolve data, unless the resolve was explicitly bound using `bindings:`\n            if (uiView.attr(attrName) && !bindings[name])\n                return attrName + \"='\" + uiView.attr(attrName) + \"'\";\n            var resolveName = bindings[name] || name;\n            // Pre-evaluate the expression for \"@\" bindings by enclosing in {{ }}\n            // some-attr=\"{{ ::$resolve.someResolveName }}\"\n            if (type === '@')\n                return attrName + \"='{{\" + prefix + \"$resolve.\" + resolveName + \"}}'\";\n            // Wire \"&\" callbacks to resolves that return a callback function\n            // Get the result of the resolve (should be a function) and annotate it to get its arguments.\n            // some-attr=\"$resolve.someResolveResultName(foo, bar)\"\n            if (type === '&') {\n                var res = context.getResolvable(resolveName);\n                var fn = res && res.data;\n                var args = (fn && services.$injector.annotate(fn)) || [];\n                // account for array style injection, i.e., ['foo', function(foo) {}]\n                var arrayIdxStr = isArray(fn) ? \"[\" + (fn.length - 1) + \"]\" : '';\n                return attrName + \"='$resolve.\" + resolveName + arrayIdxStr + \"(\" + args.join(',') + \")'\";\n            }\n            // some-attr=\"::$resolve.someResolveName\"\n            return attrName + \"='\" + prefix + \"$resolve.\" + resolveName + \"'\";\n        };\n        var attrs = getComponentBindings(component)\n            .map(attributeTpl)\n            .join(' ');\n        var kebobName = kebob(component);\n        return \"<\" + kebobName + \" \" + attrs + \"></\" + kebobName + \">\";\n    };\n    return TemplateFactory;\n}());\n// Gets all the directive(s)' inputs ('@', '=', and '<') and outputs ('&')\nfunction getComponentBindings(name) {\n    var cmpDefs = services.$injector.get(name + 'Directive'); // could be multiple\n    if (!cmpDefs || !cmpDefs.length)\n        throw new Error(\"Unable to find component named '\" + name + \"'\");\n    return cmpDefs.map(getBindings).reduce(unnestR, []);\n}\n// Given a directive definition, find its object input attributes\n// Use different properties, depending on the type of directive (component, bindToController, normal)\nvar getBindings = function (def) {\n    if (isObject(def.bindToController))\n        return scopeBindings(def.bindToController);\n    return scopeBindings(def.scope);\n};\n// for ng 1.2 style, process the scope: { input: \"=foo\" }\n// for ng 1.3 through ng 1.5, process the component's bindToController: { input: \"=foo\" } object\nvar scopeBindings = function (bindingsObj) {\n    return Object.keys(bindingsObj || {})\n        // [ 'input', [ '=foo', '=', 'foo' ] ]\n        .map(function (key) { return [key, /^([=<@&])[?]?(.*)/.exec(bindingsObj[key])]; })\n        // skip malformed values\n        .filter(function (tuple) { return isDefined(tuple) && isArray(tuple[1]); })\n        // { name: ('foo' || 'input'), type: '=' }\n        .map(function (tuple) { return ({ name: tuple[1][2] || tuple[0], type: tuple[1][1] }); });\n};\n\n/** @publicapi @module ng1 */ /** */\n/**\n * The Angular 1 `StateProvider`\n *\n * The `$stateProvider` works similar to Angular's v1 router, but it focuses purely\n * on state.\n *\n * A state corresponds to a \"place\" in the application in terms of the overall UI and\n * navigation. A state describes (via the controller / template / view properties) what\n * the UI looks like and does at that place.\n *\n * States often have things in common, and the primary way of factoring out these\n * commonalities in this model is via the state hierarchy, i.e. parent/child states aka\n * nested states.\n *\n * The `$stateProvider` provides interfaces to declare these states for your app.\n */\nvar StateProvider = /** @class */ (function () {\n    function StateProvider(stateRegistry, stateService) {\n        this.stateRegistry = stateRegistry;\n        this.stateService = stateService;\n        createProxyFunctions(val(StateProvider.prototype), this, val(this));\n    }\n    /**\n     * Decorates states when they are registered\n     *\n     * Allows you to extend (carefully) or override (at your own peril) the\n     * `stateBuilder` object used internally by [[StateRegistry]].\n     * This can be used to add custom functionality to ui-router,\n     * for example inferring templateUrl based on the state name.\n     *\n     * When passing only a name, it returns the current (original or decorated) builder\n     * function that matches `name`.\n     *\n     * The builder functions that can be decorated are listed below. Though not all\n     * necessarily have a good use case for decoration, that is up to you to decide.\n     *\n     * In addition, users can attach custom decorators, which will generate new\n     * properties within the state's internal definition. There is currently no clear\n     * use-case for this beyond accessing internal states (i.e. $state.$current),\n     * however, expect this to become increasingly relevant as we introduce additional\n     * meta-programming features.\n     *\n     * **Warning**: Decorators should not be interdependent because the order of\n     * execution of the builder functions in non-deterministic. Builder functions\n     * should only be dependent on the state definition object and super function.\n     *\n     *\n     * Existing builder functions and current return values:\n     *\n     * - **parent** `{object}` - returns the parent state object.\n     * - **data** `{object}` - returns state data, including any inherited data that is not\n     *   overridden by own values (if any).\n     * - **url** `{object}` - returns a {@link ui.router.util.type:UrlMatcher UrlMatcher}\n     *   or `null`.\n     * - **navigable** `{object}` - returns closest ancestor state that has a URL (aka is\n     *   navigable).\n     * - **params** `{object}` - returns an array of state params that are ensured to\n     *   be a super-set of parent's params.\n     * - **views** `{object}` - returns a views object where each key is an absolute view\n     *   name (i.e. \"viewName@stateName\") and each value is the config object\n     *   (template, controller) for the view. Even when you don't use the views object\n     *   explicitly on a state config, one is still created for you internally.\n     *   So by decorating this builder function you have access to decorating template\n     *   and controller properties.\n     * - **ownParams** `{object}` - returns an array of params that belong to the state,\n     *   not including any params defined by ancestor states.\n     * - **path** `{string}` - returns the full path from the root down to this state.\n     *   Needed for state activation.\n     * - **includes** `{object}` - returns an object that includes every state that\n     *   would pass a `$state.includes()` test.\n     *\n     * #### Example:\n     * Override the internal 'views' builder with a function that takes the state\n     * definition, and a reference to the internal function being overridden:\n     * ```js\n     * $stateProvider.decorator('views', function (state, parent) {\n     *   let result = {},\n     *       views = parent(state);\n     *\n     *   angular.forEach(views, function (config, name) {\n     *     let autoName = (state.name + '.' + name).replace('.', '/');\n     *     config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';\n     *     result[name] = config;\n     *   });\n     *   return result;\n     * });\n     *\n     * $stateProvider.state('home', {\n     *   views: {\n     *     'contact.list': { controller: 'ListController' },\n     *     'contact.item': { controller: 'ItemController' }\n     *   }\n     * });\n     * ```\n     *\n     *\n     * ```js\n     * // Auto-populates list and item views with /partials/home/contact/list.html,\n     * // and /partials/home/contact/item.html, respectively.\n     * $state.go('home');\n     * ```\n     *\n     * @param {string} name The name of the builder function to decorate.\n     * @param {object} func A function that is responsible for decorating the original\n     * builder function. The function receives two parameters:\n     *\n     *   - `{object}` - state - The state config object.\n     *   - `{object}` - super - The original builder function.\n     *\n     * @return {object} $stateProvider - $stateProvider instance\n     */\n    StateProvider.prototype.decorator = function (name, func) {\n        return this.stateRegistry.decorator(name, func) || this;\n    };\n    StateProvider.prototype.state = function (name, definition) {\n        if (isObject(name)) {\n            definition = name;\n        }\n        else {\n            definition.name = name;\n        }\n        this.stateRegistry.register(definition);\n        return this;\n    };\n    /**\n     * Registers an invalid state handler\n     *\n     * This is a passthrough to [[StateService.onInvalid]] for ng1.\n     */\n    StateProvider.prototype.onInvalid = function (callback) {\n        return this.stateService.onInvalid(callback);\n    };\n    return StateProvider;\n}());\n\n/** @publicapi @module ng1 */ /** */\n/**\n * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,\n * `onRetain` callback hooks on a [[Ng1StateDeclaration]].\n *\n * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder\n * ensures that those hooks are injectable for @uirouter/angularjs (ng1).\n *\n * @internalapi\n */\nvar getStateHookBuilder = function (hookName) {\n    return function stateHookBuilder(stateObject, parentFn) {\n        var hook = stateObject[hookName];\n        var pathname = hookName === 'onExit' ? 'from' : 'to';\n        function decoratedNg1Hook(trans, state) {\n            var resolveContext = new ResolveContext(trans.treeChanges(pathname));\n            var subContext = resolveContext.subContext(state.$$state());\n            var locals = extend(getLocals(subContext), { $state$: state, $transition$: trans });\n            return services.$injector.invoke(hook, this, locals);\n        }\n        return hook ? decoratedNg1Hook : undefined;\n    };\n};\n\n/** @publicapi @module ng1 */ /** */\n/**\n * Implements UI-Router LocationServices and LocationConfig using Angular 1's $location service\n * @internalapi\n */\nvar Ng1LocationServices = /** @class */ (function () {\n    function Ng1LocationServices($locationProvider) {\n        // .onChange() registry\n        this._urlListeners = [];\n        this.$locationProvider = $locationProvider;\n        var _lp = val($locationProvider);\n        createProxyFunctions(_lp, this, _lp, ['hashPrefix']);\n    }\n    /**\n     * Applys ng1-specific path parameter encoding\n     *\n     * The Angular 1 `$location` service is a bit weird.\n     * It doesn't allow slashes to be encoded/decoded bi-directionally.\n     *\n     * See the writeup at https://github.com/angular-ui/ui-router/issues/2598\n     *\n     * This code patches the `path` parameter type so it encoded/decodes slashes as ~2F\n     *\n     * @param router\n     */\n    Ng1LocationServices.monkeyPatchPathParameterType = function (router) {\n        var pathType = router.urlMatcherFactory.type('path');\n        pathType.encode = function (x) {\n            return x != null ? x.toString().replace(/(~|\\/)/g, function (m) { return ({ '~': '~~', '/': '~2F' }[m]); }) : x;\n        };\n        pathType.decode = function (x) {\n            return x != null ? x.toString().replace(/(~~|~2F)/g, function (m) { return ({ '~~': '~', '~2F': '/' }[m]); }) : x;\n        };\n    };\n    Ng1LocationServices.prototype.dispose = function () { };\n    Ng1LocationServices.prototype.onChange = function (callback) {\n        var _this = this;\n        this._urlListeners.push(callback);\n        return function () { return removeFrom(_this._urlListeners)(callback); };\n    };\n    Ng1LocationServices.prototype.html5Mode = function () {\n        var html5Mode = this.$locationProvider.html5Mode();\n        html5Mode = isObject(html5Mode) ? html5Mode.enabled : html5Mode;\n        return html5Mode && this.$sniffer.history;\n    };\n    Ng1LocationServices.prototype.baseHref = function () {\n        return this._baseHref || (this._baseHref = this.$browser.baseHref() || this.$window.location.pathname);\n    };\n    Ng1LocationServices.prototype.url = function (newUrl, replace, state) {\n        if (replace === void 0) { replace = false; }\n        if (isDefined(newUrl))\n            this.$location.url(newUrl);\n        if (replace)\n            this.$location.replace();\n        if (state)\n            this.$location.state(state);\n        return this.$location.url();\n    };\n    Ng1LocationServices.prototype._runtimeServices = function ($rootScope, $location, $sniffer, $browser, $window) {\n        var _this = this;\n        this.$location = $location;\n        this.$sniffer = $sniffer;\n        this.$browser = $browser;\n        this.$window = $window;\n        // Bind $locationChangeSuccess to the listeners registered in LocationService.onChange\n        $rootScope.$on('$locationChangeSuccess', function (evt) { return _this._urlListeners.forEach(function (fn) { return fn(evt); }); });\n        var _loc = val($location);\n        // Bind these LocationService functions to $location\n        createProxyFunctions(_loc, this, _loc, ['replace', 'path', 'search', 'hash']);\n        // Bind these LocationConfig functions to $location\n        createProxyFunctions(_loc, this, _loc, ['port', 'protocol', 'host']);\n    };\n    return Ng1LocationServices;\n}());\n\n/** @publicapi @module url */ /** */\n/**\n * Manages rules for client-side URL\n *\n * ### Deprecation warning:\n * This class is now considered to be an internal API\n * Use the [[UrlService]] instead.\n * For configuring URL rules, use the [[UrlRulesApi]] which can be found as [[UrlService.rules]].\n *\n * This class manages the router rules for what to do when the URL changes.\n *\n * This provider remains for backwards compatibility.\n *\n * @internalapi\n * @deprecated\n */\nvar UrlRouterProvider = /** @class */ (function () {\n    /** @hidden */\n    function UrlRouterProvider(/** @hidden */ router) {\n        this.router = router;\n    }\n    UrlRouterProvider.injectableHandler = function (router, handler) {\n        return function (match) { return services.$injector.invoke(handler, null, { $match: match, $stateParams: router.globals.params }); };\n    };\n    /** @hidden */\n    UrlRouterProvider.prototype.$get = function () {\n        var urlService = this.router.urlService;\n        this.router.urlRouter.update(true);\n        if (!urlService.interceptDeferred)\n            urlService.listen();\n        return this.router.urlRouter;\n    };\n    /**\n     * Registers a url handler function.\n     *\n     * Registers a low level url handler (a `rule`).\n     * A rule detects specific URL patterns and returns a redirect, or performs some action.\n     *\n     * If a rule returns a string, the URL is replaced with the string, and all rules are fired again.\n     *\n     * #### Example:\n     * ```js\n     * var app = angular.module('app', ['ui.router.router']);\n     *\n     * app.config(function ($urlRouterProvider) {\n     *   // Here's an example of how you might allow case insensitive urls\n     *   $urlRouterProvider.rule(function ($injector, $location) {\n     *     var path = $location.path(),\n     *         normalized = path.toLowerCase();\n     *\n     *     if (path !== normalized) {\n     *       return normalized;\n     *     }\n     *   });\n     * });\n     * ```\n     *\n     * @param ruleFn\n     * Handler function that takes `$injector` and `$location` services as arguments.\n     * You can use them to detect a url and return a different url as a string.\n     *\n     * @return [[UrlRouterProvider]] (`this`)\n     */\n    UrlRouterProvider.prototype.rule = function (ruleFn) {\n        var _this = this;\n        if (!isFunction(ruleFn))\n            throw new Error(\"'rule' must be a function\");\n        var match = function () { return ruleFn(services.$injector, _this.router.locationService); };\n        var rule = new BaseUrlRule(match, identity);\n        this.router.urlService.rules.rule(rule);\n        return this;\n    };\n    /**\n     * Defines the path or behavior to use when no url can be matched.\n     *\n     * #### Example:\n     * ```js\n     * var app = angular.module('app', ['ui.router.router']);\n     *\n     * app.config(function ($urlRouterProvider) {\n     *   // if the path doesn't match any of the urls you configured\n     *   // otherwise will take care of routing the user to the\n     *   // specified url\n     *   $urlRouterProvider.otherwise('/index');\n     *\n     *   // Example of using function rule as param\n     *   $urlRouterProvider.otherwise(function ($injector, $location) {\n     *     return '/a/valid/url';\n     *   });\n     * });\n     * ```\n     *\n     * @param rule\n     * The url path you want to redirect to or a function rule that returns the url path or performs a `$state.go()`.\n     * The function version is passed two params: `$injector` and `$location` services, and should return a url string.\n     *\n     * @return {object} `$urlRouterProvider` - `$urlRouterProvider` instance\n     */\n    UrlRouterProvider.prototype.otherwise = function (rule) {\n        var _this = this;\n        var urlRules = this.router.urlService.rules;\n        if (isString(rule)) {\n            urlRules.otherwise(rule);\n        }\n        else if (isFunction(rule)) {\n            urlRules.otherwise(function () { return rule(services.$injector, _this.router.locationService); });\n        }\n        else {\n            throw new Error(\"'rule' must be a string or function\");\n        }\n        return this;\n    };\n    /**\n     * Registers a handler for a given url matching.\n     *\n     * If the handler is a string, it is\n     * treated as a redirect, and is interpolated according to the syntax of match\n     * (i.e. like `String.replace()` for `RegExp`, or like a `UrlMatcher` pattern otherwise).\n     *\n     * If the handler is a function, it is injectable.\n     * It gets invoked if `$location` matches.\n     * You have the option of inject the match object as `$match`.\n     *\n     * The handler can return\n     *\n     * - **falsy** to indicate that the rule didn't match after all, then `$urlRouter`\n     *   will continue trying to find another one that matches.\n     * - **string** which is treated as a redirect and passed to `$location.url()`\n     * - **void** or any **truthy** value tells `$urlRouter` that the url was handled.\n     *\n     * #### Example:\n     * ```js\n     * var app = angular.module('app', ['ui.router.router']);\n     *\n     * app.config(function ($urlRouterProvider) {\n     *   $urlRouterProvider.when($state.url, function ($match, $stateParams) {\n     *     if ($state.$current.navigable !== state ||\n     *         !equalForKeys($match, $stateParams) {\n     *      $state.transitionTo(state, $match, false);\n     *     }\n     *   });\n     * });\n     * ```\n     *\n     * @param what A pattern string to match, compiled as a [[UrlMatcher]].\n     * @param handler The path (or function that returns a path) that you want to redirect your user to.\n     * @param ruleCallback [optional] A callback that receives the `rule` registered with [[UrlMatcher.rule]]\n     *\n     * Note: the handler may also invoke arbitrary code, such as `$state.go()`\n     */\n    UrlRouterProvider.prototype.when = function (what, handler) {\n        if (isArray(handler) || isFunction(handler)) {\n            handler = UrlRouterProvider.injectableHandler(this.router, handler);\n        }\n        this.router.urlService.rules.when(what, handler);\n        return this;\n    };\n    /**\n     * Disables monitoring of the URL.\n     *\n     * Call this method before UI-Router has bootstrapped.\n     * It will stop UI-Router from performing the initial url sync.\n     *\n     * This can be useful to perform some asynchronous initialization before the router starts.\n     * Once the initialization is complete, call [[listen]] to tell UI-Router to start watching and synchronizing the URL.\n     *\n     * #### Example:\n     * ```js\n     * var app = angular.module('app', ['ui.router']);\n     *\n     * app.config(function ($urlRouterProvider) {\n     *   // Prevent $urlRouter from automatically intercepting URL changes;\n     *   $urlRouterProvider.deferIntercept();\n     * })\n     *\n     * app.run(function (MyService, $urlRouter, $http) {\n     *   $http.get(\"/stuff\").then(function(resp) {\n     *     MyService.doStuff(resp.data);\n     *     $urlRouter.listen();\n     *     $urlRouter.sync();\n     *   });\n     * });\n     * ```\n     *\n     * @param defer Indicates whether to defer location change interception.\n     *        Passing no parameter is equivalent to `true`.\n     */\n    UrlRouterProvider.prototype.deferIntercept = function (defer) {\n        this.router.urlService.deferIntercept(defer);\n    };\n    return UrlRouterProvider;\n}());\n\n/**\n * # Angular 1 types\n *\n * UI-Router core provides various Typescript types which you can use for code completion and validating parameter values, etc.\n * The customizations to the core types for Angular UI-Router are documented here.\n *\n * The optional [[$resolve]] service is also documented here.\n *\n * @preferred @publicapi @module ng1\n */ /** */\nng.module('ui.router.angular1', []);\nvar mod_init = ng.module('ui.router.init', ['ng']);\nvar mod_util = ng.module('ui.router.util', ['ui.router.init']);\nvar mod_rtr = ng.module('ui.router.router', ['ui.router.util']);\nvar mod_state = ng.module('ui.router.state', ['ui.router.router', 'ui.router.util', 'ui.router.angular1']);\nvar mod_main = ng.module('ui.router', ['ui.router.init', 'ui.router.state', 'ui.router.angular1']);\nvar mod_cmpt = ng.module('ui.router.compat', ['ui.router']); // tslint:disable-line\nvar router = null;\n$uiRouterProvider.$inject = ['$locationProvider'];\n/** This angular 1 provider instantiates a Router and exposes its services via the angular injector */\nfunction $uiRouterProvider($locationProvider) {\n    // Create a new instance of the Router when the $uiRouterProvider is initialized\n    router = this.router = new UIRouter();\n    router.stateProvider = new StateProvider(router.stateRegistry, router.stateService);\n    // Apply ng1 specific StateBuilder code for `views`, `resolve`, and `onExit/Retain/Enter` properties\n    router.stateRegistry.decorator('views', ng1ViewsBuilder);\n    router.stateRegistry.decorator('onExit', getStateHookBuilder('onExit'));\n    router.stateRegistry.decorator('onRetain', getStateHookBuilder('onRetain'));\n    router.stateRegistry.decorator('onEnter', getStateHookBuilder('onEnter'));\n    router.viewService._pluginapi._viewConfigFactory('ng1', getNg1ViewConfigFactory());\n    var ng1LocationService = (router.locationService = router.locationConfig = new Ng1LocationServices($locationProvider));\n    Ng1LocationServices.monkeyPatchPathParameterType(router);\n    // backwards compat: also expose router instance as $uiRouterProvider.router\n    router['router'] = router;\n    router['$get'] = $get;\n    $get.$inject = ['$location', '$browser', '$window', '$sniffer', '$rootScope', '$http', '$templateCache'];\n    function $get($location, $browser, $window, $sniffer, $rootScope, $http, $templateCache) {\n        ng1LocationService._runtimeServices($rootScope, $location, $sniffer, $browser, $window);\n        delete router['router'];\n        delete router['$get'];\n        return router;\n    }\n    return router;\n}\nvar getProviderFor = function (serviceName) { return [\n    '$uiRouterProvider',\n    function ($urp) {\n        var service = $urp.router[serviceName];\n        service['$get'] = function () { return service; };\n        return service;\n    },\n]; };\n// This effectively calls $get() on `$uiRouterProvider` to trigger init (when ng enters runtime)\nrunBlock.$inject = ['$injector', '$q', '$uiRouter'];\nfunction runBlock($injector, $q, $uiRouter) {\n    services.$injector = $injector;\n    services.$q = $q;\n    // https://github.com/angular-ui/ui-router/issues/3678\n    if (!$injector.hasOwnProperty('strictDi')) {\n        try {\n            $injector.invoke(function (checkStrictDi) { });\n        }\n        catch (error) {\n            $injector.strictDi = !!/strict mode/.exec(error && error.toString());\n        }\n    }\n    // The $injector is now available.\n    // Find any resolvables that had dependency annotation deferred\n    $uiRouter.stateRegistry\n        .get()\n        .map(function (x) { return x.$$state().resolvables; })\n        .reduce(unnestR, [])\n        .filter(function (x) { return x.deps === 'deferred'; })\n        .forEach(function (resolvable) { return (resolvable.deps = $injector.annotate(resolvable.resolveFn, $injector.strictDi)); });\n}\n// $urlRouter service and $urlRouterProvider\nvar getUrlRouterProvider = function (uiRouter) { return (uiRouter.urlRouterProvider = new UrlRouterProvider(uiRouter)); };\n// $state service and $stateProvider\n// $urlRouter service and $urlRouterProvider\nvar getStateProvider = function () { return extend(router.stateProvider, { $get: function () { return router.stateService; } }); };\nwatchDigests.$inject = ['$rootScope'];\nfunction watchDigests($rootScope) {\n    $rootScope.$watch(function () {\n        trace.approximateDigests++;\n    });\n}\nmod_init.provider('$uiRouter', $uiRouterProvider);\nmod_rtr.provider('$urlRouter', ['$uiRouterProvider', getUrlRouterProvider]);\nmod_util.provider('$urlService', getProviderFor('urlService'));\nmod_util.provider('$urlMatcherFactory', ['$uiRouterProvider', function () { return router.urlMatcherFactory; }]);\nmod_util.provider('$templateFactory', function () { return new TemplateFactory(); });\nmod_state.provider('$stateRegistry', getProviderFor('stateRegistry'));\nmod_state.provider('$uiRouterGlobals', getProviderFor('globals'));\nmod_state.provider('$transitions', getProviderFor('transitionService'));\nmod_state.provider('$state', ['$uiRouterProvider', getStateProvider]);\nmod_state.factory('$stateParams', ['$uiRouter', function ($uiRouter) { return $uiRouter.globals.params; }]);\nmod_main.factory('$view', function () { return router.viewService; });\nmod_main.service('$trace', function () { return trace; });\nmod_main.run(watchDigests);\nmod_util.run(['$urlMatcherFactory', function ($urlMatcherFactory) { }]);\nmod_state.run(['$state', function ($state) { }]);\nmod_rtr.run(['$urlRouter', function ($urlRouter) { }]);\nmod_init.run(runBlock);\n/** @hidden TODO: find a place to move this */\nvar getLocals = function (ctx) {\n    var tokens = ctx.getTokens().filter(isString);\n    var tuples = tokens.map(function (key) {\n        var resolvable = ctx.getResolvable(key);\n        var waitPolicy = ctx.getPolicy(resolvable).async;\n        return [key, waitPolicy === 'NOWAIT' ? resolvable.promise : resolvable.data];\n    });\n    return tuples.reduce(applyPairs, {});\n};\n\n/**\n * # Angular 1 Directives\n *\n * These are the directives included in UI-Router for Angular 1.\n * These directives are used in templates to create viewports and link/navigate to states.\n *\n * @preferred @publicapi @module directives\n */ /** */\n/** @hidden */\nfunction parseStateRef(ref) {\n    var parsed;\n    var paramsOnly = ref.match(/^\\s*({[^}]*})\\s*$/);\n    if (paramsOnly)\n        ref = '(' + paramsOnly[1] + ')';\n    parsed = ref.replace(/\\n/g, ' ').match(/^\\s*([^(]*?)\\s*(\\((.*)\\))?\\s*$/);\n    if (!parsed || parsed.length !== 4)\n        throw new Error(\"Invalid state ref '\" + ref + \"'\");\n    return { state: parsed[1] || null, paramExpr: parsed[3] || null };\n}\n/** @hidden */\nfunction stateContext(el) {\n    var $uiView = el.parent().inheritedData('$uiView');\n    var path = parse('$cfg.path')($uiView);\n    return path ? tail(path).state.name : undefined;\n}\n/** @hidden */\nfunction processedDef($state, $element, def) {\n    var uiState = def.uiState || $state.current.name;\n    var uiStateOpts = extend(defaultOpts($element, $state), def.uiStateOpts || {});\n    var href = $state.href(uiState, def.uiStateParams, uiStateOpts);\n    return { uiState: uiState, uiStateParams: def.uiStateParams, uiStateOpts: uiStateOpts, href: href };\n}\n/** @hidden */\nfunction getTypeInfo(el) {\n    // SVGAElement does not use the href attribute, but rather the 'xlinkHref' attribute.\n    var isSvg = Object.prototype.toString.call(el.prop('href')) === '[object SVGAnimatedString]';\n    var isForm = el[0].nodeName === 'FORM';\n    return {\n        attr: isForm ? 'action' : isSvg ? 'xlink:href' : 'href',\n        isAnchor: el.prop('tagName').toUpperCase() === 'A',\n        clickable: !isForm,\n    };\n}\n/** @hidden */\nfunction clickHook(el, $state, $timeout, type, getDef) {\n    return function (e) {\n        var button = e.which || e.button, target = getDef();\n        if (!(button > 1 || e.ctrlKey || e.metaKey || e.shiftKey || el.attr('target'))) {\n            // HACK: This is to allow ng-clicks to be processed before the transition is initiated:\n            var transition_1 = $timeout(function () {\n                if (!el.attr('disabled')) {\n                    $state.go(target.uiState, target.uiStateParams, target.uiStateOpts);\n                }\n            });\n            e.preventDefault();\n            // if the state has no URL, ignore one preventDefault from the <a> directive.\n            var ignorePreventDefaultCount_1 = type.isAnchor && !target.href ? 1 : 0;\n            e.preventDefault = function () {\n                if (ignorePreventDefaultCount_1-- <= 0)\n                    $timeout.cancel(transition_1);\n            };\n        }\n    };\n}\n/** @hidden */\nfunction defaultOpts(el, $state) {\n    return {\n        relative: stateContext(el) || $state.$current,\n        inherit: true,\n        source: 'sref',\n    };\n}\n/** @hidden */\nfunction bindEvents(element, scope, hookFn, uiStateOpts) {\n    var events;\n    if (uiStateOpts) {\n        events = uiStateOpts.events;\n    }\n    if (!isArray(events)) {\n        events = ['click'];\n    }\n    var on = element.on ? 'on' : 'bind';\n    for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {\n        var event_1 = events_1[_i];\n        element[on](event_1, hookFn);\n    }\n    scope.$on('$destroy', function () {\n        var off = element.off ? 'off' : 'unbind';\n        for (var _i = 0, events_2 = events; _i < events_2.length; _i++) {\n            var event_2 = events_2[_i];\n            element[off](event_2, hookFn);\n        }\n    });\n}\n/**\n * `ui-sref`: A directive for linking to a state\n *\n * A directive which links to a state (and optionally, parameters).\n * When clicked, this directive activates the linked state with the supplied parameter values.\n *\n * ### Linked State\n * The attribute value of the `ui-sref` is the name of the state to link to.\n *\n * #### Example:\n * This will activate the `home` state when the link is clicked.\n * ```html\n * <a ui-sref=\"home\">Home</a>\n * ```\n *\n * ### Relative Links\n * You can also use relative state paths within `ui-sref`, just like a relative path passed to `$state.go()` ([[StateService.go]]).\n * You just need to be aware that the path is relative to the state that *created* the link.\n * This allows a state to create a relative `ui-sref` which always targets the same destination.\n *\n * #### Example:\n * Both these links are relative to the parent state, even when a child state is currently active.\n * ```html\n * <a ui-sref=\".child1\">child 1 state</a>\n * <a ui-sref=\".child2\">child 2 state</a>\n * ```\n *\n * This link activates the parent state.\n * ```html\n * <a ui-sref=\"^\">Return</a>\n * ```\n *\n * ### hrefs\n * If the linked state has a URL, the directive will automatically generate and\n * update the `href` attribute (using the [[StateService.href]]  method).\n *\n * #### Example:\n * Assuming the `users` state has a url of `/users/`\n * ```html\n * <a ui-sref=\"users\" href=\"/users/\">Users</a>\n * ```\n *\n * ### Parameter Values\n * In addition to the state name, a `ui-sref` can include parameter values which are applied when activating the state.\n * Param values can be provided in the `ui-sref` value after the state name, enclosed by parentheses.\n * The content inside the parentheses is an expression, evaluated to the parameter values.\n *\n * #### Example:\n * This example renders a list of links to users.\n * The state's `userId` parameter value comes from each user's `user.id` property.\n * ```html\n * <li ng-repeat=\"user in users\">\n *   <a ui-sref=\"users.detail({ userId: user.id })\">{{ user.displayName }}</a>\n * </li>\n * ```\n *\n * Note:\n * The parameter values expression is `$watch`ed for updates.\n *\n * ### Transition Options\n * You can specify [[TransitionOptions]] to pass to [[StateService.go]] by using the `ui-sref-opts` attribute.\n * Options are restricted to `location`, `inherit`, and `reload`.\n *\n * #### Example:\n * ```html\n * <a ui-sref=\"home\" ui-sref-opts=\"{ reload: true }\">Home</a>\n * ```\n *\n * ### Other DOM Events\n *\n * You can also customize which DOM events to respond to (instead of `click`) by\n * providing an `events` array in the `ui-sref-opts` attribute.\n *\n * #### Example:\n * ```html\n * <input type=\"text\" ui-sref=\"contacts\" ui-sref-opts=\"{ events: ['change', 'blur'] }\">\n * ```\n *\n * ### Highlighting the active link\n * This directive can be used in conjunction with [[uiSrefActive]] to highlight the active link.\n *\n * ### Examples\n * If you have the following template:\n *\n * ```html\n * <a ui-sref=\"home\">Home</a>\n * <a ui-sref=\"about\">About</a>\n * <a ui-sref=\"{page: 2}\">Next page</a>\n *\n * <ul>\n *     <li ng-repeat=\"contact in contacts\">\n *         <a ui-sref=\"contacts.detail({ id: contact.id })\">{{ contact.name }}</a>\n *     </li>\n * </ul>\n * ```\n *\n * Then (assuming the current state is `contacts`) the rendered html including hrefs would be:\n *\n * ```html\n * <a href=\"#/home\" ui-sref=\"home\">Home</a>\n * <a href=\"#/about\" ui-sref=\"about\">About</a>\n * <a href=\"#/contacts?page=2\" ui-sref=\"{page: 2}\">Next page</a>\n *\n * <ul>\n *     <li ng-repeat=\"contact in contacts\">\n *         <a href=\"#/contacts/1\" ui-sref=\"contacts.detail({ id: contact.id })\">Joe</a>\n *     </li>\n *     <li ng-repeat=\"contact in contacts\">\n *         <a href=\"#/contacts/2\" ui-sref=\"contacts.detail({ id: contact.id })\">Alice</a>\n *     </li>\n *     <li ng-repeat=\"contact in contacts\">\n *         <a href=\"#/contacts/3\" ui-sref=\"contacts.detail({ id: contact.id })\">Bob</a>\n *     </li>\n * </ul>\n *\n * <a href=\"#/home\" ui-sref=\"home\" ui-sref-opts=\"{reload: true}\">Home</a>\n * ```\n *\n * ### Notes\n *\n * - You can use `ui-sref` to change **only the parameter values** by omitting the state name and parentheses.\n * #### Example:\n * Sets the `lang` parameter to `en` and remains on the same state.\n *\n * ```html\n * <a ui-sref=\"{ lang: 'en' }\">English</a>\n * ```\n *\n * - A middle-click, right-click, or ctrl-click is handled (natively) by the browser to open the href in a new window, for example.\n *\n * - Unlike the parameter values expression, the state name is not `$watch`ed (for performance reasons).\n * If you need to dynamically update the state being linked to, use the fully dynamic [[uiState]] directive.\n */\nvar uiSrefDirective;\nuiSrefDirective = [\n    '$uiRouter',\n    '$timeout',\n    function $StateRefDirective($uiRouter, $timeout) {\n        var $state = $uiRouter.stateService;\n        return {\n            restrict: 'A',\n            require: ['?^uiSrefActive', '?^uiSrefActiveEq'],\n            link: function (scope, element, attrs, uiSrefActive) {\n                var type = getTypeInfo(element);\n                var active = uiSrefActive[1] || uiSrefActive[0];\n                var unlinkInfoFn = null;\n                var hookFn;\n                var rawDef = {};\n                var getDef = function () { return processedDef($state, element, rawDef); };\n                var ref = parseStateRef(attrs.uiSref);\n                rawDef.uiState = ref.state;\n                rawDef.uiStateOpts = attrs.uiSrefOpts ? scope.$eval(attrs.uiSrefOpts) : {};\n                function update() {\n                    var def = getDef();\n                    if (unlinkInfoFn)\n                        unlinkInfoFn();\n                    if (active)\n                        unlinkInfoFn = active.$$addStateInfo(def.uiState, def.uiStateParams);\n                    if (def.href != null)\n                        attrs.$set(type.attr, def.href);\n                }\n                if (ref.paramExpr) {\n                    scope.$watch(ref.paramExpr, function (val) {\n                        rawDef.uiStateParams = extend({}, val);\n                        update();\n                    }, true);\n                    rawDef.uiStateParams = extend({}, scope.$eval(ref.paramExpr));\n                }\n                update();\n                scope.$on('$destroy', $uiRouter.stateRegistry.onStatesChanged(update));\n                scope.$on('$destroy', $uiRouter.transitionService.onSuccess({}, update));\n                if (!type.clickable)\n                    return;\n                hookFn = clickHook(element, $state, $timeout, type, getDef);\n                bindEvents(element, scope, hookFn, rawDef.uiStateOpts);\n            },\n        };\n    },\n];\n/**\n * `ui-state`: A fully dynamic directive for linking to a state\n *\n * A directive which links to a state (and optionally, parameters).\n * When clicked, this directive activates the linked state with the supplied parameter values.\n *\n * **This directive is very similar to [[uiSref]], but it `$observe`s and `$watch`es/evaluates all its inputs.**\n *\n * A directive which links to a state (and optionally, parameters).\n * When clicked, this directive activates the linked state with the supplied parameter values.\n *\n * ### Linked State\n * The attribute value of `ui-state` is an expression which is `$watch`ed and evaluated as the state to link to.\n * **This is in contrast with `ui-sref`, which takes a state name as a string literal.**\n *\n * #### Example:\n * Create a list of links.\n * ```html\n * <li ng-repeat=\"link in navlinks\">\n *   <a ui-state=\"link.state\">{{ link.displayName }}</a>\n * </li>\n * ```\n *\n * ### Relative Links\n * If the expression evaluates to a relative path, it is processed like [[uiSref]].\n * You just need to be aware that the path is relative to the state that *created* the link.\n * This allows a state to create relative `ui-state` which always targets the same destination.\n *\n * ### hrefs\n * If the linked state has a URL, the directive will automatically generate and\n * update the `href` attribute (using the [[StateService.href]]  method).\n *\n * ### Parameter Values\n * In addition to the state name expression, a `ui-state` can include parameter values which are applied when activating the state.\n * Param values should be provided using the `ui-state-params` attribute.\n * The `ui-state-params` attribute value is `$watch`ed and evaluated as an expression.\n *\n * #### Example:\n * This example renders a list of links with param values.\n * The state's `userId` parameter value comes from each user's `user.id` property.\n * ```html\n * <li ng-repeat=\"link in navlinks\">\n *   <a ui-state=\"link.state\" ui-state-params=\"link.params\">{{ link.displayName }}</a>\n * </li>\n * ```\n *\n * ### Transition Options\n * You can specify [[TransitionOptions]] to pass to [[StateService.go]] by using the `ui-state-opts` attribute.\n * Options are restricted to `location`, `inherit`, and `reload`.\n * The value of the `ui-state-opts` is `$watch`ed and evaluated as an expression.\n *\n * #### Example:\n * ```html\n * <a ui-state=\"returnto.state\" ui-state-opts=\"{ reload: true }\">Home</a>\n * ```\n *\n * ### Other DOM Events\n *\n * You can also customize which DOM events to respond to (instead of `click`) by\n * providing an `events` array in the `ui-state-opts` attribute.\n *\n * #### Example:\n * ```html\n * <input type=\"text\" ui-state=\"contacts\" ui-state-opts=\"{ events: ['change', 'blur'] }\">\n * ```\n *\n * ### Highlighting the active link\n * This directive can be used in conjunction with [[uiSrefActive]] to highlight the active link.\n *\n * ### Notes\n *\n * - You can use `ui-params` to change **only the parameter values** by omitting the state name and supplying only `ui-state-params`.\n *   However, it might be simpler to use [[uiSref]] parameter-only links.\n *\n * #### Example:\n * Sets the `lang` parameter to `en` and remains on the same state.\n *\n * ```html\n * <a ui-state=\"\" ui-state-params=\"{ lang: 'en' }\">English</a>\n * ```\n *\n * - A middle-click, right-click, or ctrl-click is handled (natively) by the browser to open the href in a new window, for example.\n * ```\n */\nvar uiStateDirective;\nuiStateDirective = [\n    '$uiRouter',\n    '$timeout',\n    function $StateRefDynamicDirective($uiRouter, $timeout) {\n        var $state = $uiRouter.stateService;\n        return {\n            restrict: 'A',\n            require: ['?^uiSrefActive', '?^uiSrefActiveEq'],\n            link: function (scope, element, attrs, uiSrefActive) {\n                var type = getTypeInfo(element);\n                var active = uiSrefActive[1] || uiSrefActive[0];\n                var unlinkInfoFn = null;\n                var hookFn;\n                var rawDef = {};\n                var getDef = function () { return processedDef($state, element, rawDef); };\n                var inputAttrs = ['uiState', 'uiStateParams', 'uiStateOpts'];\n                var watchDeregFns = inputAttrs.reduce(function (acc, attr) { return ((acc[attr] = noop), acc); }, {});\n                function update() {\n                    var def = getDef();\n                    if (unlinkInfoFn)\n                        unlinkInfoFn();\n                    if (active)\n                        unlinkInfoFn = active.$$addStateInfo(def.uiState, def.uiStateParams);\n                    if (def.href != null)\n                        attrs.$set(type.attr, def.href);\n                }\n                inputAttrs.forEach(function (field) {\n                    rawDef[field] = attrs[field] ? scope.$eval(attrs[field]) : null;\n                    attrs.$observe(field, function (expr) {\n                        watchDeregFns[field]();\n                        watchDeregFns[field] = scope.$watch(expr, function (newval) {\n                            rawDef[field] = newval;\n                            update();\n                        }, true);\n                    });\n                });\n                update();\n                scope.$on('$destroy', $uiRouter.stateRegistry.onStatesChanged(update));\n                scope.$on('$destroy', $uiRouter.transitionService.onSuccess({}, update));\n                if (!type.clickable)\n                    return;\n                hookFn = clickHook(element, $state, $timeout, type, getDef);\n                bindEvents(element, scope, hookFn, rawDef.uiStateOpts);\n            },\n        };\n    },\n];\n/**\n * `ui-sref-active` and `ui-sref-active-eq`: A directive that adds a CSS class when a `ui-sref` is active\n *\n * A directive working alongside [[uiSref]] and [[uiState]] to add classes to an element when the\n * related directive's state is active (and remove them when it is inactive).\n *\n * The primary use-case is to highlight the active link in navigation menus,\n * distinguishing it from the inactive menu items.\n *\n * ### Linking to a `ui-sref` or `ui-state`\n * `ui-sref-active` can live on the same element as `ui-sref`/`ui-state`, or it can be on a parent element.\n * If a `ui-sref-active` is a parent to more than one `ui-sref`/`ui-state`, it will apply the CSS class when **any of the links are active**.\n *\n * ### Matching\n *\n * The `ui-sref-active` directive applies the CSS class when the `ui-sref`/`ui-state`'s target state **or any child state is active**.\n * This is a \"fuzzy match\" which uses [[StateService.includes]].\n *\n * The `ui-sref-active-eq` directive applies the CSS class when the `ui-sref`/`ui-state`'s target state is directly active (not when child states are active).\n * This is an \"exact match\" which uses [[StateService.is]].\n *\n * ### Parameter values\n * If the `ui-sref`/`ui-state` includes parameter values, the current parameter values must match the link's values for the link to be highlighted.\n * This allows a list of links to the same state with different parameters to be rendered, and the correct one highlighted.\n *\n * #### Example:\n * ```html\n * <li ng-repeat=\"user in users\" ui-sref-active=\"active\">\n *   <a ui-sref=\"user.details({ userId: user.id })\">{{ user.lastName }}</a>\n * </li>\n * ```\n *\n * ### Examples\n *\n * Given the following template:\n * #### Example:\n * ```html\n * <ul>\n *   <li ui-sref-active=\"active\" class=\"item\">\n *     <a href ui-sref=\"app.user({user: 'bilbobaggins'})\">@bilbobaggins</a>\n *   </li>\n * </ul>\n * ```\n *\n * When the app state is `app.user` (or any child state),\n * and contains the state parameter \"user\" with value \"bilbobaggins\",\n * the resulting HTML will appear as (note the 'active' class):\n *\n * ```html\n * <ul>\n *   <li ui-sref-active=\"active\" class=\"item active\">\n *     <a ui-sref=\"app.user({user: 'bilbobaggins'})\" href=\"/users/bilbobaggins\">@bilbobaggins</a>\n *   </li>\n * </ul>\n * ```\n *\n * ### Glob mode\n *\n * It is possible to pass `ui-sref-active` an expression that evaluates to an object.\n * The objects keys represent active class names and values represent the respective state names/globs.\n * `ui-sref-active` will match if the current active state **includes** any of\n * the specified state names/globs, even the abstract ones.\n *\n * #### Example:\n * Given the following template, with \"admin\" being an abstract state:\n * ```html\n * <div ui-sref-active=\"{'active': 'admin.**'}\">\n *   <a ui-sref-active=\"active\" ui-sref=\"admin.roles\">Roles</a>\n * </div>\n * ```\n *\n * Arrays are also supported as values in the `ngClass`-like interface.\n * This allows multiple states to add `active` class.\n *\n * #### Example:\n * Given the following template, with \"admin.roles\" being the current state, the class will be added too:\n * ```html\n * <div ui-sref-active=\"{'active': ['owner.**', 'admin.**']}\">\n *   <a ui-sref-active=\"active\" ui-sref=\"admin.roles\">Roles</a>\n * </div>\n * ```\n *\n * When the current state is \"admin.roles\" the \"active\" class will be applied to both the `<div>` and `<a>` elements.\n * It is important to note that the state names/globs passed to `ui-sref-active` override any state provided by a linked `ui-sref`.\n *\n * ### Notes:\n *\n * - The class name is interpolated **once** during the directives link time (any further changes to the\n * interpolated value are ignored).\n *\n * - Multiple classes may be specified in a space-separated format: `ui-sref-active='class1 class2 class3'`\n */\nvar uiSrefActiveDirective;\nuiSrefActiveDirective = [\n    '$state',\n    '$stateParams',\n    '$interpolate',\n    '$uiRouter',\n    function $StateRefActiveDirective($state, $stateParams, $interpolate, $uiRouter) {\n        return {\n            restrict: 'A',\n            controller: [\n                '$scope',\n                '$element',\n                '$attrs',\n                function ($scope, $element, $attrs) {\n                    var states = [];\n                    var activeEqClass;\n                    var uiSrefActive;\n                    // There probably isn't much point in $observing this\n                    // uiSrefActive and uiSrefActiveEq share the same directive object with some\n                    // slight difference in logic routing\n                    activeEqClass = $interpolate($attrs.uiSrefActiveEq || '', false)($scope);\n                    try {\n                        uiSrefActive = $scope.$eval($attrs.uiSrefActive);\n                    }\n                    catch (e) {\n                        // Do nothing. uiSrefActive is not a valid expression.\n                        // Fall back to using $interpolate below\n                    }\n                    uiSrefActive = uiSrefActive || $interpolate($attrs.uiSrefActive || '', false)($scope);\n                    setStatesFromDefinitionObject(uiSrefActive);\n                    // Allow uiSref to communicate with uiSrefActive[Equals]\n                    this.$$addStateInfo = function (newState, newParams) {\n                        // we already got an explicit state provided by ui-sref-active, so we\n                        // shadow the one that comes from ui-sref\n                        if (isObject(uiSrefActive) && states.length > 0) {\n                            return;\n                        }\n                        var deregister = addState(newState, newParams, uiSrefActive);\n                        update();\n                        return deregister;\n                    };\n                    function updateAfterTransition(trans) {\n                        trans.promise.then(update, noop);\n                    }\n                    $scope.$on('$destroy', setupEventListeners());\n                    if ($uiRouter.globals.transition) {\n                        updateAfterTransition($uiRouter.globals.transition);\n                    }\n                    function setupEventListeners() {\n                        var deregisterStatesChangedListener = $uiRouter.stateRegistry.onStatesChanged(handleStatesChanged);\n                        var deregisterOnStartListener = $uiRouter.transitionService.onStart({}, updateAfterTransition);\n                        var deregisterStateChangeSuccessListener = $scope.$on('$stateChangeSuccess', update);\n                        return function cleanUp() {\n                            deregisterStatesChangedListener();\n                            deregisterOnStartListener();\n                            deregisterStateChangeSuccessListener();\n                        };\n                    }\n                    function handleStatesChanged() {\n                        setStatesFromDefinitionObject(uiSrefActive);\n                    }\n                    function setStatesFromDefinitionObject(statesDefinition) {\n                        if (isObject(statesDefinition)) {\n                            states = [];\n                            forEach(statesDefinition, function (stateOrName, activeClass) {\n                                // Helper function to abstract adding state.\n                                var addStateForClass = function (stateOrName, activeClass) {\n                                    var ref = parseStateRef(stateOrName);\n                                    addState(ref.state, $scope.$eval(ref.paramExpr), activeClass);\n                                };\n                                if (isString(stateOrName)) {\n                                    // If state is string, just add it.\n                                    addStateForClass(stateOrName, activeClass);\n                                }\n                                else if (isArray(stateOrName)) {\n                                    // If state is an array, iterate over it and add each array item individually.\n                                    forEach(stateOrName, function (stateOrName) {\n                                        addStateForClass(stateOrName, activeClass);\n                                    });\n                                }\n                            });\n                        }\n                    }\n                    function addState(stateName, stateParams, activeClass) {\n                        var state = $state.get(stateName, stateContext($element));\n                        var stateInfo = {\n                            state: state || { name: stateName },\n                            params: stateParams,\n                            activeClass: activeClass,\n                        };\n                        states.push(stateInfo);\n                        return function removeState() {\n                            removeFrom(states)(stateInfo);\n                        };\n                    }\n                    // Update route state\n                    function update() {\n                        var splitClasses = function (str) { return str.split(/\\s/).filter(identity); };\n                        var getClasses = function (stateList) {\n                            return stateList\n                                .map(function (x) { return x.activeClass; })\n                                .map(splitClasses)\n                                .reduce(unnestR, []);\n                        };\n                        var allClasses = getClasses(states)\n                            .concat(splitClasses(activeEqClass))\n                            .reduce(uniqR, []);\n                        var fuzzyClasses = getClasses(states.filter(function (x) { return $state.includes(x.state.name, x.params); }));\n                        var exactlyMatchesAny = !!states.filter(function (x) { return $state.is(x.state.name, x.params); }).length;\n                        var exactClasses = exactlyMatchesAny ? splitClasses(activeEqClass) : [];\n                        var addClasses = fuzzyClasses.concat(exactClasses).reduce(uniqR, []);\n                        var removeClasses = allClasses.filter(function (cls) { return !inArray(addClasses, cls); });\n                        $scope.$evalAsync(function () {\n                            addClasses.forEach(function (className) { return $element.addClass(className); });\n                            removeClasses.forEach(function (className) { return $element.removeClass(className); });\n                        });\n                    }\n                    update();\n                },\n            ],\n        };\n    },\n];\nng\n    .module('ui.router.state')\n    .directive('uiSref', uiSrefDirective)\n    .directive('uiSrefActive', uiSrefActiveDirective)\n    .directive('uiSrefActiveEq', uiSrefActiveDirective)\n    .directive('uiState', uiStateDirective);\n\n/** @publicapi @module ng1 */ /** */\n/**\n * `isState` Filter: truthy if the current state is the parameter\n *\n * Translates to [[StateService.is]] `$state.is(\"stateName\")`.\n *\n * #### Example:\n * ```html\n * <div ng-if=\"'stateName' | isState\">show if state is 'stateName'</div>\n * ```\n */\n$IsStateFilter.$inject = ['$state'];\nfunction $IsStateFilter($state) {\n    var isFilter = function (state, params, options) {\n        return $state.is(state, params, options);\n    };\n    isFilter.$stateful = true;\n    return isFilter;\n}\n/**\n * `includedByState` Filter: truthy if the current state includes the parameter\n *\n * Translates to [[StateService.includes]]` $state.is(\"fullOrPartialStateName\")`.\n *\n * #### Example:\n * ```html\n * <div ng-if=\"'fullOrPartialStateName' | includedByState\">show if state includes 'fullOrPartialStateName'</div>\n * ```\n */\n$IncludedByStateFilter.$inject = ['$state'];\nfunction $IncludedByStateFilter($state) {\n    var includesFilter = function (state, params, options) {\n        return $state.includes(state, params, options);\n    };\n    includesFilter.$stateful = true;\n    return includesFilter;\n}\nng\n    .module('ui.router.state')\n    .filter('isState', $IsStateFilter)\n    .filter('includedByState', $IncludedByStateFilter);\n\n/** @publicapi @module directives */ /** */\n/**\n * `ui-view`: A viewport directive which is filled in by a view from the active state.\n *\n * ### Attributes\n *\n * - `name`: (Optional) A view name.\n *   The name should be unique amongst the other views in the same state.\n *   You can have views of the same name that live in different states.\n *   The ui-view can be targeted in a View using the name ([[Ng1StateDeclaration.views]]).\n *\n * - `autoscroll`: an expression. When it evaluates to true, the `ui-view` will be scrolled into view when it is activated.\n *   Uses [[$uiViewScroll]] to do the scrolling.\n *\n * - `onload`: Expression to evaluate whenever the view updates.\n *\n * #### Example:\n * A view can be unnamed or named.\n * ```html\n * <!-- Unnamed -->\n * <div ui-view></div>\n *\n * <!-- Named -->\n * <div ui-view=\"viewName\"></div>\n *\n * <!-- Named (different style) -->\n * <ui-view name=\"viewName\"></ui-view>\n * ```\n *\n * You can only have one unnamed view within any template (or root html). If you are only using a\n * single view and it is unnamed then you can populate it like so:\n *\n * ```html\n * <div ui-view></div>\n * $stateProvider.state(\"home\", {\n *   template: \"<h1>HELLO!</h1>\"\n * })\n * ```\n *\n * The above is a convenient shortcut equivalent to specifying your view explicitly with the\n * [[Ng1StateDeclaration.views]] config property, by name, in this case an empty name:\n *\n * ```js\n * $stateProvider.state(\"home\", {\n *   views: {\n *     \"\": {\n *       template: \"<h1>HELLO!</h1>\"\n *     }\n *   }\n * })\n * ```\n *\n * But typically you'll only use the views property if you name your view or have more than one view\n * in the same template. There's not really a compelling reason to name a view if its the only one,\n * but you could if you wanted, like so:\n *\n * ```html\n * <div ui-view=\"main\"></div>\n * ```\n *\n * ```js\n * $stateProvider.state(\"home\", {\n *   views: {\n *     \"main\": {\n *       template: \"<h1>HELLO!</h1>\"\n *     }\n *   }\n * })\n * ```\n *\n * Really though, you'll use views to set up multiple views:\n *\n * ```html\n * <div ui-view></div>\n * <div ui-view=\"chart\"></div>\n * <div ui-view=\"data\"></div>\n * ```\n *\n * ```js\n * $stateProvider.state(\"home\", {\n *   views: {\n *     \"\": {\n *       template: \"<h1>HELLO!</h1>\"\n *     },\n *     \"chart\": {\n *       template: \"<chart_thing/>\"\n *     },\n *     \"data\": {\n *       template: \"<data_thing/>\"\n *     }\n *   }\n * })\n * ```\n *\n * #### Examples for `autoscroll`:\n * ```html\n * <!-- If autoscroll present with no expression,\n *      then scroll ui-view into view -->\n * <ui-view autoscroll/>\n *\n * <!-- If autoscroll present with valid expression,\n *      then scroll ui-view into view if expression evaluates to true -->\n * <ui-view autoscroll='true'/>\n * <ui-view autoscroll='false'/>\n * <ui-view autoscroll='scopeVariable'/>\n * ```\n *\n * Resolve data:\n *\n * The resolved data from the state's `resolve` block is placed on the scope as `$resolve` (this\n * can be customized using [[Ng1ViewDeclaration.resolveAs]]).  This can be then accessed from the template.\n *\n * Note that when `controllerAs` is being used, `$resolve` is set on the controller instance *after* the\n * controller is instantiated.  The `$onInit()` hook can be used to perform initialization code which\n * depends on `$resolve` data.\n *\n * #### Example:\n * ```js\n * $stateProvider.state('home', {\n *   template: '<my-component user=\"$resolve.user\"></my-component>',\n *   resolve: {\n *     user: function(UserService) { return UserService.fetchUser(); }\n *   }\n * });\n * ```\n */\nvar uiView;\nuiView = [\n    '$view',\n    '$animate',\n    '$uiViewScroll',\n    '$interpolate',\n    '$q',\n    function $ViewDirective($view, $animate, $uiViewScroll, $interpolate, $q) {\n        function getRenderer(attrs, scope) {\n            return {\n                enter: function (element, target, cb) {\n                    if (ng.version.minor > 2) {\n                        $animate.enter(element, null, target).then(cb);\n                    }\n                    else {\n                        $animate.enter(element, null, target, cb);\n                    }\n                },\n                leave: function (element, cb) {\n                    if (ng.version.minor > 2) {\n                        $animate.leave(element).then(cb);\n                    }\n                    else {\n                        $animate.leave(element, cb);\n                    }\n                },\n            };\n        }\n        function configsEqual(config1, config2) {\n            return config1 === config2;\n        }\n        var rootData = {\n            $cfg: { viewDecl: { $context: $view._pluginapi._rootViewContext() } },\n            $uiView: {},\n        };\n        var directive = {\n            count: 0,\n            restrict: 'ECA',\n            terminal: true,\n            priority: 400,\n            transclude: 'element',\n            compile: function (tElement, tAttrs, $transclude) {\n                return function (scope, $element, attrs) {\n                    var onloadExp = attrs['onload'] || '', autoScrollExp = attrs['autoscroll'], renderer = getRenderer(), inherited = $element.inheritedData('$uiView') || rootData, name = $interpolate(attrs['uiView'] || attrs['name'] || '')(scope) || '$default';\n                    var previousEl, currentEl, currentScope, viewConfig, unregister;\n                    var activeUIView = {\n                        $type: 'ng1',\n                        id: directive.count++,\n                        name: name,\n                        fqn: inherited.$uiView.fqn ? inherited.$uiView.fqn + '.' + name : name,\n                        config: null,\n                        configUpdated: configUpdatedCallback,\n                        get creationContext() {\n                            // The context in which this ui-view \"tag\" was created\n                            var fromParentTagConfig = parse('$cfg.viewDecl.$context')(inherited);\n                            // Allow <ui-view name=\"foo\"><ui-view name=\"bar\"></ui-view></ui-view>\n                            // See https://github.com/angular-ui/ui-router/issues/3355\n                            var fromParentTag = parse('$uiView.creationContext')(inherited);\n                            return fromParentTagConfig || fromParentTag;\n                        },\n                    };\n                    trace.traceUIViewEvent('Linking', activeUIView);\n                    function configUpdatedCallback(config) {\n                        if (config && !(config instanceof Ng1ViewConfig))\n                            return;\n                        if (configsEqual(viewConfig, config))\n                            return;\n                        trace.traceUIViewConfigUpdated(activeUIView, config && config.viewDecl && config.viewDecl.$context);\n                        viewConfig = config;\n                        updateView(config);\n                    }\n                    $element.data('$uiView', { $uiView: activeUIView });\n                    updateView();\n                    unregister = $view.registerUIView(activeUIView);\n                    scope.$on('$destroy', function () {\n                        trace.traceUIViewEvent('Destroying/Unregistering', activeUIView);\n                        unregister();\n                    });\n                    function cleanupLastView() {\n                        if (previousEl) {\n                            trace.traceUIViewEvent('Removing (previous) el', previousEl.data('$uiView'));\n                            previousEl.remove();\n                            previousEl = null;\n                        }\n                        if (currentScope) {\n                            trace.traceUIViewEvent('Destroying scope', activeUIView);\n                            currentScope.$destroy();\n                            currentScope = null;\n                        }\n                        if (currentEl) {\n                            var _viewData_1 = currentEl.data('$uiViewAnim');\n                            trace.traceUIViewEvent('Animate out', _viewData_1);\n                            renderer.leave(currentEl, function () {\n                                _viewData_1.$$animLeave.resolve();\n                                previousEl = null;\n                            });\n                            previousEl = currentEl;\n                            currentEl = null;\n                        }\n                    }\n                    function updateView(config) {\n                        var newScope = scope.$new();\n                        var animEnter = $q.defer(), animLeave = $q.defer();\n                        var $uiViewData = {\n                            $cfg: config,\n                            $uiView: activeUIView,\n                        };\n                        var $uiViewAnim = {\n                            $animEnter: animEnter.promise,\n                            $animLeave: animLeave.promise,\n                            $$animLeave: animLeave,\n                        };\n                        /**\n                         * @ngdoc event\n                         * @name ui.router.state.directive:ui-view#$viewContentLoading\n                         * @eventOf ui.router.state.directive:ui-view\n                         * @eventType emits on ui-view directive scope\n                         * @description\n                         *\n                         * Fired once the view **begins loading**, *before* the DOM is rendered.\n                         *\n                         * @param {Object} event Event object.\n                         * @param {string} viewName Name of the view.\n                         */\n                        newScope.$emit('$viewContentLoading', name);\n                        var cloned = $transclude(newScope, function (clone) {\n                            clone.data('$uiViewAnim', $uiViewAnim);\n                            clone.data('$uiView', $uiViewData);\n                            renderer.enter(clone, $element, function onUIViewEnter() {\n                                animEnter.resolve();\n                                if (currentScope)\n                                    currentScope.$emit('$viewContentAnimationEnded');\n                                if ((isDefined(autoScrollExp) && !autoScrollExp) || scope.$eval(autoScrollExp)) {\n                                    $uiViewScroll(clone);\n                                }\n                            });\n                            cleanupLastView();\n                        });\n                        currentEl = cloned;\n                        currentScope = newScope;\n                        /**\n                         * @ngdoc event\n                         * @name ui.router.state.directive:ui-view#$viewContentLoaded\n                         * @eventOf ui.router.state.directive:ui-view\n                         * @eventType emits on ui-view directive scope\n                         * @description           *\n                         * Fired once the view is **loaded**, *after* the DOM is rendered.\n                         *\n                         * @param {Object} event Event object.\n                         */\n                        currentScope.$emit('$viewContentLoaded', config || viewConfig);\n                        currentScope.$eval(onloadExp);\n                    }\n                };\n            },\n        };\n        return directive;\n    },\n];\n$ViewDirectiveFill.$inject = ['$compile', '$controller', '$transitions', '$view', '$q', '$timeout'];\n/** @hidden */\nfunction $ViewDirectiveFill($compile, $controller, $transitions, $view, $q, $timeout) {\n    var getControllerAs = parse('viewDecl.controllerAs');\n    var getResolveAs = parse('viewDecl.resolveAs');\n    return {\n        restrict: 'ECA',\n        priority: -400,\n        compile: function (tElement) {\n            var initial = tElement.html();\n            tElement.empty();\n            return function (scope, $element) {\n                var data = $element.data('$uiView');\n                if (!data) {\n                    $element.html(initial);\n                    $compile($element.contents())(scope);\n                    return;\n                }\n                var cfg = data.$cfg || { viewDecl: {}, getTemplate: noop };\n                var resolveCtx = cfg.path && new ResolveContext(cfg.path);\n                $element.html(cfg.getTemplate($element, resolveCtx) || initial);\n                trace.traceUIViewFill(data.$uiView, $element.html());\n                var link = $compile($element.contents());\n                var controller = cfg.controller;\n                var controllerAs = getControllerAs(cfg);\n                var resolveAs = getResolveAs(cfg);\n                var locals = resolveCtx && getLocals(resolveCtx);\n                scope[resolveAs] = locals;\n                if (controller) {\n                    var controllerInstance = ($controller(controller, extend({}, locals, { $scope: scope, $element: $element })));\n                    if (controllerAs) {\n                        scope[controllerAs] = controllerInstance;\n                        scope[controllerAs][resolveAs] = locals;\n                    }\n                    // TODO: Use $view service as a central point for registering component-level hooks\n                    // Then, when a component is created, tell the $view service, so it can invoke hooks\n                    // $view.componentLoaded(controllerInstance, { $scope: scope, $element: $element });\n                    // scope.$on('$destroy', () => $view.componentUnloaded(controllerInstance, { $scope: scope, $element: $element }));\n                    $element.data('$ngControllerController', controllerInstance);\n                    $element.children().data('$ngControllerController', controllerInstance);\n                    registerControllerCallbacks($q, $transitions, controllerInstance, scope, cfg);\n                }\n                // Wait for the component to appear in the DOM\n                if (isString(cfg.component)) {\n                    var kebobName = kebobString(cfg.component);\n                    var tagRegexp_1 = new RegExp(\"^(x-|data-)?\" + kebobName + \"$\", 'i');\n                    var getComponentController = function () {\n                        var directiveEl = [].slice\n                            .call($element[0].children)\n                            .filter(function (el) { return el && el.tagName && tagRegexp_1.exec(el.tagName); });\n                        return directiveEl && ng.element(directiveEl).data(\"$\" + cfg.component + \"Controller\");\n                    };\n                    var deregisterWatch_1 = scope.$watch(getComponentController, function (ctrlInstance) {\n                        if (!ctrlInstance)\n                            return;\n                        registerControllerCallbacks($q, $transitions, ctrlInstance, scope, cfg);\n                        deregisterWatch_1();\n                    });\n                }\n                link(scope);\n            };\n        },\n    };\n}\n/** @hidden */\nvar hasComponentImpl = typeof ng.module('ui.router')['component'] === 'function';\n/** @hidden incrementing id */\nvar _uiCanExitId = 0;\n/** @hidden TODO: move these callbacks to $view and/or `/hooks/components.ts` or something */\nfunction registerControllerCallbacks($q, $transitions, controllerInstance, $scope, cfg) {\n    // Call $onInit() ASAP\n    if (isFunction(controllerInstance.$onInit) && !((cfg.viewDecl.component || cfg.viewDecl.componentProvider) && hasComponentImpl)) {\n        controllerInstance.$onInit();\n    }\n    var viewState = tail(cfg.path).state.self;\n    var hookOptions = { bind: controllerInstance };\n    // Add component-level hook for onUiParamsChanged\n    if (isFunction(controllerInstance.uiOnParamsChanged)) {\n        var resolveContext = new ResolveContext(cfg.path);\n        var viewCreationTrans_1 = resolveContext.getResolvable('$transition$').data;\n        // Fire callback on any successful transition\n        var paramsUpdated = function ($transition$) {\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_1 || $transition$.exiting().indexOf(viewState) !== -1)\n                return;\n            var toParams = $transition$.params('to');\n            var fromParams = $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 = $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.indexOf(param);\n                return idx === -1 || !fromSchema[idx].type.equals(toParams[param.id], fromParams[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, function (val, key) { return changedKeys_1.indexOf(key) !== -1; });\n                controllerInstance.uiOnParamsChanged(newValues, $transition$);\n            }\n        };\n        $scope.$on('$destroy', $transitions.onSuccess({}, paramsUpdated, hookOptions));\n    }\n    // Add component-level hook for uiCanExit\n    if (isFunction(controllerInstance.uiCanExit)) {\n        var id_1 = _uiCanExitId++;\n        var cacheProp_1 = '_uiCanExitIds';\n        // Returns true if a redirect transition already answered truthy\n        var prevTruthyAnswer_1 = function (trans) {\n            return !!trans && ((trans[cacheProp_1] && trans[cacheProp_1][id_1] === true) || prevTruthyAnswer_1(trans.redirectedFrom()));\n        };\n        // If a user answered yes, but the transition was later redirected, don't also ask for the new redirect transition\n        var wrappedHook = function (trans) {\n            var promise;\n            var ids = (trans[cacheProp_1] = trans[cacheProp_1] || {});\n            if (!prevTruthyAnswer_1(trans)) {\n                promise = $q.when(controllerInstance.uiCanExit(trans));\n                promise.then(function (val) { return (ids[id_1] = val !== false); });\n            }\n            return promise;\n        };\n        var criteria = { exiting: viewState.name };\n        $scope.$on('$destroy', $transitions.onBefore(criteria, wrappedHook, hookOptions));\n    }\n}\nng.module('ui.router.state').directive('uiView', uiView);\nng.module('ui.router.state').directive('uiView', $ViewDirectiveFill);\n\n/** @publicapi @module ng1 */ /** */\n/** @hidden */\nfunction $ViewScrollProvider() {\n    var useAnchorScroll = false;\n    this.useAnchorScroll = function () {\n        useAnchorScroll = true;\n    };\n    this.$get = [\n        '$anchorScroll',\n        '$timeout',\n        function ($anchorScroll, $timeout) {\n            if (useAnchorScroll) {\n                return $anchorScroll;\n            }\n            return function ($element) {\n                return $timeout(function () {\n                    $element[0].scrollIntoView();\n                }, 0, false);\n            };\n        },\n    ];\n}\nng.module('ui.router.state').provider('$uiViewScroll', $ViewScrollProvider);\n\nexport { Ng1ViewConfig as N, StateProvider as S, UrlRouterProvider as U, getNg1ViewConfigFactory as a, getLocals as g, ng1ViewsBuilder as n, watchDigests as w };\n", "export { 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';\nexport { i as core } from '../common/index-fc7f5fbd.js';\nimport '../common/index-729b989c.js';\nexport { N as Ng1ViewConfig, S as StateProvider, U as UrlRouterProvider, g as getLocals, a as getNg1ViewConfigFactory, n as ng1ViewsBuilder, w as watchDigests } from '../common/viewScroll-db255824.js';\n\nvar index = 'ui.router';\n\nexport default index;\n"],
  "mappings": "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",
  "names": []
}