kms 1.0.1 → 1.1.0

data/vendor/assets/bower_components/angular-ui-router/release/resolveService.js

@@ -0,0 +1,83 @@
+/**
+ * State-based routing for AngularJS 1.x
+ * @version v1.0.11
+ * @link https://ui-router.github.io
+ * @license MIT License, http://www.opensource.org/licenses/MIT
+ */
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@uirouter/core'), require('angular')) :
+	typeof define === 'function' && define.amd ? define(['exports', '@uirouter/core', 'angular'], factory) :
+	(factory((global['@uirouter/angularjs-resolve-service'] = {}),global['@uirouter/core'],global.angular));
+}(this, (function (exports,core,angular) { 'use strict';
+
+/** @module ng1 */ /** */
+/**
+ * Implementation of the legacy `$resolve` service for angular 1.
+ */
+var $resolve = {
+    /**
+     * Asynchronously injects a resolve block.
+     *
+     * This emulates most of the behavior of the ui-router 0.2.x $resolve.resolve() service API.
+     *
+    * ### Not bundled by default
+     *
+     * This API is no longer not part of the standard `@uirouter/angularjs` bundle.
+     * For users of the prebuilt bundles, add the `release/resolveService.min.js` UMD bundle.
+     * For bundlers (webpack, browserify, etc), add `@uirouter/angularjs/lib/legacy/resolveService`.
+     *
+     * ---
+     *
+     * Given an object `invocables`, where keys are strings and values are injectable functions,
+     * injects each function, and waits for the resulting promise to resolve.
+     * When all resulting promises are resolved, returns the results as an object.
+     *
+     * #### Example:
+     * ```js
+     * let invocables = {
+     *   foo: [ '$http', ($http) =>
+     *            $http.get('/api/foo').then(resp => resp.data) ],
+     *   bar: [ 'foo', '$http', (foo, $http) =>
+     *            $http.get('/api/bar/' + foo.barId).then(resp => resp.data) ]
+     * }
+     * $resolve.resolve(invocables)
+     *     .then(results => console.log(results.foo, results.bar))
+     * // Logs foo and bar:
+     * // { id: 123, barId: 456, fooData: 'foo data' }
+     * // { id: 456, barData: 'bar data' }
+     * ```
+     *
+     * @param invocables an object which looks like an [[StateDeclaration.resolve]] object; keys are resolve names and values are injectable functions
+     * @param locals key/value pre-resolved data (locals)
+     * @param parent a promise for a "parent resolve"
+     */
+    resolve: function (invocables, locals, parent) {
+        if (locals === void 0) { locals = {}; }
+        var parentNode = new core.PathNode(new core.StateObject({ params: {}, resolvables: [] }));
+        var node = new core.PathNode(new core.StateObject({ params: {}, resolvables: [] }));
+        var context = new core.ResolveContext([parentNode, node]);
+        context.addResolvables(core.resolvablesBuilder({ resolve: invocables }), node.state);
+        var resolveData = function (parentLocals) {
+            var rewrap = function (_locals) { return core.resolvablesBuilder({ resolve: core.mapObj(_locals, function (local) { return function () { return local; }; }) }); };
+            context.addResolvables(rewrap(parentLocals), parentNode.state);
+            context.addResolvables(rewrap(locals), node.state);
+            var tuples2ObjR = function (acc, tuple) {
+                acc[tuple.token] = tuple.value;
+                return acc;
+            };
+            return context.resolvePath().then(function (results) { return results.reduce(tuples2ObjR, {}); });
+        };
+        return parent ? parent.then(resolveData) : resolveData({});
+    }
+};
+/** @hidden */
+var resolveFactory = function () { return $resolve; };
+// The old $resolve service
+angular.module('ui.router').factory('$resolve', resolveFactory);
+
+exports.resolveFactory = resolveFactory;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=resolveService.js.map

data/vendor/assets/bower_components/angular-ui-router/release/resolveService.js.map

@@ -0,0 +1,19 @@
+{
+  "version": 3,
+  "file": "resolveService.js",
+  "sources": [
+    "@uirouter/angularjs/src/legacy/resolveService.ts"
+  ],
+  "sourcesContent": [
+    "/** @module ng1 */ /** */\nimport { StateObject, PathNode, ResolveContext, Obj, mapObj, resolvablesBuilder } from \"@uirouter/core\";\nimport * as angular from \"angular\";\n\n/**\n * Implementation of the legacy `$resolve` service for angular 1.\n */\nvar $resolve = {\n  /**\n   * Asynchronously injects a resolve block.\n   *\n   * This emulates most of the behavior of the ui-router 0.2.x $resolve.resolve() service API.\n   *\n  * ### Not bundled by default\n   *\n   * This API is no longer not part of the standard `@uirouter/angularjs` bundle.\n   * For users of the prebuilt bundles, add the `release/resolveService.min.js` UMD bundle.\n   * For bundlers (webpack, browserify, etc), add `@uirouter/angularjs/lib/legacy/resolveService`.\n   *\n   * ---\n   *\n   * Given an object `invocables`, where keys are strings and values are injectable functions,\n   * injects each function, and waits for the resulting promise to resolve.\n   * When all resulting promises are resolved, returns the results as an object.\n   *\n   * #### Example:\n   * ```js\n   * let invocables = {\n   *   foo: [ '$http', ($http) =>\n   *            $http.get('/api/foo').then(resp => resp.data) ],\n   *   bar: [ 'foo', '$http', (foo, $http) =>\n   *            $http.get('/api/bar/' + foo.barId).then(resp => resp.data) ]\n   * }\n   * $resolve.resolve(invocables)\n   *     .then(results => console.log(results.foo, results.bar))\n   * // Logs foo and bar:\n   * // { id: 123, barId: 456, fooData: 'foo data' }\n   * // { id: 456, barData: 'bar data' }\n   * ```\n   *\n   * @param invocables an object which looks like an [[StateDeclaration.resolve]] object; keys are resolve names and values are injectable functions\n   * @param locals key/value pre-resolved data (locals)\n   * @param parent a promise for a \"parent resolve\"\n   */\n  resolve: (invocables: { [key: string]: Function }, locals = {}, parent?: Promise<any>) => {\n    let parentNode = new PathNode(new StateObject(<any> { params: {}, resolvables: [] }));\n    let node = new PathNode(new StateObject(<any> { params: {}, resolvables: [] }));\n    let context = new ResolveContext([parentNode, node]);\n\n    context.addResolvables(resolvablesBuilder(<any> { resolve: invocables }), node.state);\n\n    const resolveData = (parentLocals: Obj) => {\n      const rewrap = (_locals: Obj) => resolvablesBuilder(<any> { resolve: mapObj(_locals, local => () => local) });\n      context.addResolvables(rewrap(parentLocals), parentNode.state);\n      context.addResolvables(rewrap(locals), node.state);\n\n      const tuples2ObjR = (acc: Obj, tuple: { token: any, value: any }) => {\n        acc[tuple.token] = tuple.value;\n        return acc;\n      };\n      return context.resolvePath().then(results => results.reduce(tuples2ObjR, {}));\n    };\n\n    return parent ? parent.then(resolveData) : resolveData({});\n  }\n};\n\n/** @hidden */\nexport const resolveFactory = () => $resolve;\n\n// The old $resolve service\nangular.module('ui.router').factory('$resolve', <any> resolveFactory);\n"
+  ],
+  "names": [
+    "PathNode",
+    "StateObject",
+    "ResolveContext",
+    "resolvablesBuilder",
+    "mapObj",
+    "angular.module"
+  ],
+  "mappings": ";;;;;;;;;;;;AAAA;AACA,AAGA;;;AAGA,IAAI,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqCb,OAAO,EAAE,UAAC,UAAuC,EAAE,MAAW,EAAE,MAAqB;QAAlC,uBAAA,EAAA,WAAW;QAC5D,IAAI,UAAU,GAAG,IAAIA,aAAQ,CAAC,IAAIC,gBAAW,CAAO,EAAE,MAAM,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;QACtF,IAAI,IAAI,GAAG,IAAID,aAAQ,CAAC,IAAIC,gBAAW,CAAO,EAAE,MAAM,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;QAChF,IAAI,OAAO,GAAG,IAAIC,mBAAc,CAAC,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC;QAErD,OAAO,CAAC,cAAc,CAACC,uBAAkB,CAAO,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QAEtF,IAAM,WAAW,GAAG,UAAC,YAAiB;YACpC,IAAM,MAAM,GAAG,UAAC,OAAY,IAAK,OAAAA,uBAAkB,CAAO,EAAE,OAAO,EAAEC,WAAM,CAAC,OAAO,EAAE,UAAA,KAAK,IAAI,OAAA,cAAM,OAAA,KAAK,GAAA,GAAA,CAAC,EAAE,CAAC,GAAA,CAAC;YAC9G,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;YAC/D,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;YAEnD,IAAM,WAAW,GAAG,UAAC,GAAQ,EAAE,KAAiC;gBAC9D,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;gBAC/B,OAAO,GAAG,CAAC;aACZ,CAAC;YACF,OAAO,OAAO,CAAC,WAAW,EAAE,CAAC,IAAI,CAAC,UAAA,OAAO,IAAI,OAAA,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,CAAC,GAAA,CAAC,CAAC;SAC/E,CAAC;QAEF,OAAO,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;KAC5D;CACF,CAAC;;AAGF,AAAO,IAAM,cAAc,GAAG,cAAM,OAAA,QAAQ,GAAA,CAAC;;AAG7CC,cAAc,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,UAAU,EAAQ,cAAc,CAAC,CAAC;;;;;;;;;;;;"
+}

data/vendor/assets/bower_components/angular-ui-router/release/resolveService.min.js

@@ -0,0 +1,8 @@
+/**
+ * State-based routing for AngularJS 1.x
+ * @version v1.0.11
+ * @link https://ui-router.github.io
+ * @license MIT License, http://www.opensource.org/licenses/MIT
+ */
+!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@uirouter/core"),require("angular")):"function"==typeof define&&define.amd?define(["exports","@uirouter/core","angular"],r):r(e["@uirouter/angularjs-resolve-service"]={},e["@uirouter/core"],e.angular)}(this,function(e,r,t){"use strict";var o={resolve:function(e,t,o){void 0===t&&(t={});var n=new r.PathNode(new r.StateObject({params:{},resolvables:[]})),u=new r.PathNode(new r.StateObject({params:{},resolvables:[]})),a=new r.ResolveContext([n,u]);a.addResolvables(r.resolvablesBuilder({resolve:e}),u.state);var s=function(e){var o=function(e){return r.resolvablesBuilder({resolve:r.mapObj(e,function(e){return function(){return e}})})};a.addResolvables(o(e),n.state),a.addResolvables(o(t),u.state);var s=function(e,r){return e[r.token]=r.value,e};return a.resolvePath().then(function(e){return e.reduce(s,{})})};return o?o.then(s):s({})}},n=function(){return o};t.module("ui.router").factory("$resolve",n),e.resolveFactory=n,Object.defineProperty(e,"__esModule",{value:!0})});
+//# sourceMappingURL=resolveService.min.js.map

data/vendor/assets/bower_components/angular-ui-router/release/resolveService.min.js.map

@@ -0,0 +1,47 @@
+{
+  "version": 3,
+  "file": "resolveService.min.js",
+  "sources": [
+    "@uirouter/angularjs/src/legacy/resolveService.ts"
+  ],
+  "sourcesContent": [
+    "/** @module ng1 */ /** */\nimport { StateObject, PathNode, ResolveContext, Obj, mapObj, resolvablesBuilder } from \"@uirouter/core\";\nimport * as angular from \"angular\";\n\n/**\n * Implementation of the legacy `$resolve` service for angular 1.\n */\nvar $resolve = {\n  /**\n   * Asynchronously injects a resolve block.\n   *\n   * This emulates most of the behavior of the ui-router 0.2.x $resolve.resolve() service API.\n   *\n  * ### Not bundled by default\n   *\n   * This API is no longer not part of the standard `@uirouter/angularjs` bundle.\n   * For users of the prebuilt bundles, add the `release/resolveService.min.js` UMD bundle.\n   * For bundlers (webpack, browserify, etc), add `@uirouter/angularjs/lib/legacy/resolveService`.\n   *\n   * ---\n   *\n   * Given an object `invocables`, where keys are strings and values are injectable functions,\n   * injects each function, and waits for the resulting promise to resolve.\n   * When all resulting promises are resolved, returns the results as an object.\n   *\n   * #### Example:\n   * ```js\n   * let invocables = {\n   *   foo: [ '$http', ($http) =>\n   *            $http.get('/api/foo').then(resp => resp.data) ],\n   *   bar: [ 'foo', '$http', (foo, $http) =>\n   *            $http.get('/api/bar/' + foo.barId).then(resp => resp.data) ]\n   * }\n   * $resolve.resolve(invocables)\n   *     .then(results => console.log(results.foo, results.bar))\n   * // Logs foo and bar:\n   * // { id: 123, barId: 456, fooData: 'foo data' }\n   * // { id: 456, barData: 'bar data' }\n   * ```\n   *\n   * @param invocables an object which looks like an [[StateDeclaration.resolve]] object; keys are resolve names and values are injectable functions\n   * @param locals key/value pre-resolved data (locals)\n   * @param parent a promise for a \"parent resolve\"\n   */\n  resolve: (invocables: { [key: string]: Function }, locals = {}, parent?: Promise<any>) => {\n    let parentNode = new PathNode(new StateObject(<any> { params: {}, resolvables: [] }));\n    let node = new PathNode(new StateObject(<any> { params: {}, resolvables: [] }));\n    let context = new ResolveContext([parentNode, node]);\n\n    context.addResolvables(resolvablesBuilder(<any> { resolve: invocables }), node.state);\n\n    const resolveData = (parentLocals: Obj) => {\n      const rewrap = (_locals: Obj) => resolvablesBuilder(<any> { resolve: mapObj(_locals, local => () => local) });\n      context.addResolvables(rewrap(parentLocals), parentNode.state);\n      context.addResolvables(rewrap(locals), node.state);\n\n      const tuples2ObjR = (acc: Obj, tuple: { token: any, value: any }) => {\n        acc[tuple.token] = tuple.value;\n        return acc;\n      };\n      return context.resolvePath().then(results => results.reduce(tuples2ObjR, {}));\n    };\n\n    return parent ? parent.then(resolveData) : resolveData({});\n  }\n};\n\n/** @hidden */\nexport const resolveFactory = () => $resolve;\n\n// The old $resolve service\nangular.module('ui.router').factory('$resolve', <any> resolveFactory);\n"
+  ],
+  "names": [
+    "$resolve",
+    "resolve",
+    "invocables",
+    "locals",
+    "parent",
+    "parentNode",
+    "PathNode",
+    "StateObject",
+    "params",
+    "resolvables",
+    "node",
+    "context",
+    "ResolveContext",
+    "addResolvables",
+    "resolvablesBuilder",
+    "state",
+    "resolveData",
+    "parentLocals",
+    "rewrap",
+    "_locals",
+    "mapObj",
+    "local",
+    "tuples2ObjR",
+    "acc",
+    "tuple",
+    "token",
+    "value",
+    "resolvePath",
+    "then",
+    "results",
+    "reduce",
+    "resolveFactory",
+    "angular.module",
+    "factory"
+  ],
+  "mappings": ";;;;;;mUAOA,IAAIA,GAqCFC,QAAS,SAACC,EAAyCC,EAAaC,gBAAbD,MACjD,IAAIE,EAAa,IAAIC,WAAS,IAAIC,eAAoBC,UAAYC,kBAC9DC,EAAO,IAAIJ,WAAS,IAAIC,eAAoBC,UAAYC,kBACxDE,EAAU,IAAIC,kBAAgBP,EAAYK,IAE9CC,EAAQE,eAAeC,sBAA2Bb,QAASC,IAAeQ,EAAKK,OAE/E,IAAMC,EAAc,SAACC,GACnB,IAAMC,EAAS,SAACC,GAAiB,OAAAL,sBAA2Bb,QAASmB,SAAOD,EAAS,SAAAE,GAAS,OAAA,WAAM,OAAAA,QACpGV,EAAQE,eAAeK,EAAOD,GAAeZ,EAAWU,OACxDJ,EAAQE,eAAeK,EAAOf,GAASO,EAAKK,OAE5C,IAAMO,EAAc,SAACC,EAAUC,GAE7B,OADAD,EAAIC,EAAMC,OAASD,EAAME,MAClBH,GAET,OAAOZ,EAAQgB,cAAcC,KAAK,SAAAC,GAAW,OAAAA,EAAQC,OAAOR,SAG9D,OAAOlB,EAASA,EAAOwB,KAAKZ,GAAeA,QAKlCe,EAAiB,WAAM,OAAA/B,GAGpCgC,SAAe,aAAaC,QAAQ,WAAkBF"
+}

data/vendor/assets/bower_components/angular-ui-router/release/stateEvents.js

@@ -0,0 +1,294 @@
+/**
+ * State-based routing for AngularJS 1.x
+ * @version v1.0.11
+ * @link https://ui-router.github.io
+ * @license MIT License, http://www.opensource.org/licenses/MIT
+ */
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('angular')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'angular'], factory) :
+	(factory((global['@uirouter/angularjs-state-events'] = {}),global.angular));
+}(this, (function (exports,ng_from_import) { 'use strict';
+
+var ng_from_global = angular;
+var ng = (ng_from_import && ng_from_import.module) ? ng_from_import : ng_from_global;
+
+/**
+ * # Legacy state events
+ *
+ * Polyfill implementation of the UI-Router 0.2.x state events.
+ *
+ * The 0.2.x state events are deprecated.  We recommend moving to Transition Hooks instead, as they
+ * provide much more flexibility, support async, and provide the context (the Transition, etc) necessary
+ * to implement meaningful application behaviors.
+ *
+ * To enable these state events, include the `stateEvents.js` file in your project, e.g.,
+ * ```
+ * <script src="stateEvents.js"></script>
+ * ```
+ * and also make sure you depend on the `ui.router.state.events` angular module, e.g.,
+ * ```
+ * angular.module("myApplication", ['ui.router', 'ui.router.state.events']
+ * ```
+ *
+ * @module ng1_state_events
+ */ /** */
+/**
+ * An event broadcast on `$rootScope` when the state transition **begins**.
+ *
+ * ### Deprecation warning: use [[TransitionService.onStart]] instead
+ *
+ * You can use `event.preventDefault()`
+ * to prevent the transition from happening and then the transition promise will be
+ * rejected with a `'transition prevented'` value.
+ *
+ * Additional arguments to the event handler are provided:
+ * - `toState`: the Transition Target state
+ * - `toParams`: the Transition Target Params
+ * - `fromState`: the state the transition is coming from
+ * - `fromParams`: the parameters from the state the transition is coming from
+ * - `options`: any Transition Options
+ * - `$transition$`: the [[Transition]]
+ *
+ * #### Example:
+ * ```js
+ * $rootScope.$on('$stateChangeStart', function(event, transition) {
+ *   event.preventDefault();
+ *   // transitionTo() promise will be rejected with
+ *   // a 'transition prevented' error
+ * })
+ * ```
+ *
+ * @event $stateChangeStart
+ * @deprecated
+ */
+var $stateChangeStart;
+/**
+ * An event broadcast on `$rootScope` if a transition is **cancelled**.
+ *
+ * ### Deprecation warning: use [[TransitionService.onStart]] instead
+ *
+ * Additional arguments to the event handler are provided:
+ * - `toState`: the Transition Target state
+ * - `toParams`: the Transition Target Params
+ * - `fromState`: the state the transition is coming from
+ * - `fromParams`: the parameters from the state the transition is coming from
+ * - `options`: any Transition Options
+ * - `$transition$`: the [[Transition]] that was cancelled
+ *
+ * @event $stateChangeCancel
+ * @deprecated
+ */
+var $stateChangeCancel;
+/**
+ * An event broadcast on `$rootScope` once the state transition is **complete**.
+ *
+ * ### Deprecation warning: use [[TransitionService.onStart]] and [[Transition.promise]], or [[Transition.onSuccess]]
+ *
+ * Additional arguments to the event handler are provided:
+ * - `toState`: the Transition Target state
+ * - `toParams`: the Transition Target Params
+ * - `fromState`: the state the transition is coming from
+ * - `fromParams`: the parameters from the state the transition is coming from
+ * - `options`: any Transition Options
+ * - `$transition$`: the [[Transition]] that just succeeded
+ *
+ * @event $stateChangeSuccess
+ * @deprecated
+ */
+var $stateChangeSuccess;
+/**
+ * An event broadcast on `$rootScope` when an **error occurs** during transition.
+ *
+ * ### Deprecation warning: use [[TransitionService.onStart]] and [[Transition.promise]], or [[Transition.onError]]
+ *
+ * It's important to note that if you
+ * have any errors in your resolve functions (javascript errors, non-existent services, etc)
+ * they will not throw traditionally. You must listen for this $stateChangeError event to
+ * catch **ALL** errors.
+ *
+ * Additional arguments to the event handler are provided:
+ * - `toState`: the Transition Target state
+ * - `toParams`: the Transition Target Params
+ * - `fromState`: the state the transition is coming from
+ * - `fromParams`: the parameters from the state the transition is coming from
+ * - `error`: The reason the transition errored.
+ * - `options`: any Transition Options
+ * - `$transition$`: the [[Transition]] that errored
+ *
+ * @event $stateChangeError
+ * @deprecated
+ */
+var $stateChangeError;
+/**
+ * An event broadcast on `$rootScope` when a requested state **cannot be found** using the provided state name.
+ *
+ * ### Deprecation warning: use [[StateService.onInvalid]] instead
+ *
+ * The event is broadcast allowing any handlers a single chance to deal with the error (usually by
+ * lazy-loading the unfound state). A `TargetState` object is passed to the listener handler,
+ * you can see its properties in the example. You can use `event.preventDefault()` to abort the
+ * transition and the promise returned from `transitionTo()` will be rejected with a
+ * `'transition aborted'` error.
+ *
+ * Additional arguments to the event handler are provided:
+ * - `unfoundState` Unfound State information. Contains: `to, toParams, options` properties.
+ * - `fromState`: the state the transition is coming from
+ * - `fromParams`: the parameters from the state the transition is coming from
+ * - `options`: any Transition Options
+ *
+ * #### Example:
+ * ```js
+ * // somewhere, assume lazy.state has not been defined
+ * $state.go("lazy.state", { a: 1, b: 2 }, { inherit: false });
+ *
+ * // somewhere else
+ * $scope.$on('$stateNotFound', function(event, transition) {
+ * function(event, unfoundState, fromState, fromParams){
+ *     console.log(unfoundState.to); // "lazy.state"
+ *     console.log(unfoundState.toParams); // {a:1, b:2}
+ *     console.log(unfoundState.options); // {inherit:false} + default options
+ * });
+ * ```
+ *
+ * @event $stateNotFound
+ * @deprecated
+ */
+var $stateNotFound;
+(function () {
+    var isFunction = ng.isFunction, isString = ng.isString;
+    function applyPairs(memo, keyValTuple) {
+        var key, value;
+        if (Array.isArray(keyValTuple))
+            key = keyValTuple[0], value = keyValTuple[1];
+        if (!isString(key))
+            throw new Error("invalid parameters to applyPairs");
+        memo[key] = value;
+        return memo;
+    }
+    function stateChangeStartHandler($transition$) {
+        if (!$transition$.options().notify || !$transition$.valid() || $transition$.ignored())
+            return;
+        var $injector = $transition$.injector();
+        var $stateEvents = $injector.get('$stateEvents');
+        var $rootScope = $injector.get('$rootScope');
+        var $state = $injector.get('$state');
+        var $urlRouter = $injector.get('$urlRouter');
+        var enabledEvents = $stateEvents.provider.enabled();
+        var toParams = $transition$.params("to");
+        var fromParams = $transition$.params("from");
+        if (enabledEvents.$stateChangeSuccess) {
+            var startEvent = $rootScope.$broadcast('$stateChangeStart', $transition$.to(), toParams, $transition$.from(), fromParams, $transition$.options(), $transition$);
+            if (startEvent.defaultPrevented) {
+                if (enabledEvents.$stateChangeCancel) {
+                    $rootScope.$broadcast('$stateChangeCancel', $transition$.to(), toParams, $transition$.from(), fromParams, $transition$.options(), $transition$);
+                }
+                //Don't update and resync url if there's been a new transition started. see issue #2238, #600
+                if ($state.transition == null)
+                    $urlRouter.update();
+                return false;
+            }
+            // right after global state is updated
+            var successOpts = { priority: 9999 };
+            $transition$.onSuccess({}, function () {
+                $rootScope.$broadcast('$stateChangeSuccess', $transition$.to(), toParams, $transition$.from(), fromParams, $transition$.options(), $transition$);
+            }, successOpts);
+        }
+        if (enabledEvents.$stateChangeError) {
+            $transition$.promise["catch"](function (error) {
+                if (error && (error.type === 2 /* RejectType.SUPERSEDED */ || error.type === 3 /* RejectType.ABORTED */))
+                    return;
+                var evt = $rootScope.$broadcast('$stateChangeError', $transition$.to(), toParams, $transition$.from(), fromParams, error, $transition$.options(), $transition$);
+                if (!evt.defaultPrevented) {
+                    $urlRouter.update();
+                }
+            });
+        }
+    }
+    stateNotFoundHandler.$inject = ['$to$', '$from$', '$state', '$rootScope', '$urlRouter'];
+    function stateNotFoundHandler($to$, $from$, injector) {
+        var $state = injector.get('$state');
+        var $rootScope = injector.get('$rootScope');
+        var $urlRouter = injector.get('$urlRouter');
+        var redirect = { to: $to$.identifier(), toParams: $to$.params(), options: $to$.options() };
+        var e = $rootScope.$broadcast('$stateNotFound', redirect, $from$.state(), $from$.params());
+        if (e.defaultPrevented || e.retry)
+            $urlRouter.update();
+        function redirectFn() {
+            return $state.target(redirect.to, redirect.toParams, redirect.options);
+        }
+        if (e.defaultPrevented) {
+            return false;
+        }
+        else if (e.retry || !!$state.get(redirect.to)) {
+            return e.retry && isFunction(e.retry.then) ? e.retry.then(redirectFn) : redirectFn();
+        }
+    }
+    $StateEventsProvider.$inject = ['$stateProvider'];
+    function $StateEventsProvider($stateProvider) {
+        $StateEventsProvider.prototype.instance = this;
+        var runtime = false;
+        var allEvents = ['$stateChangeStart', '$stateNotFound', '$stateChangeSuccess', '$stateChangeError'];
+        var enabledStateEvents = allEvents.map(function (e) { return [e, true]; }).reduce(applyPairs, {});
+        function assertNotRuntime() {
+            if (runtime)
+                throw new Error("Cannot enable events at runtime (use $stateEventsProvider");
+        }
+        /**
+         * Enables the deprecated UI-Router 0.2.x State Events
+         * [ '$stateChangeStart', '$stateNotFound', '$stateChangeSuccess', '$stateChangeError' ]
+         */
+        this.enable = function () {
+            var events = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                events[_i] = arguments[_i];
+            }
+            assertNotRuntime();
+            if (!events || !events.length)
+                events = allEvents;
+            events.forEach(function (event) { return enabledStateEvents[event] = true; });
+        };
+        /**
+         * Disables the deprecated UI-Router 0.2.x State Events
+         * [ '$stateChangeStart', '$stateNotFound', '$stateChangeSuccess', '$stateChangeError' ]
+         */
+        this.disable = function () {
+            var events = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                events[_i] = arguments[_i];
+            }
+            assertNotRuntime();
+            if (!events || !events.length)
+                events = allEvents;
+            events.forEach(function (event) { return delete enabledStateEvents[event]; });
+        };
+        this.enabled = function () { return enabledStateEvents; };
+        this.$get = $get;
+        $get.$inject = ['$transitions'];
+        function $get($transitions) {
+            runtime = true;
+            if (enabledStateEvents["$stateNotFound"])
+                $stateProvider.onInvalid(stateNotFoundHandler);
+            if (enabledStateEvents.$stateChangeStart)
+                $transitions.onBefore({}, stateChangeStartHandler, { priority: 1000 });
+            return {
+                provider: $StateEventsProvider.prototype.instance
+            };
+        }
+    }
+    ng.module('ui.router.state.events', ['ui.router.state'])
+        .provider("$stateEvents", $StateEventsProvider)
+        .run(['$stateEvents', function ($stateEvents) {
+        }]);
+})();
+
+exports.$stateChangeStart = $stateChangeStart;
+exports.$stateChangeCancel = $stateChangeCancel;
+exports.$stateChangeSuccess = $stateChangeSuccess;
+exports.$stateChangeError = $stateChangeError;
+exports.$stateNotFound = $stateNotFound;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=stateEvents.js.map