(js/css) Update generated files

UI/WebServerResources/js/Mailer.services.js

@@ -1,2 +1,2 @@
-!function(){"use strict";function e(t){"function"!=typeof t.then&&(angular.extend(this,t),_.forEach(this.identities,function(e){e.fullName?e.full=e.fullName+" <"+e.email+">":e.full="<"+e.email+">"}),e.$log.debug("Account: "+JSON.stringify(t,void 0,2)))}e.$factory=["$q","$timeout","$log","sgSettings","Resource","Preferences","Mailbox","Message",function(t,n,s,i,o,a,r,l){return angular.extend(e,{$q:t,$timeout:n,$log:s,$$resource:new o(i.activeUser("folderURL")+"Mail",i.activeUser()),$Preferences:a,$Mailbox:r,$Message:l}),e}];try{angular.module("SOGo.MailerUI")}catch(e){angular.module("SOGo.MailerUI",["SOGo.Common"])}angular.module("SOGo.MailerUI").factory("Account",e.$factory),e.$findAll=function(t){return t?e.$unwrapCollection(t):e.$$resource.fetch("","mailAccounts").then(function(t){return e.$unwrapCollection(t)})},e.$unwrapCollection=function(t){var n=[];return angular.forEach(t,function(t,s){t.id=s,n[s]=new e(t)}),e.$accounts=n,n},e.prototype.getLength=function(){return this.$flattenMailboxes().length},e.prototype.getItemAtIndex=function(e){var t;return t=this.$flattenMailboxes(),e>=0&&e<t.length?t[e]:null},e.prototype.$getMailboxes=function(t){var n=this;return!this.$mailboxes||t&&t.reload?e.$Mailbox.$find(this,t).then(function(t){n.$mailboxes=t,n.$expanded=!1;var s,i=function(e){_.forEach(e,function(e){e.$expanded=s.indexOf("/"+e.id)>=0,e.children&&e.children.length>0&&i(e.children)})};if(e.$Preferences.settings.Mail.ExpandedFolders){if(angular.isString(e.$Preferences.settings.Mail.ExpandedFolders))try{s=angular.fromJson(e.$Preferences.settings.Mail.ExpandedFolders)}catch(t){e.$log.warn("Can't parse list of expanded folders. String was: "+e.$Preferences.settings.Mail.ExpandedFolders),s=[]}else s=e.$Preferences.settings.Mail.ExpandedFolders;n.$expanded=s.indexOf("/"+n.id)>=0,s.length>0&&i(n.$mailboxes)}return e.$accounts&&(n.$expanded|=1==e.$accounts.length),n.$flattenMailboxes({reload:!0}),n.$mailboxes}):e.$q.when(this.$mailboxes)},e.prototype.$flattenMailboxes=function(t){var n=[],s=[],i=function(e){_.forEach(e,function(e){n.push(e),(t&&t.all||e.$expanded)&&e.children&&e.children.length>0&&i(e.children)})};return!this.$$flattenMailboxes||t&&(t.reload||t.all)?(i(this.$mailboxes),t&&t.all||(this.$$flattenMailboxes=n,t&&t.saveState&&(_.forEach(e.$accounts,function(e){e.$expanded&&s.push("/"+e.id),_.reduce(e.$$flattenMailboxes,function(e,t){return t.$expanded&&e.push("/"+t.id),e},s)}),e.$$resource.post(null,"saveFoldersState",s)))):n=this.$$flattenMailboxes,n},e.prototype.$getMailboxByType=function(e){var t=function(n){var s=_.find(n,function(t){return t.type==e});return s||angular.forEach(n,function(e){!s&&e.children&&e.children.length>0&&(s=t(e.children))}),s};return t(this.$mailboxes)},e.prototype.$getMailboxByPath=function(e){var t=function(n){var s=_.find(n,function(t){return t.path==e});return s||angular.forEach(n,function(e){!s&&e.children&&e.children.length>0&&(s=t(e.children))}),s};return t(this.$mailboxes)},e.prototype.$newMailbox=function(t,n){var s=this;return e.$$resource.post(t.toString(),"createFolder",{name:n}).then(function(){s.$getMailboxes({reload:!0})})},e.prototype.$certificate=function(){var t=this;return this.security&&this.security.hasCertificate?this.$$certificate?e.$q.when(this.$$certificate):e.$$resource.fetch(this.id.toString(),"certificate").then(function(e){return t.$$certificate=e,e}):e.$q.reject()},e.prototype.$removeCertificate=function(){var t=this;return e.$$resource.fetch(this.id.toString(),"removeCertificate").then(function(){t.security.hasCertificate=!1})},e.prototype.updateQuota=function(e){var t,n;t=Math.round(1e4*e.usedSpace/e.maxQuota)/100,n=l("quotasFormat").formatted(t,Math.round(e.maxQuota/10.24)/100),this.$quota={percent:t,description:n}},e.prototype.$newMessage=function(t){var n=this;return e.$$resource.fetch(this.id.toString(),"compose").then(function(t){e.$log.debug("New message (compose): "+JSON.stringify(t,void 0,2));return new e.$Message(t.accountId,n.$getMailboxByPath(t.mailboxPath),t)}).then(function(s){return e.$$resource.fetch(s.$absolutePath({asDraft:!0}),"edit").then(function(i){var o=e.$Preferences.defaults.AuxiliaryMailAccounts[n.id];return o.security&&(o.security.alwaysSign&&(i.sign=!0),o.security.alwaysEncrypt&&(i.encrypt=!0)),e.$log.debug("New message (edit): "+JSON.stringify(i,void 0,2)),angular.extend(s.editable,i),s.isNew=!0,t&&t.mailto&&(angular.isObject(t.mailto)?angular.extend(s.editable,t.mailto):s.$parseMailto(t.mailto)),s})})},e.prototype.$addDelegate=function(t){var n=this,s=e.$q.defer(),i={uid:t.uid};return!t.uid||_.indexOf(_.map(this.delegates,"uid"),t.uid)>-1?s.resolve():e.$$resource.fetch(this.id.toString(),"addDelegate",i).then(function(){n.delegates.push(t),s.resolve(n.users)},function(e,t){s.reject(l("An error occured please try again."))}),s.promise},e.prototype.$removeDelegate=function(t){var n=this,s={uid:t};return e.$$resource.fetch(this.id.toString(),"removeDelegate",s).then(function(){var e=_.indexOf(_.map(n.delegates,"uLine truncated
+!function(){"use strict";function e(t){"function"!=typeof t.then&&(angular.extend(this,t),_.forEach(this.identities,function(e){e.fullName?e.full=e.fullName+" <"+e.email+">":e.full="<"+e.email+">"}),e.$log.debug("Account: "+JSON.stringify(t,void 0,2)))}e.$factory=["$q","$timeout","$log","sgSettings","Resource","Preferences","Mailbox","Message",function(t,n,s,i,o,a,r,l){return angular.extend(e,{$q:t,$timeout:n,$log:s,$$resource:new o(i.activeUser("folderURL")+"Mail",i.activeUser()),$Preferences:a,$Mailbox:r,$Message:l}),e}];try{angular.module("SOGo.MailerUI")}catch(e){angular.module("SOGo.MailerUI",["SOGo.Common"])}angular.module("SOGo.MailerUI").factory("Account",e.$factory),e.$findAll=function(t){return t?e.$unwrapCollection(t):e.$$resource.fetch("","mailAccounts").then(function(t){return e.$unwrapCollection(t)})},e.$unwrapCollection=function(t){var n=[];return angular.forEach(t,function(t,s){t.id=s,n[s]=new e(t)}),e.$accounts=n,n},e.prototype.getLength=function(){return this.$flattenMailboxes().length},e.prototype.getItemAtIndex=function(e){var t;return t=this.$flattenMailboxes(),e>=0&&e<t.length?t[e]:null},e.prototype.$getMailboxes=function(t){var n=this;return!this.$mailboxes||t&&t.reload?e.$Mailbox.$find(this,t).then(function(t){n.$mailboxes=t,n.$expanded=!1;var s,i=function(e){_.forEach(e,function(e){e.$expanded=s.indexOf("/"+e.id)>=0,e.children&&e.children.length>0&&i(e.children)})};if(e.$Preferences.settings.Mail.ExpandedFolders){if(angular.isString(e.$Preferences.settings.Mail.ExpandedFolders))try{s=angular.fromJson(e.$Preferences.settings.Mail.ExpandedFolders)}catch(t){e.$log.warn("Can't parse list of expanded folders. String was: "+e.$Preferences.settings.Mail.ExpandedFolders),s=[]}else s=e.$Preferences.settings.Mail.ExpandedFolders;n.$expanded=s.indexOf("/"+n.id)>=0,s.length>0&&i(n.$mailboxes)}return e.$accounts&&(n.$expanded|=1==e.$accounts.length),n.$flattenMailboxes({reload:!0}),n.$mailboxes}):e.$q.when(this.$mailboxes)},e.prototype.$flattenMailboxes=function(t){var n=[],s=[],i=function(e){_.forEach(e,function(e){n.push(e),(t&&t.all||e.$expanded)&&e.children&&e.children.length>0&&i(e.children)})};return!this.$$flattenMailboxes||t&&(t.reload||t.all)?(i(this.$mailboxes),t&&t.all||(this.$$flattenMailboxes=n,t&&t.saveState&&(_.forEach(e.$accounts,function(e){e.$expanded&&s.push("/"+e.id),_.reduce(e.$$flattenMailboxes,function(e,t){return t.$expanded&&e.push("/"+t.id),e},s)}),e.$$resource.post(null,"saveFoldersState",s)))):n=this.$$flattenMailboxes,n},e.prototype.$getMailboxByType=function(e){var t=function(n){var s=_.find(n,function(t){return t.type==e});return s||angular.forEach(n,function(e){!s&&e.children&&e.children.length>0&&(s=t(e.children))}),s};return t(this.$mailboxes)},e.prototype.$getMailboxByPath=function(e){var t=function(n){var s=_.find(n,function(t){return t.path==e});return s||angular.forEach(n,function(e){!s&&e.children&&e.children.length>0&&(s=t(e.children))}),s};return t(this.$mailboxes)},e.prototype.$newMailbox=function(t,n){var s=this;return e.$$resource.post(t.toString(),"createFolder",{name:n}).then(function(){s.$getMailboxes({reload:!0})})},e.prototype.$certificate=function(){var t=this;return this.security&&this.security.hasCertificate?this.$$certificate?e.$q.when(this.$$certificate):e.$$resource.fetch(this.id.toString(),"certificate").then(function(e){return t.$$certificate=e,e}):e.$q.reject()},e.prototype.$removeCertificate=function(){var t=this;return e.$$resource.fetch(this.id.toString(),"removeCertificate").then(function(){t.security.hasCertificate=!1})},e.prototype.updateQuota=function(e){var t,n;t=Math.round(1e4*e.usedSpace/e.maxQuota)/100,n=l("quotasFormat").formatted(t,Math.round(e.maxQuota/10.24)/100),this.$quota={percent:t,description:n}},e.prototype.$newMessage=function(t){var n=this;return e.$$resource.fetch(this.id.toString(),"compose").then(function(t){e.$log.debug("New message (compose): "+JSON.stringify(t,void 0,2));return new e.$Message(t.accountId,n.$getMailboxByPath(t.mailboxPath),t)}).then(function(s){return e.$$resource.fetch(s.$absolutePath({asDraft:!0}),"edit").then(function(i){var o=e.$Preferences.defaults.AuxiliaryMailAccounts[n.id];return o.security&&(o.security.alwaysSign&&(i.sign=!0),o.security.alwaysEncrypt&&(i.encrypt=!0)),e.$log.debug("New message (edit): "+JSON.stringify(i,void 0,2)),angular.extend(s.editable,i),s.isNew=!0,t&&t.mailto&&(angular.isObject(t.mailto)?angular.extend(s.editable,t.mailto):s.$parseMailto(t.mailto)),s})})},e.prototype.$addDelegate=function(t){var n=this,s=e.$q.defer(),i={uid:t.uid};return!t.uid||_.indexOf(_.map(this.delegates,"uid"),t.uid)>-1?s.resolve():e.$$resource.fetch(this.id.toString(),"addDelegate",i).then(function(){n.delegates.push(t),s.resolve(n.users)},function(e,t){s.reject(l("An error occured please try again."))}),s.promise},e.prototype.$removeDelegate=function(t){var n=this,s={uid:t};return e.$$resource.fetch(this.id.toString(),"removeDelegate",s).then(function(){var e=_.indexOf(_.map(n.delegates,"uLine truncated
 //# sourceMappingURL=Mailer.services.js.map

UI/WebServerResources/js/Mailer.services.js.map

@@ -1 +1 @@
-{"version":3,"sources":["Mailer/Account.service.js","Mailer/Mailbox.service.js","Mailer/Message.service.js","Mailer/sgImageGallery.service.js","Mailer/VirtualMailbox.service.js","Mailer/MailboxController.js","Mailer/MailboxesController.js","Mailer/MessageController.js","Mailer/MessageEditorController.js","Mailer/sgAccountSection.directive.js","Mailer/sgIMIP.directive.js","Mailer/sgMailboxListItem.directive.js","Mailer/sgMessageListItem.directive.js","Mailer/sgMessageListItemMain.directive.js","Mailer/sgZoomableImage.directive.js"],"names":["Account","futureAccountData","then","angular","extend","this","_","forEach","identities","identity","fullName","full","email","$log","debug","JSON","stringify","undefined","$factory","$q","$timeout","Settings","Resource","Preferences","Mailbox","Message","$$resource","activeUser","$Preferences","$Mailbox","$Message","module","e","factory","$findAll","data","$unwrapCollection","fetch","o","collection","i","id","$accounts","prototype","getLength","$flattenMailboxes","length","getItemAtIndex","index","expandedMailboxes","$getMailboxes","options","_this","$mailboxes","reload","$find","$expanded","expandedFolders","_visit","mailboxes","indexOf","children","settings","Mail","ExpandedFolders","isString","fromJson","warn","when","allMailboxes","push","all","$$flattenMailboxes","saveState","account","reduce","mailbox","post","$getMailboxByType","type","_find","find","$getMailboxByPath","path","$newMailbox","name","toString","$certificate","security","hasCertificate","$$certificate","reject","$removeCertificate","updateQuota","percent","description","Math","round","usedSpace","maxQuota","l","formatted","$quota","$newMessage","accountId","mailboxPath","message","$absolutePath","asDraft","accountDefaults","defaults","AuxiliaryMailAccounts","alwaysSign","sign","alwaysEncrypt","encrypt","editable","isNew","mailto","isObject","$parseMailto","$addDelegate","user","deferred","defer","param","uid","map","delegates","resolve","users","status","promise","$removeDelegate","splice","futureMailboxData","$account","init","newMailboxData","create","$unwrap","Acl","PRELOAD","$$Acl","$query","sort","asc","selectedFolder","$refreshTimeout","$virtualMode","$virtualPath","SortingState","parseInt","constant","LOOKAHEAD","SIZE","createMailboxes","level","quotas","split","component","asCSSIdentifier","join","isUndefined","uidsMap","headers","$isLoading","$messages","$id","$acl","$displayName","$isEditable","isEditable","$isSpecial","$icon","$isNoInferiors","isNoInferiors","$shadowData","$omit","selectFolder","$lastVisibleIndex","max","$loadMessage","$selectedMessages","filter","selected","$selectedCount","isSelectedMessage","messageId","selectedMessage","$selectedMessage","$selectedMessageIndex","hasSelectedMessage","isDefined","$filter","sortingAttributes","filters","unseenCount","cancel","searchInput","secondFilter","match","searchBy","copy","refreshViewCheck","SOGoRefreshViewCheck","f","bind","timeInterval","endIndex","uids","futureHeadersData","startIndex","loaded","subject","min","loading","$unwrapHeaders","flags","isNoSelect","getClassName","base","$rename","findParent","parent","parentMailbox","$save","sibling","oldPath","localeCompare","pathRE","RegExp","_updateChildren","child","replace","$compact","$canFolderAs","$setFolderAs","$emptyTrash","$markAsRead","isread","$flagMessages","messages","operation","msgUIDs","saveSelectedMessages","selectedMessages","selectedUIDs","filename","download","exportFolder","$delete","$_deleteMessages","unseen","firstIndex","forEachRight","selectedIndex","findIndex","$deleteMessages","$markOrUnMarkMessagesAsJunk","method","$copyMessages","folder","$moveMessages","$reset","value","key","save","response","error","$futureMailboxData","$topIndex","invokeMap","threaded","msgs","msg","msgObject","zipObject","isError","j","messageHeaders","$updateSubscribe","action","subscribed","futureMessageData","lazy","$mailbox","$hasUnsafeContent","$loadUnsafeContent","to","cc","bcc","$formatFullAddresses","Message_STATUS","STATUS","$avatar","avatar","SOGoMailLabelsColors","$tags","SOGoMailDisplayRemoteInlineImages","$displayRemoteInlineImages","NOT_LOADED","DELAYED_LOADING","LOADING","LOADED","DELAYED_MS","filterTags","query","excludedTags","re","results","keys","tag","pair","search","includes","color","buildPath","nocache","draftId","withResourcePath","$setUID","oldUID","attr","constructor","shortname","first","last","image","$shortRecipients","result","count","total","$shortAddress","address","allowReplyAll","recipientsCount","isDraft","loadUnsafeContent","$parts","$content","parts","part","msgclass","content","alternatePart","preferredPart","contentType","isArray","signed","valid","certificate","certificates","encrypted","mixedPart","safeContent","html","unsafeContent","document","createElement","innerHTML","suffix","element","elements","querySelectorAll","removeAttr","compile","$editableContent","from","toLowerCase","text","$plainContent","addTag","$addOrRemoveTag","removeTag"Line truncated
+{"version":3,"sources":["Mailer/Account.service.js","Mailer/Mailbox.service.js","Mailer/Message.service.js","Mailer/sgImageGallery.service.js","Mailer/VirtualMailbox.service.js","Mailer/MailboxController.js","Mailer/MailboxesController.js","Mailer/MessageController.js","Mailer/MessageEditorController.js","Mailer/sgAccountSection.directive.js","Mailer/sgIMIP.directive.js","Mailer/sgMailboxListItem.directive.js","Mailer/sgMessageListItem.directive.js","Mailer/sgMessageListItemMain.directive.js","Mailer/sgZoomableImage.directive.js"],"names":["Account","futureAccountData","then","angular","extend","this","_","forEach","identities","identity","fullName","full","email","$log","debug","JSON","stringify","undefined","$factory","$q","$timeout","Settings","Resource","Preferences","Mailbox","Message","$$resource","activeUser","$Preferences","$Mailbox","$Message","module","e","factory","$findAll","data","$unwrapCollection","fetch","o","collection","i","id","$accounts","prototype","getLength","$flattenMailboxes","length","getItemAtIndex","index","expandedMailboxes","$getMailboxes","options","_this","$mailboxes","reload","$find","$expanded","expandedFolders","_visit","mailboxes","indexOf","children","settings","Mail","ExpandedFolders","isString","fromJson","warn","when","allMailboxes","push","all","$$flattenMailboxes","saveState","account","reduce","mailbox","post","$getMailboxByType","type","_find","find","$getMailboxByPath","path","$newMailbox","name","toString","$certificate","security","hasCertificate","$$certificate","reject","$removeCertificate","updateQuota","percent","description","Math","round","usedSpace","maxQuota","l","formatted","$quota","$newMessage","accountId","mailboxPath","message","$absolutePath","asDraft","accountDefaults","defaults","AuxiliaryMailAccounts","alwaysSign","sign","alwaysEncrypt","encrypt","editable","isNew","mailto","isObject","$parseMailto","$addDelegate","user","deferred","defer","param","uid","map","delegates","resolve","users","status","promise","$removeDelegate","splice","futureMailboxData","$account","init","newMailboxData","create","$unwrap","Acl","PRELOAD","$$Acl","$query","sort","asc","selectedFolder","$refreshTimeout","$virtualMode","$virtualPath","SortingState","parseInt","constant","LOOKAHEAD","SIZE","createMailboxes","level","quotas","split","component","asCSSIdentifier","join","isUndefined","uidsMap","headers","$isLoading","$messages","$id","$acl","$displayName","$isEditable","isEditable","$isSpecial","$icon","$isNoInferiors","isNoInferiors","$shadowData","$omit","selectFolder","$lastVisibleIndex","max","$loadMessage","$selectedMessages","filter","selected","$selectedCount","isSelectedMessage","messageId","selectedMessage","$selectedMessage","$selectedMessageIndex","hasSelectedMessage","isDefined","$filter","sortingAttributes","filters","unseenCount","cancel","searchInput","secondFilter","match","searchBy","copy","refreshViewCheck","SOGoRefreshViewCheck","f","bind","timeInterval","endIndex","uids","futureHeadersData","startIndex","loaded","subject","min","loading","$unwrapHeaders","flags","isNoSelect","getClassName","base","$rename","findParent","parent","parentMailbox","$save","sibling","oldPath","localeCompare","pathRE","RegExp","_updateChildren","child","replace","$compact","$canFolderAs","$setFolderAs","$emptyTrash","$markAsRead","isread","$flagMessages","messages","operation","msgUIDs","saveSelectedMessages","selectedMessages","selectedUIDs","filename","download","exportFolder","$delete","$_deleteMessages","unseen","firstIndex","forEachRight","selectedIndex","findIndex","$deleteMessages","$markOrUnMarkMessagesAsJunk","method","$copyMessages","folder","$moveMessages","$reset","value","key","save","response","error","$futureMailboxData","$topIndex","invokeMap","threaded","msgs","msg","msgObject","zipObject","isError","j","messageHeaders","$updateSubscribe","action","subscribed","futureMessageData","lazy","$mailbox","$hasUnsafeContent","$loadUnsafeContent","to","cc","bcc","$formatFullAddresses","Message_STATUS","STATUS","$avatar","avatar","SOGoMailLabelsColors","$tags","SOGoMailDisplayRemoteInlineImages","$displayRemoteInlineImages","NOT_LOADED","DELAYED_LOADING","LOADING","LOADED","DELAYED_MS","filterTags","query","excludedTags","re","results","keys","tag","pair","search","includes","color","buildPath","nocache","draftId","withResourcePath","$setUID","oldUID","attr","constructor","shortname","first","last","image","$shortRecipients","result","count","total","$shortAddress","address","allowReplyAll","recipientsCount","isDraft","loadUnsafeContent","$parts","$content","parts","part","msgclass","content","alternatePart","preferredPart","contentType","isArray","signed","valid","certificate","certificates","encrypted","mixedPart","safeContent","html","unsafeContent","document","createElement","innerHTML","suffix","element","elements","querySelectorAll","removeAttr","compile","$editableContent","from","toLowerCase","text","$plainContent","addTag","$addOrRemoveTag","removeTag"Line truncated

UI/WebServerResources/js/vendor/angular-ui-router.js

@@ -4,7 +4,7 @@
  *         This causes it to be incompatible with plugins that depend on @uirouter/core.
  *         We recommend switching to the ui-router-core.js and ui-router-angularjs.js bundles instead.
  *         For more information, see https://ui-router.github.io/blog/uirouter-for-angularjs-umd-bundles
- * @version v1.0.13
+ * @version v1.0.14
  * @link https://ui-router.github.io
  * @license MIT License, http://www.opensource.org/licenses/MIT
  */
@@ -715,10 +715,10 @@ function find(collection, callback) {
 /** Given an object, returns a new object, where each property is transformed by the callback function */
 var mapObj = map;
 /** Maps an array or object properties using a callback function */
-function map(collection, callback) {
-    var result = isArray(collection) ? [] : {};
-    forEach(collection, function (item, i) { return result[i] = callback(item, i); });
-    return result;
+function map(collection, callback, target) {
+    target = target || (isArray(collection) ? [] : {});
+    forEach(collection, function (item, i) { return target[i] = callback(item, i); });
+    return target;
 }
 /**
  * Given an object, return its enumerable property values
@@ -1030,19 +1030,27 @@ var silentRejection = function (error) {
 
 /**
  * @module common
- */ /** for typedoc */
+ */
+/** for typedoc */
 var Queue = /** @class */ (function () {
     function Queue(_items, _limit) {
         if (_items === void 0) { _items = []; }
         if (_limit === void 0) { _limit = null; }
         this._items = _items;
         this._limit = _limit;
+        this._evictListeners = [];
+        this.onEvict = pushTo(this._evictListeners);
     }
     Queue.prototype.enqueue = function (item) {
         var items = this._items;
         items.push(item);
         if (this._limit && items.length > this._limit)
-            items.shift();
+            this.evict();
+        return item;
+    };
+    Queue.prototype.evict = function () {
+        var item = this._items.shift();
+        this._evictListeners.forEach(function (fn) { return fn(item); });
         return item;
     };
     Queue.prototype.dequeue = function () {
@@ -1849,7 +1857,7 @@ var RegisteredHook = /** @class */ (function () {
      * }
      */
     RegisteredHook.prototype._getDefaultMatchCriteria = function () {
-        return map(this.tranSvc._pluginapi._getPathTypes(), function () { return true; });
+        return mapObj(this.tranSvc._pluginapi._getPathTypes(), function () { return true; });
     };
     /**
      * Gets matching nodes as [[IMatchingNodes]]
@@ -2384,9 +2392,8 @@ var PathNode = /** @class */ (function () {
             this.resolvables = state.resolvables.map(function (res) { return res.clone(); });
         }
     }
-    /** Returns a clone of the PathNode */
-    PathNode.clone = function (node) {
-        return new PathNode(node);
+    PathNode.prototype.clone = function () {
+        return new PathNode(this);
     };
     /** Sets [[paramValues]] for the node, from the values of an object hash */
     PathNode.prototype.applyRawParams = function (params) {
@@ -2424,6 +2431,11 @@ var PathNode = /** @class */ (function () {
         var params = paramsFn ? paramsFn(this) : this.paramSchema;
         return Param.changed(params, this.paramValues, node.paramValues);
     };
+    /**
+     * Returns a clone of the PathNode
+     * @deprecated use instance method `node.clone()`
+     */
+    PathNode.clone = function (node) { return node.clone(); };
     return PathNode;
 }());
 
@@ -2518,17 +2530,19 @@ var PathUtils = /** @class */ (function () {
         }
         /** Given a retained node, return a new node which uses the to node's param values */
         function applyToParams(retainedNode, idx) {
-            var cloned = PathNode.clone(retainedNode);
+            var cloned = retainedNode.clone();
             cloned.paramValues = toPath[idx].paramValues;
             return cloned;
         }
         var from, retained, exiting, entering, to;
         from = fromPath;
-        retained = from.slice(0, keep).map(applyToParams); // applyToParams to update dynamic params
+        retained = from.slice(0, keep);
         exiting = from.slice(keep);
+        // Create a new retained path (with shallow copies of nodes) which have the params of the toPath mapped
+        var retainedWithToParams = retained.map(applyToParams);
         entering = toPath.slice(keep);
-        to = (retained).concat(entering);
-        return { from: from, to: to, retained: retained, exiting: exiting, entering: entering };
+        to = (retainedWithToParams).concat(entering);
+        return { from: from, to: to, retained: retained, retainedWithToParams: retainedWithToParams, exiting: exiting, entering: entering };
     };
     /**
      * Returns a new path which is: the subpath of the first path which matches the second path.
@@ -2633,7 +2647,7 @@ var Resolvable = /** @class */ (function () {
             this.resolved = data !== undefined;
             this.promise = this.resolved ? services.$q.when(this.data) : undefined;
         }
-        else if (isObject(arg1) && arg1.token && isFunction(arg1.resolveFn)) {
+        else if (isObject(arg1) && arg1.token && (arg1.hasOwnProperty('resolveFn') || arg1.hasOwnProperty('data'))) {
             var literal = arg1;
             return new Resolvable(literal.token, literal.resolveFn, literal.deps, literal.policy, literal.data);
         }
@@ -2686,6 +2700,7 @@ var Resolvable = /** @class */ (function () {
         var applyResolvedValue = function (resolvedValue) {
             _this.data = resolvedValue;
             _this.resolved = true;
+            _this.resolveFn = null;
             trace.traceResolvableResolved(_this, trans);
             return _this.data;
         };
@@ -5999,10 +6014,10 @@ var UIRouter = /** @class */ (function () {
         this.trace = trace;
         /** Provides services related to ui-view synchronization */
         this.viewService = new ViewService();
-        /** Provides services related to Transitions */
-        this.transitionService = new TransitionService(this);
         /** Global router state */
         this.globals = new UIRouterGlobals();
+        /** Provides services related to Transitions */
+        this.transitionService = new TransitionService(this);
         /**
          * Deprecated for public use. Use [[urlService]] instead.
          * @deprecated Use [[urlService]] instead
@@ -6130,17 +6145,35 @@ var UIRouter = /** @class */ (function () {
 
 /** @module hooks */ /** */
 function addCoreResolvables(trans) {
-    trans.addResolvable({ token: UIRouter, deps: [], resolveFn: function () { return trans.router; }, data: trans.router }, '');
-    trans.addResolvable({ token: Transition, deps: [], resolveFn: function () { return trans; }, data: trans }, '');
-    trans.addResolvable({ token: '$transition$', deps: [], resolveFn: function () { return trans; }, data: trans }, '');
-    trans.addResolvable({ token: '$stateParams', deps: [], resolveFn: function () { return trans.params(); }, data: trans.params() }, '');
+    trans.addResolvable(Resolvable.fromData(UIRouter, trans.router), '');
+    trans.addResolvable(Resolvable.fromData(Transition, trans), '');
+    trans.addResolvable(Resolvable.fromData('$transition$', trans), '');
+    trans.addResolvable(Resolvable.fromData('$stateParams', trans.params()), '');
     trans.entering().forEach(function (state) {
-        trans.addResolvable({ token: '$state$', deps: [], resolveFn: function () { return state; }, data: state }, state);
+        trans.addResolvable(Resolvable.fromData('$state$', state), state);
     });
 }
 var registerAddCoreResolvables = function (transitionService) {
     return transitionService.onCreate({}, addCoreResolvables);
 };
+var TRANSITION_TOKENS = ['$transition$', Transition];
+var isTransition = inArray(TRANSITION_TOKENS);
+// References to Transition in the treeChanges pathnodes makes all
+// previous Transitions reachable in memory, causing a memory leak
+// This function removes resolves for '$transition$' and `Transition` from the treeChanges.
+// Do not use this on current transitions, only on old ones.
+var treeChangesCleanup = function (trans) {
+    // If the resolvable is a Transition, return a new resolvable with null data
+    var replaceTransitionWithNull = function (r) {
+        return isTransition(r.token) ? Resolvable.fromData(r.token, null) : r;
+    };
+    var cleanPath = function (path) { return path.map(function (node) {
+        var resolvables = node.resolvables.map(replaceTransitionWithNull);
+        return extend(node.clone(), { resolvables: resolvables });
+    }); };
+    var treeChanges = trans.treeChanges();
+    mapObj(treeChanges, cleanPath, treeChanges);
+};
 
 /** @module hooks */ /** */
 /**
@@ -6601,6 +6634,7 @@ var TransitionService = /** @class */ (function () {
         this._defineCorePaths();
         this._defineCoreEvents();
         this._registerCoreTransitionHooks();
+        _router.globals.successfulTransitions.onEvict(treeChangesCleanup);
     }
     /**
      * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
@@ -7811,7 +7845,7 @@ var UIRouterPluginBase = /** @class */ (function () {
 
 
 
-var index$1 = Object.freeze({
+var index = Object.freeze({
 	root: root,
 	fromJson: fromJson,
 	toJson: toJson,
@@ -9325,6 +9359,17 @@ uiStateDirective = ['$uiRouter', '$timeout',
  * </div>
  * ```
  *
+ * Arrays are also supported as values in the `ngClass`-like interface.
+ * This allows multiple states to add `active` class.
+ *
+ * #### Example:
+ * Given the following template, with "admin.roles" being the current state, the class will be added too:
+ * ```html
+ * <div ui-sref-active="{'active': ['owner.**', 'admin.**']}">
+ *   <a ui-sref-active="active" ui-sref="admin.roles">Roles</a>
+ * </div>
+ * ```
+ *
  * When the current state is "admin.roles" the "active" class will be applied to both the `<div>` and `<a>` elements.
  * It is important to note that the state names/globs passed to `ui-sref-active` override any state provided by a linked `ui-sref`.
  *
@@ -9357,14 +9402,7 @@ uiSrefActiveDirective = ['$state', '$stateParams', '$interpolate', '$uiRouter',
                         // Fall back to using $interpolate below
                     }
                     uiSrefActive = uiSrefActive || $interpolate($attrs.uiSrefActive || '', false)($scope);
-                    if (isObject(uiSrefActive)) {
-                        forEach(uiSrefActive, function (stateOrName, activeClass) {
-                            if (isString(stateOrName)) {
-                                var ref = parseStateRef(stateOrName);
-                                addState(ref.state, $scope.$eval(ref.paramExpr), activeClass);
-                            }
-                        });
-                    }
+                    setStatesFromDefinitionObject(uiSrefActive);
                     // Allow uiSref to communicate with uiSrefActive[Equals]
                     this.$$addStateInfo = function (newState, newParams) {
                         // we already got an explicit state provided by ui-sref-active, so we
@@ -9379,11 +9417,45 @@ uiSrefActiveDirective = ['$state', '$stateParams', '$interpolate', '$uiRouter',
                     function updateAfterTransition(trans) {
                         trans.promise.then(update, noop);
                     }
-                    $scope.$on('$stateChangeSuccess', update);
-                    $scope.$on('$destroy', $uiRouter.transitionService.onStart({}, updateAfterTransition));
+                    $scope.$on('$destroy', setupEventListeners());
                     if ($uiRouter.globals.transition) {
                         updateAfterTransition($uiRouter.globals.transition);
                     }
+                    function setupEventListeners() {
+                        var deregisterStatesChangedListener = $uiRouter.stateRegistry.onStatesChanged(handleStatesChanged);
+                        var deregisterOnStartListener = $uiRouter.transitionService.onStart({}, updateAfterTransition);
+                        var deregisterStateChangeSuccessListener = $scope.$on('$stateChangeSuccess', update);
+                        return function cleanUp() {
+                            deregisterStatesChangedListener();
+                            deregisterOnStartListener();
+                            deregisterStateChangeSuccessListener();
+                        };
+                    }
+                    function handleStatesChanged() {
+                        setStatesFromDefinitionObject(uiSrefActive);
+                    }
+                    function setStatesFromDefinitionObject(statesDefinition) {
+                        if (isObject(statesDefinition)) {
+                            states = [];
+                            forEach(statesDefinition, function (stateOrName, activeClass) {
+                                // Helper function to abstract adding state.
+                                var addStateForClass = function (stateOrName, activeClass) {
+                                    var ref = parseStateRef(stateOrName);
+                                    addState(ref.state, $scope.$eval(ref.paramExpr), activeClass);
+                                };
+                                if (isString(stateOrName)) {
+                                    // If state is string, just add it.
+                                    addStateForClass(stateOrName, activeClass);
+                                }
+                                else if (isArray(stateOrName)) {
+                                    // If state is an array, iterate over it and add each array item individually.
+                                    forEach(stateOrName, function (stateOrName) {
+                                        addStateForClass(stateOrName, activeClass);
+                                    });
+                                }
+                            });
+                        }
+                    }
                     function addState(stateName, stateParams, activeClass) {
                         var state = $state.get(stateName, stateContext($element));
                         var stateInfo = {
@@ -9901,10 +9973,10 @@ ng.module('ui.router.state').provider('$uiViewScroll', $ViewScrollProvider);
  * Main entry point for angular 1.x build
  * @module ng1
  */ /** */
-var index = 'ui.router';
+var index$1 = 'ui.router';
 
-exports['default'] = index;
-exports.core = index$1;
+exports.default = index$1;
+exports.core = index;
 exports.watchDigests = watchDigests;
 exports.getLocals = getLocals;
 exports.getNg1ViewConfigFactory = getNg1ViewConfigFactory;

UI/WebServerResources/js/vendor/angular-ui-router.js.map

@@ -91,20 +91,20 @@
     "/**\n * @coreapi\n * @module state\n */\n/** for typedoc */\nimport { StateDeclaration, _ViewDeclaration, _StateDeclaration, LazyLoadResult } from './interface';\nimport { defaults, values, find, inherit } from '../common/common';\nimport { propEq } from '../common/hof';\nimport { Param } from '../params/param';\nimport { UrlMatcher } from '../url/urlMatcher';\nimport { Resolvable } from '../resolve/resolvable';\nimport { TransitionStateHookFn } from '../transition/interface';\nimport { TargetState } from './targetState';\nimport { Transition } from '../transition/transition';\nimport { Glob } from '../common/glob';\nimport { isObject, isFunction } from '../common/predicates';\n\n/**\n * Internal representation of a UI-Router state.\n *\n * Instances of this class are created when a [[StateDeclaration]] is registered with the [[StateRegistry]].\n *\n * A registered [[StateDeclaration]] is augmented with a getter ([[StateDeclaration.$$state]]) which returns the corresponding [[StateObject]] object.\n *\n * This class prototypally inherits from the corresponding [[StateDeclaration]].\n * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].\n */\nexport class StateObject {\n  /** The parent [[StateObject]] */\n  public parent: StateObject;\n\n  /** The name used to register the state */\n  public name: string;\n\n  /** Prototypally inherits from [[StateDeclaration.abstract]] */\n  public abstract: boolean;\n\n  /** Prototypally inherits from [[StateDeclaration.resolve]] */\n  public resolve: ({ [key: string]: (string|any[]|Function) }|any[]);\n\n  /** A list of [[Resolvable]] objects.  The internal representation of [[resolve]]. */\n  public resolvables: Resolvable[];\n\n  /** Prototypally inherits from [[StateDeclaration.resolvePolicy]] */\n  public resolvePolicy: any;\n\n  /** A compiled URLMatcher which detects when the state's URL is matched */\n  public url: UrlMatcher;\n\n  /** The parameters for the state, built from the URL and [[StateDeclaration.params]] */\n  public params: { [key: string]: Param };\n\n  /**\n   * The views for the state.\n   * Note: `@uirouter/core` does not register a builder for views.\n   * The framework specific code should register a `views` builder.\n   */\n  public views: { [key: string]: _ViewDeclaration; };\n\n  /**\n   * The original [[StateDeclaration]] used to build this [[StateObject]].\n   * Note: `this` object also prototypally inherits from the `self` declaration object.\n   */\n  public self: StateDeclaration;\n\n  /** The nearest parent [[StateObject]] which has a URL */\n  public navigable: StateObject;\n\n  /** The parent [[StateObject]] objects from this state up to the root */\n  public path: StateObject[];\n\n  /**\n   * Prototypally inherits from [[StateDeclaration.data]]\n   * Note: This is the only field on the [[StateDeclaration]] which is mutated.\n   * The definition object's `data` field is replaced with a new object\n   * which prototypally inherits from the parent state definition's `data` field.\n   */\n  public data: any;\n\n  /**\n   * An object containing the parent States' names as keys and\n   * true as their values.\n   */\n  public includes: { [name: string]: boolean };\n\n  /** Prototypally inherits from [[StateDeclaration.onExit]] */\n  public onExit: TransitionStateHookFn;\n  /** Prototypally inherits from [[StateDeclaration.onRetain]] */\n  public onRetain: TransitionStateHookFn;\n  /** Prototypally inherits from [[StateDeclaration.onEnter]] */\n  public onEnter: TransitionStateHookFn;\n\n  /** Prototypally inherits from [[StateDeclaration.lazyLoad]] */\n  public lazyLoad: (transition: Transition, state: StateDeclaration) => Promise<LazyLoadResult>;\n\n  /** Prototypally inherits from [[StateDeclaration.redirectTo]] */\n  redirectTo: (\n      string |\n      (($transition$: Transition) => TargetState) |\n      { state: (string|StateDeclaration), params: { [key: string]: any }}\n  );\n\n  /** @hidden */\n  __stateObjectCache: {\n    /** Might be null */\n    nameGlob?: Glob,\n  };\n\n  /**\n   * Create a state object to put the private/internal implementation details onto.\n   * The object's prototype chain looks like:\n   * (Internal State Object) -> (Copy of State.prototype) -> (State Declaration object) -> (State Declaration's prototype...)\n   *\n   * @param stateDecl the user-supplied State Declaration\n   * @returns {StateObject} an internal State object\n   */\n  static create(stateDecl: _StateDeclaration): StateObject {\n    stateDecl = StateObject.isStateClass(stateDecl) ? new stateDecl() : stateDecl;\n\n    const state = inherit(inherit(stateDecl, StateObject.prototype)) as StateObject;\n    stateDecl.$$state = () => state;\n    state.self = stateDecl;\n    state.__stateObjectCache = {\n      nameGlob: Glob.fromString(state.name), // might return null\n    };\n    return state;\n  }\n\n  /** Predicate which returns true if the object is an class with @State() decorator */\n Line truncated
     "/** Predicates\n *\n * These predicates return true/false based on the input.\n * Although these functions are exported, they are subject to change without notice.\n *\n * @module common_predicates\n */\n/** */\nimport { and, not, pipe, prop, or } from './hof';\nimport { Predicate } from './common'; // has or is using\nimport { StateObject } from '../state/stateObject';\n\nconst toStr = Object.prototype.toString;\nconst tis = (t: string) => (x: any) => typeof(x) === t;\nexport const isUndefined = tis('undefined');\nexport const isDefined = not(isUndefined);\nexport const isNull = (o: any) => o === null;\nexport const isNullOrUndefined = or(isNull, isUndefined);\nexport const isFunction: (x: any) => x is Function = <any> tis('function');\nexport const isNumber: (x: any) => x is number = <any> tis('number');\nexport const isString = <(x: any) => x is string> tis('string');\nexport const isObject = (x: any) => x !== null && typeof x === 'object';\nexport const isArray = Array.isArray;\nexport const isDate: (x: any) => x is Date = <any> ((x: any) => toStr.call(x) === '[object Date]');\nexport const isRegExp: (x: any) => x is RegExp = <any> ((x: any) => toStr.call(x) === '[object RegExp]');\nexport const isState: (x: any) => x is StateObject = StateObject.isState;\n\n/**\n * Predicate which checks if a value is injectable\n *\n * A value is \"injectable\" if it is a function, or if it is an ng1 array-notation-style array\n * where all the elements in the array are Strings, except the last one, which is a Function\n */\nexport function isInjectable(val: any) {\n  if (isArray(val) && val.length) {\n    const head = val.slice(0, -1), tail = val.slice(-1);\n    return !(head.filter(not(isString)).length || tail.filter(not(isFunction)).length);\n  }\n  return isFunction(val);\n}\n\n/**\n * Predicate which checks if a value looks like a Promise\n *\n * It is probably a Promise if it's an object, and it has a `then` property which is a Function\n */\nexport const isPromise = <(x: any) => x is Promise<any>> and(isObject, pipe(prop('then'), isFunction));\n\n",
     "/**\n * This module is a stub for core services such as Dependency Injection or Browser Location.\n * Core services may be implemented by a specific framework, such as ng1 or ng2, or be pure javascript.\n *\n * @module common\n */\n/** for typedoc */\nimport { IInjectable, Obj } from './common';\nimport { Disposable } from '../interface';\nimport { UrlParts } from '../url/interface';\n\nexport let notImplemented = (fnname: string) => () => {\n  throw new Error(`${fnname}(): No coreservices implementation for UI-Router is loaded.`);\n};\n\nconst services: CoreServices = {\n  $q: undefined,\n  $injector: undefined,\n};\n\nexport interface $QLikeDeferred {\n  resolve: (val?: any) => void;\n  reject: (reason?: any) => void;\n  promise: Promise<any>;\n}\n\nexport interface $QLike {\n  when<T>(value?: T | PromiseLike<T>): Promise<T>;\n  reject<T>(reason: any): Promise<T>;\n  defer(): $QLikeDeferred;\n  all(promises: { [key: string]: Promise<any> }): Promise<any>;\n  all(promises: Promise<any>[]): Promise<any[]>;\n}\n\nexport interface $InjectorLike {\n  strictDi?: boolean;\n  get(token: any): any;\n  get<T>(token: any): T;\n  has(token: any): boolean;\n  invoke(fn: IInjectable, context?: any, locals?: Obj): any;\n  annotate(fn: IInjectable, strictDi?: boolean): any[];\n}\n\nexport interface CoreServices {\n  $q: $QLike;\n  $injector: $InjectorLike;\n}\n\nexport interface LocationServices extends Disposable {\n  /**\n   * Gets the current url string\n   *\n   * The URL is normalized using the internal [[path]]/[[search]]/[[hash]] values.\n   *\n   * For example, the URL may be stored in the hash ([[HashLocationServices]]) or\n   * have a base HREF prepended ([[PushStateLocationServices]]).\n   *\n   * The raw URL in the browser might be:\n   *\n   * ```\n   * http://mysite.com/somepath/index.html#/internal/path/123?param1=foo#anchor\n   * ```\n   *\n   * or\n   *\n   * ```\n   * http://mysite.com/basepath/internal/path/123?param1=foo#anchor\n   * ```\n   *\n   * then this method returns:\n   *\n   * ```\n   * /internal/path/123?param1=foo#anchor\n   * ```\n   *\n   *\n   * #### Example:\n   * ```js\n   * locationServices.url(); // \"/some/path?query=value#anchor\"\n   * ```\n   *\n   * @returns the current value of the url, as a string.\n   */\n  url(): string;\n\n  /**\n   * Updates the url, or gets the current url\n   *\n   * Updates the url, changing it to the value in `newurl`\n   *\n   * #### Example:\n   * ```js\n   * locationServices.url(\"/some/path?query=value#anchor\", true);\n   * ```\n   *\n   * @param newurl The new value for the URL.\n   *               This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.\n   *               It should not include the protocol, site, port, or base path of an absolute HREF.\n   * @param replace When true, replaces the current history entry (instead of appending it) with this new url\n   * @param state The history's state object, i.e., pushState (if the LocationServices implementation supports it)\n   * @return the url (after potentially being processed)\n   */\n  url(newurl: string, replace?: boolean, state?: any): string;\n\n  /**\n   * Gets the path part of the current url\n   *\n   * If the current URL is `/some/path?query=value#anchor`, this returns `/some/path`\n   *\n   * @return the path portion of the url\n   */\n  path(): string;\n\n  /**\n   * Gets the search part of the current url as an object\n   *\n   * If the current URL is `/some/path?query=value#anchor`, this returns `{ query: 'value' }`\n   *\n   * @return the search (querystring) portion of the url, as an object\n   */\n  search(): { [key: string]: any };\n\n  /**\n   * Gets the hash part of the current url\n   *\n   * If the current URL is `/some/path?query=value#anchor`, this returns `anchor`\n   *\n   * @return the hash (anchor) portion of the url\n   */\n  hash(): string;\n\n  /**\n   * Registers a url change handler\n   *\n   * #### Example:\n   * ```js\n   * let deregisterFn = locationServices.onChange((evt) => console.log(\"url change\", evt));\n   * ```\n   *\n   * @param callback a function that will be called when the url is changing\n   * @return a function that de-registers the callback\n   */\n  onChange(callback: Function): Function;\n}\n\n/**\n * This service returns the location configuration\n *\n * This service returns information about the location configuration.\n * This service is primarily used when building URLs (e.g., for `hrefs`)\n */\nexport interface LocationConfig extends Disposable {\n  /**\n   * Gets the port, e.g., `80`\n   *\n   * @return the port number\n   */\n  port(): number;\n  /**\n   * Gets the protocol, e.g., `http`\n   *\n   * @return the protocol\n   */\n  protocol(): string;\n  /**\n   * Gets the host, e.g., `localhost`\n   *\n   * @return the protocol\n   */\n  host(): string;\n  /**\n   * Gets the base Href, e.g., `http://localhost/approot/`\n   *\n   * @return the application's base href\n   */\n  baseHref(): striLine truncated
-    "/**\n * Random utility functions used in the UI-Router code\n *\n * These functions are exported, but are subject to change without notice.\n *\n * @preferred\n * @module common\n */\n/** for typedoc */\nimport { isFunction, isString, isArray, isRegExp, isDate } from './predicates';\nimport { all, any, prop, curry, not } from './hof';\nimport { services } from './coreservices';\nimport { StateObject } from '../state/stateObject';\n\ndeclare const global;\nexport const root: any = (typeof self === 'object' && self.self === self && self) ||\n  (typeof global === 'object' && global.global === global && global) || this;\nconst angular = root.angular || {};\n\nexport const fromJson = angular.fromJson || JSON.parse.bind(JSON);\nexport const toJson = angular.toJson || JSON.stringify.bind(JSON);\nexport const forEach = angular.forEach || _forEach;\nexport const extend = Object.assign || _extend;\nexport const equals = angular.equals || _equals;\nexport function identity(x: any) { return x; }\nexport function noop(): any {}\n\nexport type Mapper<X, T> = (x: X, key?: (string|number)) => T;\nexport interface TypedMap<T> { [key: string]: T; }\nexport type Predicate<X> = (x?: X) => boolean;\n/**\n * An ng1-style injectable\n *\n * This could be a (non-minified) function such as:\n * ```js\n * function injectableFunction(SomeDependency) {\n *\n * }\n * ```\n *\n * or an explicitly annotated function (minify safe)\n * ```js\n * injectableFunction.$inject = [ 'SomeDependency' ];\n * function injectableFunction(SomeDependency) {\n *\n * }\n * ```\n *\n * or an array style annotated function (minify safe)\n * ```js\n * ['SomeDependency', function injectableFunction(SomeDependency) {\n *\n * }];\n * ```\n *\n * @publicapi\n */\nexport type IInjectable = (Function|any[]);\n\nexport interface Obj extends Object {\n  [key: string]: any;\n}\n\n/**\n * Builds proxy functions on the `to` object which pass through to the `from` object.\n *\n * For each key in `fnNames`, creates a proxy function on the `to` object.\n * The proxy function calls the real function on the `from` object.\n *\n *\n * #### Example:\n * This example creates an new class instance whose functions are prebound to the new'd object.\n * ```js\n * class Foo {\n *   constructor(data) {\n *     // Binds all functions from Foo.prototype to 'this',\n *     // then copies them to 'this'\n *     bindFunctions(Foo.prototype, this, this);\n *     this.data = data;\n *   }\n *\n *   log() {\n *     console.log(this.data);\n *   }\n * }\n *\n * let myFoo = new Foo([1,2,3]);\n * var logit = myFoo.log;\n * logit(); // logs [1, 2, 3] from the myFoo 'this' instance\n * ```\n *\n * #### Example:\n * This example creates a bound version of a service function, and copies it to another object\n * ```\n *\n * var SomeService = {\n *   this.data = [3, 4, 5];\n *   this.log = function() {\n *     console.log(this.data);\n *   }\n * }\n *\n * // Constructor fn\n * function OtherThing() {\n *   // Binds all functions from SomeService to SomeService,\n *   // then copies them to 'this'\n *   bindFunctions(SomeService, this, SomeService);\n * }\n *\n * let myOtherThing = new OtherThing();\n * myOtherThing.log(); // logs [3, 4, 5] from SomeService's 'this'\n * ```\n *\n * @param source A function that returns the source object which contains the original functions to be bound\n * @param target A function that returns the target object which will receive the bound functions\n * @param bind A function that returns the object which the functions will be bound to\n * @param fnNames The function names which will be bound (Defaults to all the functions found on the 'from' object)\n * @param latebind If true, the binding of the function is delayed until the first time it's invoked\n */\nexport function createProxyFunctions(source: Function, target: Obj, bind: Function, fnNames?: string[], latebind = false): Obj {\n  const bindFunction = (fnName) =>\n      source()[fnName].bind(bind());\n\n  const makeLateRebindFn = fnName => function lateRebindFunction() {\n    target[fnName] = bindFunction(fnName);\n    return target[fnName].apply(null, arguments);\n  };\n\n  fnNames = fnNames || Object.keys(source());\n\n  return fnNames.reduce((acc, name) => {\n    acc[name] = latebind ? makeLateRebindFn(name) : bindFunction(name);\n    return acc;\n  }, target);\n}\n\n\n/**\n * prototypal inheritance helper.\n * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it\n */\nexport const inherit = (parent: Obj, extra?: Obj) =>\n    extend(Object.create(parent), extra);\n\n/** Given an array, returns true if the object is found in the array, (using indexOf) */\nexport const inArray: typeof _inArray = curry(_inArray) as any;\nexport function _inArray(array: any[], obj: any): boolean;\nexport function _inArray(array: any[]): (obj: any) => boolean;\nexport function _inArray(array, obj?): any {\n  return array.indexOf(obj) !== -1;\n}\n\n/**\n * GivenLine truncated
-    "/**\n * @module common\n */ /** for typedoc */\n\nexport class Queue<T> {\n  constructor(private _items: T[] = [], private _limit: number = null) { }\n\n  enqueue(item: T) {\n    const items = this._items;\n    items.push(item);\n    if (this._limit && items.length > this._limit) items.shift();\n    return item;\n  }\n\n  dequeue(): T {\n    if (this.size())\n      return this._items.splice(0, 1)[0];\n  }\n\n  clear(): Array<T> {\n    const current = this._items;\n    this._items = [];\n    return current;\n  }\n\n  size(): number {\n    return this._items.length;\n  }\n\n  remove(item: T) {\n    const idx = this._items.indexOf(item);\n    return idx > -1 && this._items.splice(idx, 1)[0];\n  }\n\n  peekTail(): T {\n    return this._items[this._items.length - 1];\n  }\n\n  peekHead(): T {\n    if (this.size())\n      return this._items[0];\n  }\n}\n",
+    "/**\n * Random utility functions used in the UI-Router code\n *\n * These functions are exported, but are subject to change without notice.\n *\n * @preferred\n * @module common\n */\n/** for typedoc */\nimport { isFunction, isString, isArray, isRegExp, isDate } from './predicates';\nimport { all, any, prop, curry, not } from './hof';\nimport { services } from './coreservices';\nimport { StateObject } from '../state/stateObject';\n\ndeclare const global;\nexport const root: any = (typeof self === 'object' && self.self === self && self) ||\n  (typeof global === 'object' && global.global === global && global) || this;\nconst angular = root.angular || {};\n\nexport const fromJson = angular.fromJson || JSON.parse.bind(JSON);\nexport const toJson = angular.toJson || JSON.stringify.bind(JSON);\nexport const forEach = angular.forEach || _forEach;\nexport const extend = Object.assign || _extend;\nexport const equals = angular.equals || _equals;\nexport function identity(x: any) { return x; }\nexport function noop(): any {}\n\nexport type Mapper<X, T> = (x: X, key?: (string|number)) => T;\nexport interface TypedMap<T> { [key: string]: T; }\nexport type Predicate<X> = (x?: X) => boolean;\n/**\n * An ng1-style injectable\n *\n * This could be a (non-minified) function such as:\n * ```js\n * function injectableFunction(SomeDependency) {\n *\n * }\n * ```\n *\n * or an explicitly annotated function (minify safe)\n * ```js\n * injectableFunction.$inject = [ 'SomeDependency' ];\n * function injectableFunction(SomeDependency) {\n *\n * }\n * ```\n *\n * or an array style annotated function (minify safe)\n * ```js\n * ['SomeDependency', function injectableFunction(SomeDependency) {\n *\n * }];\n * ```\n *\n * @publicapi\n */\nexport type IInjectable = (Function|any[]);\n\nexport interface Obj extends Object {\n  [key: string]: any;\n}\n\n/**\n * Builds proxy functions on the `to` object which pass through to the `from` object.\n *\n * For each key in `fnNames`, creates a proxy function on the `to` object.\n * The proxy function calls the real function on the `from` object.\n *\n *\n * #### Example:\n * This example creates an new class instance whose functions are prebound to the new'd object.\n * ```js\n * class Foo {\n *   constructor(data) {\n *     // Binds all functions from Foo.prototype to 'this',\n *     // then copies them to 'this'\n *     bindFunctions(Foo.prototype, this, this);\n *     this.data = data;\n *   }\n *\n *   log() {\n *     console.log(this.data);\n *   }\n * }\n *\n * let myFoo = new Foo([1,2,3]);\n * var logit = myFoo.log;\n * logit(); // logs [1, 2, 3] from the myFoo 'this' instance\n * ```\n *\n * #### Example:\n * This example creates a bound version of a service function, and copies it to another object\n * ```\n *\n * var SomeService = {\n *   this.data = [3, 4, 5];\n *   this.log = function() {\n *     console.log(this.data);\n *   }\n * }\n *\n * // Constructor fn\n * function OtherThing() {\n *   // Binds all functions from SomeService to SomeService,\n *   // then copies them to 'this'\n *   bindFunctions(SomeService, this, SomeService);\n * }\n *\n * let myOtherThing = new OtherThing();\n * myOtherThing.log(); // logs [3, 4, 5] from SomeService's 'this'\n * ```\n *\n * @param source A function that returns the source object which contains the original functions to be bound\n * @param target A function that returns the target object which will receive the bound functions\n * @param bind A function that returns the object which the functions will be bound to\n * @param fnNames The function names which will be bound (Defaults to all the functions found on the 'from' object)\n * @param latebind If true, the binding of the function is delayed until the first time it's invoked\n */\nexport function createProxyFunctions(source: Function, target: Obj, bind: Function, fnNames?: string[], latebind = false): Obj {\n  const bindFunction = (fnName) =>\n      source()[fnName].bind(bind());\n\n  const makeLateRebindFn = fnName => function lateRebindFunction() {\n    target[fnName] = bindFunction(fnName);\n    return target[fnName].apply(null, arguments);\n  };\n\n  fnNames = fnNames || Object.keys(source());\n\n  return fnNames.reduce((acc, name) => {\n    acc[name] = latebind ? makeLateRebindFn(name) : bindFunction(name);\n    return acc;\n  }, target);\n}\n\n\n/**\n * prototypal inheritance helper.\n * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it\n */\nexport const inherit = (parent: Obj, extra?: Obj) =>\n    extend(Object.create(parent), extra);\n\n/** Given an array, returns true if the object is found in the array, (using indexOf) */\nexport const inArray: typeof _inArray = curry(_inArray) as any;\nexport function _inArray(array: any[], obj: any): boolean;\nexport function _inArray(array: any[]): (obj: any) => boolean;\nexport function _inArray(array, obj?): any {\n  return array.indexOf(obj) !== -1;\n}\n\n/**\n * GivenLine truncated
+    "import { pushTo } from './common';\n\n/**\n * @module common\n */\n/** for typedoc */\n\nexport class Queue<T> {\n  private _evictListeners: ((item: T) => void)[] = [];\n  public onEvict = pushTo(this._evictListeners);\n\n  constructor(private _items: T[] = [], private _limit: number = null) { }\n\n  enqueue(item: T) {\n    const items = this._items;\n    items.push(item);\n    if (this._limit && items.length > this._limit) this.evict();\n    return item;\n  }\n\n  evict(): T {\n    const item: T = this._items.shift();\n    this._evictListeners.forEach(fn => fn(item));\n    return item;\n  }\n\n  dequeue(): T {\n    if (this.size())\n      return this._items.splice(0, 1)[0];\n  }\n\n  clear(): Array<T> {\n    const current = this._items;\n    this._items = [];\n    return current;\n  }\n\n  size(): number {\n    return this._items.length;\n  }\n\n  remove(item: T) {\n    const idx = this._items.indexOf(item);\n    return idx > -1 && this._items.splice(idx, 1)[0];\n  }\n\n  peekTail(): T {\n    return this._items[this._items.length - 1];\n  }\n\n  peekHead(): T {\n    if (this.size())\n      return this._items[0];\n  }\n}\n",
     "/**\n * @coreapi\n * @module transition\n */ /** for typedoc */\n'use strict';\nimport { extend, silentRejection } from '../common/common';\nimport { stringify } from '../common/strings';\nimport { is } from '../common/hof';\n\nexport enum RejectType {\n  SUPERSEDED = 2, ABORTED = 3, INVALID = 4, IGNORED = 5, ERROR = 6,\n}\n\n/** @hidden */\nlet id = 0;\n\nexport class Rejection {\n  $id = id++;\n  type: number;\n  message: string;\n  detail: any;\n  redirected: boolean;\n\n  /** Returns true if the obj is a rejected promise created from the `asPromise` factory */\n  static isRejectionPromise(obj: any): boolean {\n    return obj && (typeof obj.then === 'function') && is(Rejection)(obj._transitionRejection);\n  }\n\n  /** Returns a Rejection due to transition superseded */\n  static superseded(detail?: any, options?: any): Rejection {\n    const message = 'The transition has been superseded by a different transition';\n    const rejection = new Rejection(RejectType.SUPERSEDED, message, detail);\n    if (options && options.redirected) {\n      rejection.redirected = true;\n    }\n    return rejection;\n  }\n\n  /** Returns a Rejection due to redirected transition */\n  static redirected(detail?: any): Rejection {\n    return Rejection.superseded(detail, { redirected: true });\n  }\n\n  /** Returns a Rejection due to invalid transition */\n  static invalid(detail?: any): Rejection {\n    const message = 'This transition is invalid';\n    return new Rejection(RejectType.INVALID, message, detail);\n  }\n\n  /** Returns a Rejection due to ignored transition */\n  static ignored(detail?: any): Rejection {\n    const message = 'The transition was ignored';\n    return new Rejection(RejectType.IGNORED, message, detail);\n  }\n\n  /** Returns a Rejection due to aborted transition */\n  static aborted(detail?: any): Rejection {\n    const message = 'The transition has been aborted';\n    return new Rejection(RejectType.ABORTED, message, detail);\n  }\n\n  /** Returns a Rejection due to aborted transition */\n  static errored(detail?: any): Rejection {\n    const message = 'The transition errored';\n    return new Rejection(RejectType.ERROR, message, detail);\n  }\n\n  /**\n   * Returns a Rejection\n   *\n   * Normalizes a value as a Rejection.\n   * If the value is already a Rejection, returns it.\n   * Otherwise, wraps and returns the value as a Rejection (Rejection type: ERROR).\n   *\n   * @returns `detail` if it is already a `Rejection`, else returns an ERROR Rejection.\n   */\n  static normalize(detail?: Rejection | Error | any): Rejection {\n    return is(Rejection)(detail) ? detail : Rejection.errored(detail);\n  }\n\n  constructor(type: number, message?: string, detail?: any) {\n    this.type = type;\n    this.message = message;\n    this.detail = detail;\n  }\n\n  toString() {\n    const detailString = (d: any) =>\n        d && d.toString !== Object.prototype.toString ? d.toString() : stringify(d);\n    const detail = detailString(this.detail);\n    const { $id, type, message } = this;\n    return `Transition Rejection($id: ${$id} type: ${type}, message: ${message}, detail: ${detail})`;\n  }\n\n  toPromise(): Promise<any> {\n    return extend(silentRejection(this), { _transitionRejection: this });\n  }\n}\n",
     "/**\n * # Transition tracing (debug)\n *\n * Enable transition tracing to print transition information to the console,\n * in order to help debug your application.\n * Tracing logs detailed information about each Transition to your console.\n *\n * To enable tracing, import the [[Trace]] singleton and enable one or more categories.\n *\n * ### ES6\n * ```js\n * import {trace} from \"ui-router-ng2\"; // or \"angular-ui-router\"\n * trace.enable(1, 5); // TRANSITION and VIEWCONFIG\n * ```\n *\n * ### CJS\n * ```js\n * let trace = require(\"angular-ui-router\").trace; // or \"ui-router-ng2\"\n * trace.enable(\"TRANSITION\", \"VIEWCONFIG\");\n * ```\n *\n * ### Globals\n * ```js\n * let trace = window[\"angular-ui-router\"].trace; // or \"ui-router-ng2\"\n * trace.enable(); // Trace everything (very verbose)\n * ```\n *\n * ### Angular 1:\n * ```js\n * app.run($trace => $trace.enable());\n * ```\n *\n * @coreapi\n * @module trace\n */\n/* tslint:disable:no-console */\nimport { parse } from '../common/hof';\nimport { isFunction, isNumber } from '../common/predicates';\nimport { Transition } from '../transition/transition';\nimport { ViewTuple } from '../view';\nimport { ActiveUIView, ViewConfig, ViewContext } from '../view/interface';\nimport { stringify, functionToString, maxLength, padString } from './strings';\nimport { Resolvable } from '../resolve/resolvable';\nimport { PathNode } from '../path/pathNode';\nimport { PolicyWhen } from '../resolve/interface';\nimport { TransitionHook } from '../transition/transitionHook';\nimport { HookResult } from '../transition/interface';\nimport { StateObject } from '../state/stateObject';\n\n/** @hidden */\nfunction uiViewString (uiview: ActiveUIView) {\n    if (!uiview) return 'ui-view (defunct)';\n    const state = uiview.creationContext ? uiview.creationContext.name || '(root)' : '(none)';\n    return `[ui-view#${uiview.id} ${uiview.$type}:${uiview.fqn} (${uiview.name}@${state})]`;\n}\n\n/** @hidden */\nconst viewConfigString = (viewConfig: ViewConfig) => {\n  const view = viewConfig.viewDecl;\n  const state = view.$context.name || '(root)';\n  return `[View#${viewConfig.$id} from '${state}' state]: target ui-view: '${view.$uiViewName}@${view.$uiViewContextAnchor}'`;\n};\n\n/** @hidden */\nfunction normalizedCat(input: Category|string): string {\n  return isNumber(input) ? Category[input] : Category[Category[input]];\n}\n\n/** @hidden */\nconst consoleLog = Function.prototype.bind.call(console.log, console);\n\n/** @hidden */\nconst consoletable = isFunction(console.table) ? console.table.bind(console) : consoleLog.bind(console);\n\n\n/**\n * Trace categories Enum\n *\n * Enable or disable a category using [[Trace.enable]] or [[Trace.disable]]\n *\n * `trace.enable(Category.TRANSITION)`\n *\n * These can also be provided using a matching string, or position ordinal\n *\n * `trace.enable(\"TRANSITION\")`\n *\n * `trace.enable(1)`\n */\nexport enum Category {\n  RESOLVE, TRANSITION, HOOK, UIVIEW, VIEWCONFIG,\n}\n\n/** @hidden */\nconst _tid = parse('$id');\n\n/** @hidden */\nconst _rid = parse('router.$id');\n\n/** @hidden */\nconst transLbl = (trans) => `Transition #${_tid(trans)}-${_rid(trans)}`;\n\n/**\n * Prints UI-Router Transition trace information to the console.\n */\nexport class Trace {\n  /** @hidden */\n  approximateDigests: number;\n\n  /** @hidden */\n  private _enabled: { [key: string]: boolean } = {};\n\n  /** @hidden */\n  constructor() {\n    this.approximateDigests = 0;\n  }\n\n   /** @hidden */\n  private _set(enabled: boolean, categories: Category[]) {\n    if (!categories.length) {\n      categories = <any> Object.keys(Category)\n          .map(k => parseInt(k, 10))\n          .filter(k => !isNaN(k))\n          .map(key => Category[key]);\n    }\n    categories.map(normalizedCat).forEach(category => this._enabled[category] = enabled);\n  }\n\n  /**\n   * Enables a trace [[Category]]\n   *\n   * ```js\n   * trace.enable(\"TRANSITION\");\n   * ```\n   *\n   * @param categories categories to enable. If `categories` is omitted, all categories are enabled.\n   *        Also takes strings (category name) or ordinal (category position)\n   */\n  enable(...categories: (Category|string|number)[]);\n  enable(...categories: any[]) { this._set(true, categories); }\n  /**\n   * Disables a trace [[Category]]\n   *\n   * ```js\n   * trace.disable(\"VIEWCONFIG\");\n   * ```\n   *\n   * @param categories categories to disable. If `categories` is omitted, all categories are disabled.\n   *        Also takes strings (category name) or ordinal (category position)\n   */\n  disable(...categories: (Category|string|number)[]);\n  disable(...categories: any[]) { this._set(false, categories); }\n\n  /**\n   * Retrieves the enabled stateus of a [[Category]]\n   *\n   * ```js\n   * trace.enabled(\"VIEWCONFIG\"); // true or false\n   * ```\n   *\n   * @returns boolean true if the category is enabled\n   */\n  enabled(category: (Category|string|number)): boolean {\n    rLine truncated
-    "/**\n * @coreapi\n * @module transition\n */ /** for typedoc */\nimport { StateDeclaration } from '../state/interface';\nimport { Predicate } from '../common/common';\n\nimport { Transition } from './transition';\nimport { StateObject } from '../state/stateObject';\nimport { PathNode } from '../path/pathNode';\nimport { TargetState } from '../state/targetState';\nimport { RegisteredHook } from './hookRegistry';\n\n/**\n * The TransitionOptions object can be used to change the behavior of a transition.\n *\n * It is passed as the third argument to [[StateService.go]], [[StateService.transitionTo]].\n * It can also be used with a `uiSref`.\n */\nexport interface TransitionOptions {\n  /**\n   * This option changes how the Transition interacts with the browser's location bar (URL).\n   *\n   * - If `true`, it will update the url in the location bar.\n   * - If `false`, it will not update the url in the location bar.\n   * - If it is the string `\"replace\"`, it will update the url and also replace the last history record.\n   *\n   * @default `true`\n   */\n  location    ?: (boolean|string);\n\n  /**\n   * When transitioning to relative path (e.g '`^`'), this option defines which state to be relative from.\n   * @default `$state.current`\n   */\n  relative    ?: (string|StateDeclaration|StateObject);\n\n  /**\n   * This option sets whether or not the transition's parameter values should be inherited from\n   * the current parameter values.\n   *\n   * - If `true`, it will inherit parameter values from the current parameter values.\n   * - If `false`, only the parameters which are provided to `transitionTo` will be used.\n   *\n   * @default `false`\n   */\n  inherit     ?: boolean;\n\n  /**\n   * @deprecated\n   */\n  notify      ?: boolean;\n\n  /**\n   * This option may be used to force states which are currently active to reload.\n   *\n   * During a normal transition, a state is \"retained\" if:\n   * - It was previously active\n   * - The state's parameter values have not changed\n   * - All the parent states' parameter values have not changed\n   *\n   * Forcing a reload of a state will cause it to be exited and entered, which will:\n   * - Refetch that state's resolve data\n   * - Exit the state (onExit hook)\n   * - Re-enter the state (onEnter hook)\n   * - Re-render the views (controllers and templates)\n   *\n   * - When `true`, the destination state (and all parent states) will be reloaded.\n   * - When it is a string and is the name of a state, or when it is a State object,\n   *   that state and any children states will be reloaded.\n   *\n   * @default `false`\n   */\n  reload      ?: (boolean|string|StateDeclaration|StateObject);\n  /**\n   * You can define your own Transition Options inside this property and use them, e.g., from a Transition Hook\n   */\n  custom      ?: any;\n  /** @internalapi */\n  reloadState ?: (StateObject);\n  /** @internalapi\n   * If this transition is a redirect, this property should be the original Transition (which was redirected to this one)\n   */\n  redirectedFrom?: Transition;\n  /** @internalapi */\n  current     ?: () => Transition;\n  /** @internalapi */\n  source      ?: 'sref' | 'url' | 'redirect' | 'otherwise' | 'unknown';\n}\n\n/** @internalapi */\nexport interface TransitionHookOptions {\n  current             ?: () => Transition;  // path?\n  transition          ?: Transition;\n  hookType            ?: string;\n  target              ?: any;\n  traceData           ?: any;\n  bind                ?: any;\n  stateHook           ?: boolean;\n}\n\n/**\n * TreeChanges encapsulates the various Paths that are involved in a Transition.\n *\n * Get a TreeChanges object using [[Transition.treeChanges]]\n *\n * A UI-Router Transition is from one Path in a State Tree to another Path.  For a given Transition,\n * this object stores the \"to\" and \"from\" paths, as well as subsets of those: the \"retained\",\n * \"exiting\" and \"entering\" paths.\n *\n * Each path in TreeChanges is an array of [[PathNode]] objects. Each PathNode in the array corresponds to a portion\n * of a nested state.\n *\n * For example, if you had a nested state named `foo.bar.baz`, it would have three\n * portions, `foo, bar, baz`.  If you transitioned **to** `foo.bar.baz` and inspected the [[TreeChanges.to]]\n * Path, you would find a node in the array for each portion: `foo`, `bar`, and `baz`.\n *\n * ---\n *\n * @todo show visual state tree\n */\nexport interface TreeChanges {\n  /** @nodoc */\n  [key: string]: PathNode[];\n\n  /** The path of nodes in the state tree that the transition is coming *from* */\n  from: PathNode[];\n\n  /** The path of nodes in the state tree that the transition is going *to* */\n  to: PathNode[];\n\n  /**\n   * The path of active nodes that the transition is retaining.\n   *\n   * These nodes are neither exited, nor entered.\n   * Before and after the transition is successful, these nodes are active.\n   */\n  retained: PathNode[];\n\n  /**\n   * The pathLine truncated
+    "/**\n * @coreapi\n * @module transition\n */ /** for typedoc */\nimport { StateDeclaration } from '../state/interface';\nimport { Predicate } from '../common/common';\n\nimport { Transition } from './transition';\nimport { StateObject } from '../state/stateObject';\nimport { PathNode } from '../path/pathNode';\nimport { TargetState } from '../state/targetState';\nimport { RegisteredHook } from './hookRegistry';\n\n/**\n * The TransitionOptions object can be used to change the behavior of a transition.\n *\n * It is passed as the third argument to [[StateService.go]], [[StateService.transitionTo]].\n * It can also be used with a `uiSref`.\n */\nexport interface TransitionOptions {\n  /**\n   * This option changes how the Transition interacts with the browser's location bar (URL).\n   *\n   * - If `true`, it will update the url in the location bar.\n   * - If `false`, it will not update the url in the location bar.\n   * - If it is the string `\"replace\"`, it will update the url and also replace the last history record.\n   *\n   * @default `true`\n   */\n  location    ?: (boolean|string);\n\n  /**\n   * When transitioning to relative path (e.g '`^`'), this option defines which state to be relative from.\n   * @default `$state.current`\n   */\n  relative    ?: (string|StateDeclaration|StateObject);\n\n  /**\n   * This option sets whether or not the transition's parameter values should be inherited from\n   * the current parameter values.\n   *\n   * - If `true`, it will inherit parameter values from the current parameter values.\n   * - If `false`, only the parameters which are provided to `transitionTo` will be used.\n   *\n   * @default `false`\n   */\n  inherit     ?: boolean;\n\n  /**\n   * @deprecated\n   */\n  notify      ?: boolean;\n\n  /**\n   * This option may be used to force states which are currently active to reload.\n   *\n   * During a normal transition, a state is \"retained\" if:\n   * - It was previously active\n   * - The state's parameter values have not changed\n   * - All the parent states' parameter values have not changed\n   *\n   * Forcing a reload of a state will cause it to be exited and entered, which will:\n   * - Refetch that state's resolve data\n   * - Exit the state (onExit hook)\n   * - Re-enter the state (onEnter hook)\n   * - Re-render the views (controllers and templates)\n   *\n   * - When `true`, the destination state (and all parent states) will be reloaded.\n   * - When it is a string and is the name of a state, or when it is a State object,\n   *   that state and any children states will be reloaded.\n   *\n   * @default `false`\n   */\n  reload      ?: (boolean|string|StateDeclaration|StateObject);\n  /**\n   * You can define your own Transition Options inside this property and use them, e.g., from a Transition Hook\n   */\n  custom      ?: any;\n  /** @internalapi */\n  reloadState ?: (StateObject);\n  /** @internalapi\n   * If this transition is a redirect, this property should be the original Transition (which was redirected to this one)\n   */\n  redirectedFrom?: Transition;\n  /** @internalapi */\n  current     ?: () => Transition;\n  /** @internalapi */\n  source      ?: 'sref' | 'url' | 'redirect' | 'otherwise' | 'unknown';\n}\n\n/** @internalapi */\nexport interface TransitionHookOptions {\n  current             ?: () => Transition;  // path?\n  transition          ?: Transition;\n  hookType            ?: string;\n  target              ?: any;\n  traceData           ?: any;\n  bind                ?: any;\n  stateHook           ?: boolean;\n}\n\n/**\n * TreeChanges encapsulates the various Paths that are involved in a Transition.\n *\n * Get a TreeChanges object using [[Transition.treeChanges]]\n *\n * A UI-Router Transition is from one Path in a State Tree to another Path.  For a given Transition,\n * this object stores the \"to\" and \"from\" paths, as well as subsets of those: the \"retained\",\n * \"exiting\" and \"entering\" paths.\n *\n * Each path in TreeChanges is an array of [[PathNode]] objects. Each PathNode in the array corresponds to a portion\n * of a nested state.\n *\n * For example, if you had a nested state named `foo.bar.baz`, it would have three\n * portions, `foo, bar, baz`.  If you transitioned **to** `foo.bar.baz` and inspected the [[TreeChanges.to]]\n * Path, you would find a node in the array for each portion: `foo`, `bar`, and `baz`.\n *\n * ---\n *\n * @todo show visual state tree\n */\nexport interface TreeChanges {\n  /** @nodoc */\n  [key: string]: PathNode[];\n\n  /** The path of nodes in the state tree that the transition is coming *from* */\n  from: PathNode[];\n\n  /** The path of nodes in the state tree that the transition is going *to* */\n  to: PathNode[];\n\n  /**\n   * The path of active nodes that the transition is retaining.\n   *\n   * These nodes are neither exited, nor entered.\n   * Before and after the transition is successful, these nodes are active.\n   */\n  retained: PathNode[];\n\n  /**\n   * The pathLine truncated
     "/**\n * @coreapi\n * @module state\n */ /** for typedoc */\n\nimport { StateDeclaration, StateOrName, TargetStateDef } from './interface';\nimport { TransitionOptions } from '../transition/interface';\nimport { StateObject } from './stateObject';\nimport { isString } from '../common/predicates';\nimport { stringify } from '../common/strings';\nimport { extend } from '../common';\nimport { StateRegistry } from './stateRegistry';\nimport { RawParams } from '../params';\n\n/**\n * Encapsulate the target (destination) state/params/options of a [[Transition]].\n *\n * This class is frequently used to redirect a transition to a new destination.\n *\n * See:\n *\n * - [[HookResult]]\n * - [[TransitionHookFn]]\n * - [[TransitionService.onStart]]\n *\n * To create a `TargetState`, use [[StateService.target]].\n *\n * ---\n *\n * This class wraps:\n *\n * 1) an identifier for a state\n * 2) a set of parameters\n * 3) and transition options\n * 4) the registered state object (the [[StateDeclaration]])\n *\n * Many UI-Router APIs such as [[StateService.go]] take a [[StateOrName]] argument which can\n * either be a *state object* (a [[StateDeclaration]] or [[StateObject]]) or a *state name* (a string).\n * The `TargetState` class normalizes those options.\n *\n * A `TargetState` may be valid (the state being targeted exists in the registry)\n * or invalid (the state being targeted is not registered).\n */\nexport class TargetState {\n  private _definition: StateObject;\n  private _params: RawParams;\n  private _options: TransitionOptions;\n\n  /** Returns true if the object has a state property that might be a state or state name */\n  static isDef = (obj): obj is TargetStateDef =>\n    obj && obj.state && (isString(obj.state) || isString(obj.state.name));\n\n  /**\n   * The TargetState constructor\n   *\n   * Note: Do not construct a `TargetState` manually.\n   * To create a `TargetState`, use the [[StateService.target]] factory method.\n   *\n   * @param _stateRegistry The StateRegistry to use to look up the _definition\n   * @param _identifier An identifier for a state.\n   *    Either a fully-qualified state name, or the object used to define the state.\n   * @param _params Parameters for the target state\n   * @param _options Transition options.\n   *\n   * @internalapi\n   */\n  constructor(\n    private _stateRegistry: StateRegistry,\n    private _identifier: StateOrName,\n    _params?: RawParams,\n    _options?: TransitionOptions,\n  ) {\n    this._identifier = _identifier;\n    this._params = extend({}, _params || {});\n    this._options = extend({}, _options || {});\n    this._definition = _stateRegistry.matcher.find(_identifier, this._options.relative);\n  }\n\n  /** The name of the state this object targets */\n  name(): string {\n    return this._definition && this._definition.name || <string> this._identifier;\n  }\n\n  /** The identifier used when creating this TargetState */\n  identifier(): StateOrName {\n    return this._identifier;\n  }\n\n  /** The target parameter values */\n  params(): RawParams {\n    return this._params;\n  }\n\n  /** The internal state object (if it was found) */\n  $state(): StateObject {\n    return this._definition;\n  }\n\n  /** The internal state declaration (if it was found) */\n  state(): StateDeclaration {\n    return this._definition && this._definition.self;\n  }\n\n  /** The target options */\n  options() {\n    return this._options;\n  }\n\n  /** True if the target state was found */\n  exists(): boolean {\n    return !!(this._definition && this._definition.self);\n  }\n\n  /** True if the object is valid */\n  valid(): boolean {\n    return !this.error();\n  }\n\n  /** If the object is invalid, returns the reason why */\n  error(): string {\n    const base = <any> this.options().relative;\n    if (!this._definition && !!base) {\n      const stateName = base.name ? base.name : base;\n      return `Could not resolve '${this.name()}' from state '${stateName}'`;\n    }\n    if (!this._definition)\n      return `No such state '${this.name()}'`;\n    if (!this._definition.self)\n      return `State '${this.name()}' has an invalid definition`;\n  }\n\n  toString() {\n    return `'${this.name()}'${stringify(this.params())}`;\n  }\n\n  /**\n   * Returns a copy of this TargetState which targets a different state.\n   * The new TargetState has the same parameter values and transition options.\n   *\n   * @param state The new state that should be targeted\n   */\n  withState(state: StateOrName): TargetState {\n    return new TargetState(this._stateRegistry, state, this._params, this._options);\n  }\n\n  /**\n   * Returns a copy of this TargetState, using the specified parameter values.\n   *\n   * @param params the new parameter values to use\n   * @param replace When false (default) the new parameter values will be merged with the current values.\n   *                When true the parameter values will be used instead of the current values.\n   */\n  withParams(params: RLine truncated
     "/**\n * @coreapi\n * @module transition\n */\n/** for typedoc */\nimport { TransitionHookOptions, HookResult, TransitionHookPhase } from './interface';\nimport { defaults, noop, silentRejection } from '../common/common';\nimport { fnToString, maxLength } from '../common/strings';\nimport { isPromise } from '../common/predicates';\nimport { is, parse } from '../common/hof';\nimport { trace } from '../common/trace';\nimport { services } from '../common/coreservices';\nimport { Rejection } from './rejectFactory';\nimport { TargetState } from '../state/targetState';\nimport { Transition } from './transition';\nimport { TransitionEventType } from './transitionEventType';\nimport { RegisteredHook } from './hookRegistry';\nimport { StateDeclaration } from '../state/interface';\n\nconst defaultOptions: TransitionHookOptions = {\n  current: noop,\n  transition: null,\n  traceData: {},\n  bind: null,\n};\n\nexport type GetResultHandler = (hook: TransitionHook) => ResultHandler;\nexport type GetErrorHandler  = (hook: TransitionHook) => ErrorHandler;\n\nexport type ResultHandler = (result: HookResult)      => Promise<HookResult>;\nexport type ErrorHandler  = (error: any)              => Promise<any>;\n\n/** @hidden */\nexport class TransitionHook {\n  type: TransitionEventType;\n\n  /**\n   * These GetResultHandler(s) are used by [[invokeHook]] below\n   * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])\n   */\n  static HANDLE_RESULT: GetResultHandler = (hook: TransitionHook) => (result: HookResult) =>\n      hook.handleHookResult(result);\n\n  /**\n   * If the result is a promise rejection, log it.\n   * Otherwise, ignore the result.\n   */\n  static LOG_REJECTED_RESULT: GetResultHandler = (hook: TransitionHook) => (result: HookResult) => {\n    isPromise(result) && result.catch(err =>\n        hook.logError(Rejection.normalize(err)));\n    return undefined;\n  }\n\n  /**\n   * These GetErrorHandler(s) are used by [[invokeHook]] below\n   * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])\n   */\n  static LOG_ERROR: GetErrorHandler = (hook: TransitionHook) => (error: any) =>\n      hook.logError(error);\n\n  static REJECT_ERROR: GetErrorHandler = (hook: TransitionHook) => (error: any) =>\n      silentRejection(error);\n\n  static THROW_ERROR: GetErrorHandler = (hook: TransitionHook) => (error: any) => {\n    throw error;\n  }\n\n  /**\n   * Chains together an array of TransitionHooks.\n   *\n   * Given a list of [[TransitionHook]] objects, chains them together.\n   * Each hook is invoked after the previous one completes.\n   *\n   * #### Example:\n   * ```js\n   * var hooks: TransitionHook[] = getHooks();\n   * let promise: Promise<any> = TransitionHook.chain(hooks);\n   *\n   * promise.then(handleSuccess, handleError);\n   * ```\n   *\n   * @param hooks the list of hooks to chain together\n   * @param waitFor if provided, the chain is `.then()`'ed off this promise\n   * @returns a `Promise` for sequentially invoking the hooks (in order)\n   */\n  static chain(hooks: TransitionHook[], waitFor?: Promise<any>): Promise<any> {\n    // Chain the next hook off the previous\n    const createHookChainR = (prev: Promise<any>, nextHook: TransitionHook) =>\n      prev.then(() => nextHook.invokeHook());\n    return hooks.reduce(createHookChainR, waitFor || services.$q.when());\n  }\n\n\n  /**\n   * Invokes all the provided TransitionHooks, in order.\n   * Each hook's return value is checked.\n   * If any hook returns a promise, then the rest of the hooks are chained off that promise, and the promise is returned.\n   * If no hook returns a promise, then all hooks are processed synchronously.\n   *\n   * @param hooks the list of TransitionHooks to invoke\n   * @param doneCallback a callback that is invoked after all the hooks have successfully completed\n   *\n   * @returns a promise for the async result, or the result of the callback\n   */\n  static invokeHooks<T>(hooks: TransitionHook[], doneCallback: (result?: HookResult) => T): Promise<any> | T {\n    for (let idx = 0; idx < hooks.length; idx++) {\n      const hookResult = hooks[idx].invokeHook();\n\n      if (isPromise(hookResult)) {\n        const remainingHooks = hooks.slice(idx + 1);\n\n        return TransitionHook.chain(remainingHooks, hookResult)\n          .then(doneCallback);\n      }\n    }\n\n    return doneCallback();\n  }\n\n  /**\n   * Run all TransitionHooks, ignoring their return value.\n   */\n  static runAllHooks(hooks: TransitionHook[]): void {\n    hooks.forEach(hook => hook.invokeHook());\n  }\n\n  constructor(private transition: Transition,\n              private stateContext: StateDeclaration,\n              private registeredHook: RegisteredHook,\n              private options: TransitionHookOptions) {\n    this.options = defaults(options, defaultOptions);\n    this.type = registeredHook.eventType;\n  }\n\n  private isSuperseded = () =>\n    this.type.hookPhase === TranLine truncated
-    "/**\n * @coreapi\n * @module transition\n */ /** for typedoc */\nimport { extend, removeFrom, tail, values, identity, map } from '../common/common';\nimport { isString, isFunction } from '../common/predicates';\nimport { PathNode } from '../path/pathNode';\nimport {\n    TransitionStateHookFn, TransitionHookFn, TransitionHookPhase, TransitionHookScope, IHookRegistry, PathType,\n} from './interface'; // has or is using\n\nimport {\n    HookRegOptions, HookMatchCriteria, TreeChanges,\n    HookMatchCriterion, IMatchingNodes, HookFn,\n} from './interface';\nimport { Glob } from '../common/glob';\nimport { StateObject } from '../state/stateObject';\nimport { TransitionEventType } from './transitionEventType';\nimport { TransitionService } from './transitionService';\n\n/**\n * Determines if the given state matches the matchCriteria\n *\n * @hidden\n *\n * @param state a State Object to test against\n * @param criterion\n * - If a string, matchState uses the string as a glob-matcher against the state name\n * - If an array (of strings), matchState uses each string in the array as a glob-matchers against the state name\n *   and returns a positive match if any of the globs match.\n * - If a function, matchState calls the function with the state and returns true if the function's result is truthy.\n * @returns {boolean}\n */\nexport function matchState(state: StateObject, criterion: HookMatchCriterion) {\n  const toMatch = isString(criterion) ? [criterion] : criterion;\n\n  function matchGlobs(_state: StateObject) {\n    const globStrings = <string[]> toMatch;\n    for (let i = 0; i < globStrings.length; i++) {\n      const glob = new Glob(globStrings[i]);\n\n      if ((glob && glob.matches(_state.name)) || (!glob && globStrings[i] === _state.name)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  const matchFn = <any> (isFunction(toMatch) ? toMatch : matchGlobs);\n  return !!matchFn(state);\n}\n\n/**\n * @internalapi\n * The registration data for a registered transition hook\n */\nexport class RegisteredHook {\n  priority: number;\n  bind: any;\n  invokeCount = 0;\n  invokeLimit: number;\n  _deregistered = false;\n\n  constructor(public tranSvc: TransitionService,\n              public eventType: TransitionEventType,\n              public callback: HookFn,\n              public matchCriteria: HookMatchCriteria,\n              public removeHookFromRegistry: (hook: RegisteredHook) => void,\n              options: HookRegOptions = {} as any) {\n    this.priority = options.priority || 0;\n    this.bind = options.bind || null;\n    this.invokeLimit = options.invokeLimit;\n  }\n\n  /**\n   * Gets the matching [[PathNode]]s\n   *\n   * Given an array of [[PathNode]]s, and a [[HookMatchCriterion]], returns an array containing\n   * the [[PathNode]]s that the criteria matches, or `null` if there were no matching nodes.\n   *\n   * Returning `null` is significant to distinguish between the default\n   * \"match-all criterion value\" of `true` compared to a `() => true` function,\n   * when the nodes is an empty array.\n   *\n   * This is useful to allow a transition match criteria of `entering: true`\n   * to still match a transition, even when `entering === []`.  Contrast that\n   * with `entering: (state) => true` which only matches when a state is actually\n   * being entered.\n   */\n  private _matchingNodes(nodes: PathNode[], criterion: HookMatchCriterion): PathNode[] {\n    if (criterion === true) return nodes;\n    const matching = nodes.filter(node => matchState(node.state, criterion));\n    return matching.length ? matching : null;\n  }\n\n  /**\n   * Gets the default match criteria (all `true`)\n   *\n   * Returns an object which has all the criteria match paths as keys and `true` as values, i.e.:\n   *\n   * ```js\n   * {\n   *   to: true,\n   *   from: true,\n   *   entering: true,\n   *   exiting: true,\n   *   retained: true,\n   * }\n   */\n  private _getDefaultMatchCriteria(): HookMatchCriteria {\n    return map(this.tranSvc._pluginapi._getPathTypes(), () => true);\n  }\n\n  /**\n   * Gets matching nodes as [[IMatchingNodes]]\n   *\n   * Create a IMatchingNodes object from the TransitionHookTypes that is roughly equivalent to:\n   *\n   * ```js\n   * let matches: IMatchingNodes = {\n   *   to:       _matchingNodes([tail(treeChanges.to)],   mc.to),\n   *   from:     _matchingNodes([tail(treeChanges.from)], mc.from),\n   *   exiting:  _matchingNodes(treeChanges.exiting,      mc.exiting),\n   *   retained: _matchingNodes(treeChanges.retained,     mc.retained),\n   *   entering: _matchingNodes(treeChanges.entering,     mc.entering),\n   * };\n   * ```\n   */\n  private _getMatchingNodes(treeChanges: TreeChanges): IMatchingNodes {\n    const criteria = extend(this._getDefaultMatchCriteria(), this.matchCriteria);\n    const paths: PathType[] = values(this.tranSvc._pluginapi._getPathTypes());\n\n    return paths.reduce((mn: IMatchingNodes, pathtype: PathType) => {\n      // STATE scope criLine truncated
+    "/**\n * @coreapi\n * @module transition\n */ /** for typedoc */\nimport { isString, isFunction, Glob, extend, removeFrom, tail, values, identity, mapObj } from '../common';\nimport { PathNode } from '../path/pathNode';\nimport {\n  TransitionStateHookFn, TransitionHookFn, TransitionHookPhase, // has or is using\n  TransitionHookScope, IHookRegistry, PathType,\n} from './interface';\n\nimport { HookRegOptions, HookMatchCriteria, TreeChanges, HookMatchCriterion, IMatchingNodes, HookFn } from './interface';\nimport { StateObject } from '../state/stateObject';\nimport { TransitionEventType } from './transitionEventType';\nimport { TransitionService } from './transitionService';\n\n/**\n * Determines if the given state matches the matchCriteria\n *\n * @hidden\n *\n * @param state a State Object to test against\n * @param criterion\n * - If a string, matchState uses the string as a glob-matcher against the state name\n * - If an array (of strings), matchState uses each string in the array as a glob-matchers against the state name\n *   and returns a positive match if any of the globs match.\n * - If a function, matchState calls the function with the state and returns true if the function's result is truthy.\n * @returns {boolean}\n */\nexport function matchState(state: StateObject, criterion: HookMatchCriterion) {\n  const toMatch = isString(criterion) ? [criterion] : criterion;\n\n  function matchGlobs(_state: StateObject) {\n    const globStrings = <string[]> toMatch;\n    for (let i = 0; i < globStrings.length; i++) {\n      const glob = new Glob(globStrings[i]);\n\n      if ((glob && glob.matches(_state.name)) || (!glob && globStrings[i] === _state.name)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  const matchFn = <any> (isFunction(toMatch) ? toMatch : matchGlobs);\n  return !!matchFn(state);\n}\n\n/**\n * @internalapi\n * The registration data for a registered transition hook\n */\nexport class RegisteredHook {\n  priority: number;\n  bind: any;\n  invokeCount = 0;\n  invokeLimit: number;\n  _deregistered = false;\n\n  constructor(public tranSvc: TransitionService,\n              public eventType: TransitionEventType,\n              public callback: HookFn,\n              public matchCriteria: HookMatchCriteria,\n              public removeHookFromRegistry: (hook: RegisteredHook) => void,\n              options: HookRegOptions = {} as any) {\n    this.priority = options.priority || 0;\n    this.bind = options.bind || null;\n    this.invokeLimit = options.invokeLimit;\n  }\n\n  /**\n   * Gets the matching [[PathNode]]s\n   *\n   * Given an array of [[PathNode]]s, and a [[HookMatchCriterion]], returns an array containing\n   * the [[PathNode]]s that the criteria matches, or `null` if there were no matching nodes.\n   *\n   * Returning `null` is significant to distinguish between the default\n   * \"match-all criterion value\" of `true` compared to a `() => true` function,\n   * when the nodes is an empty array.\n   *\n   * This is useful to allow a transition match criteria of `entering: true`\n   * to still match a transition, even when `entering === []`.  Contrast that\n   * with `entering: (state) => true` which only matches when a state is actually\n   * being entered.\n   */\n  private _matchingNodes(nodes: PathNode[], criterion: HookMatchCriterion): PathNode[] {\n    if (criterion === true) return nodes;\n    const matching = nodes.filter(node => matchState(node.state, criterion));\n    return matching.length ? matching : null;\n  }\n\n  /**\n   * Gets the default match criteria (all `true`)\n   *\n   * Returns an object which has all the criteria match paths as keys and `true` as values, i.e.:\n   *\n   * ```js\n   * {\n   *   to: true,\n   *   from: true,\n   *   entering: true,\n   *   exiting: true,\n   *   retained: true,\n   * }\n   */\n  private _getDefaultMatchCriteria(): HookMatchCriteria {\n    return mapObj(this.tranSvc._pluginapi._getPathTypes(), () => true);\n  }\n\n  /**\n   * Gets matching nodes as [[IMatchingNodes]]\n   *\n   * Create a IMatchingNodes object from the TransitionHookTypes that is roughly equivalent to:\n   *\n   * ```js\n   * let matches: IMatchingNodes = {\n   *   to:       _matchingNodes([tail(treeChanges.to)],   mc.to),\n   *   from:     _matchingNodes([tail(treeChanges.from)], mc.from),\n   *   exiting:  _matchingNodes(treeChanges.exiting,      mc.exiting),\n   *   retained: _matchingNodes(treeChanges.retained,     mc.retained),\n   *   entering: _matchingNodes(treeChanges.entering,     mc.entering),\n   * };\n   * ```\n   */\n  private _getMatchingNodes(treeChanges: TreeChanges): IMatchingNodes {\n    const criteria = extend(this._getDefaultMatchCriteria(), this.matchCriteria);\n    const paths: PathType[] = values(this.tranSvc._pluginapi._getPathTypes());\n\n    return paths.reduce((mn: IMatchingNodes, pathtype: PathType) => {\n      // STATE scope criteria matches against every node in the path.\n      // TRANSITION scope criteria matcLine truncated
     "/**\n * @coreapi\n * @module transition\n */ /** for typedoc */\n\nimport { extend, tail, assertPredicate, unnestR, identity } from '../common/common';\nimport { isArray } from '../common/predicates';\n\nimport {\n    TransitionOptions, TransitionHookOptions, IHookRegistry, TreeChanges, IMatchingNodes,\n    TransitionHookPhase, TransitionHookScope,\n} from './interface';\n\nimport { Transition } from './transition';\nimport { TransitionHook } from './transitionHook';\nimport { StateObject } from '../state/stateObject';\nimport { PathNode } from '../path/pathNode';\nimport { TransitionService } from './transitionService';\nimport { TransitionEventType } from './transitionEventType';\nimport { RegisteredHook } from './hookRegistry';\n\n/**\n * This class returns applicable TransitionHooks for a specific Transition instance.\n *\n * Hooks ([[RegisteredHook]]) may be registered globally, e.g., $transitions.onEnter(...), or locally, e.g.\n * myTransition.onEnter(...).  The HookBuilder finds matching RegisteredHooks (where the match criteria is\n * determined by the type of hook)\n *\n * The HookBuilder also converts RegisteredHooks objects to TransitionHook objects, which are used to run a Transition.\n *\n * The HookBuilder constructor is given the $transitions service and a Transition instance.  Thus, a HookBuilder\n * instance may only be used for one specific Transition object. (side note: the _treeChanges accessor is private\n * in the Transition class, so we must also provide the Transition's _treeChanges)\n *\n */\nexport class HookBuilder {\n  constructor(private transition: Transition) { }\n\n  buildHooksForPhase(phase: TransitionHookPhase): TransitionHook[] {\n    const $transitions = this.transition.router.transitionService;\n    return $transitions._pluginapi._getEvents(phase)\n        .map(type => this.buildHooks(type))\n        .reduce(unnestR, [])\n        .filter(identity);\n  }\n\n  /**\n   * Returns an array of newly built TransitionHook objects.\n   *\n   * - Finds all RegisteredHooks registered for the given `hookType` which matched the transition's [[TreeChanges]].\n   * - Finds [[PathNode]] (or `PathNode[]`) to use as the TransitionHook context(s)\n   * - For each of the [[PathNode]]s, creates a TransitionHook\n   *\n   * @param hookType the type of the hook registration function, e.g., 'onEnter', 'onFinish'.\n   */\n  buildHooks(hookType: TransitionEventType): TransitionHook[] {\n    const transition = this.transition;\n    const treeChanges = transition.treeChanges();\n\n    // Find all the matching registered hooks for a given hook type\n    const matchingHooks = this.getMatchingHooks(hookType, treeChanges);\n    if (!matchingHooks) return [];\n\n    const baseHookOptions = <TransitionHookOptions> {\n      transition: transition,\n      current: transition.options().current,\n    };\n\n    const makeTransitionHooks = (hook: RegisteredHook) => {\n       // Fetch the Nodes that caused this hook to match.\n       const matches: IMatchingNodes = hook.matches(treeChanges);\n       // Select the PathNode[] that will be used as TransitionHook context objects\n       const matchingNodes: PathNode[] = matches[hookType.criteriaMatchPath.name];\n\n       // Return an array of HookTuples\n       return matchingNodes.map(node => {\n         const _options = extend({\n           bind: hook.bind,\n           traceData: { hookType: hookType.name, context: node },\n         }, baseHookOptions);\n\n         const state = hookType.criteriaMatchPath.scope === TransitionHookScope.STATE ? node.state.self : null;\n         const transitionHook = new TransitionHook(transition, state, hook, _options);\n         return <HookTuple> { hook, node, transitionHook };\n       });\n    };\n\n    return matchingHooks.map(makeTransitionHooks)\n        .reduce(unnestR, [])\n        .sort(tupleSort(hookType.reverseSort))\n        .map(tuple => tuple.transitionHook);\n  }\n\n  /**\n   * Finds all RegisteredHooks from:\n   * - The Transition object instance hook registry\n   * - The TransitionService ($transitions) global hook registry\n   *\n   * which matched:\n   * - the eventType\n   * - the matchCriteria (to, from, exiting, retained, entering)\n   *\n   * @returns an array of matched [[RegisteredHook]]s\n   */\n  public getMatchingHooks(hookType: TransitionEventType, treeChanges: TreeChanges): RegisteredHook[] {\n    const isCreate = hookType.hookPhase === TransitionHookPhase.CREATE;\n\n    // Instance and Global hook registries\n    const $transitions = this.transition.router.transitionService;\n    const registries = isCreate ? [ $transitions ] : [ this.transition, $transitions ];\n\n    return registries.map((reg: IHookRegistry) => reg.getHooks(hookType.name))    // Get named hooks from registries\n        .filter(assertPredicate(isArray, `broken event named: ${hookType.name}`)) // Sanity check\n        .reduce(unnestR, [])                                                      // Un-nest RegisteredHook[][] to RegLine truncated
     "/**\n * @coreapi\n * @module params\n */\n/** */\nimport { extend, filter, map } from '../common/common';\nimport { isArray, isDefined } from '../common/predicates';\nimport { ParamTypeDefinition } from './interface';\n\n/**\n * An internal class which implements [[ParamTypeDefinition]].\n *\n * A [[ParamTypeDefinition]] is a plain javascript object used to register custom parameter types.\n * When a param type definition is registered, an instance of this class is created internally.\n *\n * This class has naive implementations for all the [[ParamTypeDefinition]] methods.\n *\n * Used by [[UrlMatcher]] when matching or formatting URLs, or comparing and validating parameter values.\n *\n * #### Example:\n * ```js\n * var paramTypeDef = {\n *   decode: function(val) { return parseInt(val, 10); },\n *   encode: function(val) { return val && val.toString(); },\n *   equals: function(a, b) { return this.is(a) && a === b; },\n *   is: function(val) { return angular.isNumber(val) && isFinite(val) && val % 1 === 0; },\n *   pattern: /\\d+/\n * }\n *\n * var paramType = new ParamType(paramTypeDef);\n * ```\n * @internalapi\n */\nexport class ParamType implements ParamTypeDefinition {\n  /** @inheritdoc */\n  pattern: RegExp = /.*/;\n  /** The name/id of the parameter type */\n  name: string;\n  /** @inheritdoc */\n  raw: boolean;\n  /** @inheritdoc */\n  dynamic: boolean;\n  /** @inheritdoc */\n  inherit = true;\n\n  /**\n   * @param def  A configuration object which contains the custom type definition.  The object's\n   *        properties will override the default methods and/or pattern in `ParamType`'s public interface.\n   * @returns a new ParamType object\n   */\n  constructor(def: ParamTypeDefinition) {\n    extend(this, def);\n  }\n\n\n  // consider these four methods to be \"abstract methods\" that should be overridden\n  /** @inheritdoc */\n  is(val: any, key?: string): boolean { return true; }\n  /** @inheritdoc */\n  encode(val: any, key?: string): (string|string[]) { return val; }\n  /** @inheritdoc */\n  decode(val: string, key?: string): any { return val; }\n  /** @inheritdoc */\n  equals(a: any, b: any): boolean { return a == b; } // tslint:disable-line:triple-equals\n\n\n  $subPattern() {\n    const sub = this.pattern.toString();\n    return sub.substr(1, sub.length - 2);\n  }\n\n  toString() {\n    return `{ParamType:${this.name}}`;\n  }\n\n  /** Given an encoded string, or a decoded object, returns a decoded object */\n  $normalize(val: any) {\n    return this.is(val) ? val : this.decode(val);\n  }\n\n  /**\n   * Wraps an existing custom ParamType as an array of ParamType, depending on 'mode'.\n   * e.g.:\n   * - urlmatcher pattern \"/path?{queryParam[]:int}\"\n   * - url: \"/path?queryParam=1&queryParam=2\n   * - $stateParams.queryParam will be [1, 2]\n   * if `mode` is \"auto\", then\n   * - url: \"/path?queryParam=1 will create $stateParams.queryParam: 1\n   * - url: \"/path?queryParam=1&queryParam=2 will create $stateParams.queryParam: [1, 2]\n   */\n  $asArray(mode: (boolean|'auto'), isSearch: boolean) {\n    if (!mode) return this;\n    if (mode === 'auto' && !isSearch) throw new Error(\"'auto' array mode is for query parameters only\");\n    return new (<any> ArrayType)(this, mode);\n  }\n}\n\n/**\n * Wraps up a `ParamType` object to handle array values.\n * @internalapi\n */\nfunction ArrayType(type: ParamType, mode: (boolean|'auto')) {\n  // Wrap non-array value as array\n  function arrayWrap(val: any): any[] {\n    return isArray(val) ? val : (isDefined(val) ? [ val ] : []);\n  }\n\n  // Unwrap array value for \"auto\" mode. Return undefined for empty array.\n  function arrayUnwrap(val: any) {\n    switch (val.length) {\n      case 0: return undefined;\n      case 1: return mode === 'auto' ? val[0] : val;\n      default: return val;\n    }\n  }\n\n  // Wraps type (.is/.encode/.decode) functions to operate on each value of an array\n  function arrayHandler(callback: (x: any) => any, allTruthyMode?: boolean) {\n    return function handleArray(val: any) {\n      if (isArray(val) && val.length === 0) return val;\n      const arr = arrayWrap(val);\n      const result = map(arr, callback);\n      return (allTruthyMode === true) ? filter(result, x => !x).length === 0 : arrayUnwrap(result);\n    };\n  }\n\n  // Wraps type (.equals) functions to operate on each value of an array\n  function arrayEqualsHandler(callback: (l: any, r: any) => boolean) {\n    return function handleArray(val1: any, val2: any) {\n      const left = arrayWrap(val1), right = arrayWrap(val2);\n      if (left.length !== right.length) return false;\n      for (let i = 0; i < left.length; i++) {\n        if (!callback(left[i], right[i])) return false;\n      }\n      return true;\n    };\n  }\n\n  ['encode', 'decode', 'equals', '$normalize'].forEach(name => {\n    const paramTypeFn = type[name].bind(type);\n    const wrapperFn: Function = name === 'equals' ? arrayEqualsHandler : arrayHandler;\n    this[name] = wrapperFnLine truncated
     "/**\n * @coreapi\n * @module params\n */ /** for typedoc */\nimport { extend, filter, map, allTrueR } from '../common/common';\nimport { prop } from '../common/hof';\nimport { isInjectable, isDefined, isString, isArray, isUndefined } from '../common/predicates';\nimport { RawParams, ParamDeclaration } from '../params/interface';\nimport { services } from '../common/coreservices';\nimport { ParamType } from './paramType';\nimport { ParamTypes } from './paramTypes';\nimport { UrlMatcherFactory } from '../url/urlMatcherFactory';\n\n/** @hidden */\nconst hasOwn = Object.prototype.hasOwnProperty;\n\n/** @hidden */\nconst isShorthand = (cfg: ParamDeclaration) =>\n    ['value', 'type', 'squash', 'array', 'dynamic'].filter(hasOwn.bind(cfg || {})).length === 0;\n\n/** @internalapi */\nexport enum DefType {\n  PATH,\n  SEARCH,\n  CONFIG,\n}\n\n/** @hidden */\nfunction unwrapShorthand(cfg: ParamDeclaration): ParamDeclaration {\n  cfg = isShorthand(cfg) && { value: cfg } as any || cfg;\n\n  getStaticDefaultValue['__cacheable'] = true;\n  function getStaticDefaultValue() {\n    return cfg.value;\n  }\n\n  return extend(cfg, {\n    $$fn: isInjectable(cfg.value) ? cfg.value : getStaticDefaultValue,\n  });\n}\n\n/** @hidden */\nfunction getType(cfg: ParamDeclaration, urlType: ParamType, location: DefType, id: string, paramTypes: ParamTypes) {\n  if (cfg.type && urlType && urlType.name !== 'string') throw new Error(`Param '${id}' has two type configurations.`);\n  if (cfg.type && urlType && urlType.name === 'string' && paramTypes.type(cfg.type as string)) return paramTypes.type(cfg.type as string);\n  if (urlType) return urlType;\n  if (!cfg.type) {\n    const type = location === DefType.CONFIG ? 'any' :\n        location === DefType.PATH ? 'path' :\n        location === DefType.SEARCH ? 'query' : 'string';\n    return paramTypes.type(type);\n  }\n  return cfg.type instanceof ParamType ? cfg.type : paramTypes.type(cfg.type as string);\n}\n\n/**\n * @internalapi\n * returns false, true, or the squash value to indicate the \"default parameter url squash policy\".\n */\nfunction getSquashPolicy(config: ParamDeclaration, isOptional: boolean, defaultPolicy: (boolean|string)) {\n  const squash = config.squash;\n  if (!isOptional || squash === false) return false;\n  if (!isDefined(squash) || squash == null) return defaultPolicy;\n  if (squash === true || isString(squash)) return squash;\n  throw new Error(`Invalid squash policy: '${squash}'. Valid policies: false, true, or arbitrary string`);\n}\n\n/** @internalapi */\nfunction getReplace(config: ParamDeclaration, arrayMode: boolean, isOptional: boolean, squash: (string|boolean)) {\n  const defaultPolicy = [\n    { from: '', to: (isOptional || arrayMode ? undefined : '') },\n    { from: null, to: (isOptional || arrayMode ? undefined : '') },\n  ];\n\n  const replace = isArray(config.replace) ? config.replace : [];\n  if (isString(squash)) replace.push({ from: squash, to: undefined });\n\n  const configuredKeys = map(replace, prop('from'));\n  return filter(defaultPolicy, item => configuredKeys.indexOf(item.from) === -1).concat(replace);\n}\n\n\n/** @internalapi */\nexport class Param {\n  id: string;\n  type: ParamType;\n  location: DefType;\n  isOptional: boolean;\n  dynamic: boolean;\n  raw: boolean;\n  squash: (boolean|string);\n  replace: [{ to: any, from: any }];\n  inherit: boolean;\n  array: boolean;\n  config: any;\n  /** Cache the default value if it is a static value */\n  _defaultValueCache: {\n    defaultValue: any,\n  };\n\n  static values(params: Param[], values: RawParams = {}): RawParams {\n    const paramValues = {} as RawParams;\n    for (const param of params) {\n      paramValues[param.id] = param.value(values[param.id]);\n    }\n    return paramValues;\n  }\n\n  /**\n   * Finds [[Param]] objects which have different param values\n   *\n   * Filters a list of [[Param]] objects to only those whose parameter values differ in two param value objects\n   *\n   * @param params: The list of Param objects to filter\n   * @param values1: The first set of parameter values\n   * @param values2: the second set of parameter values\n   *\n   * @returns any Param objects whose values were different between values1 and values2\n   */\n  static changed(params: Param[], values1: RawParams = {}, values2: RawParams = {}): Param[] {\n    return params.filter(param => !param.type.equals(values1[param.id], values2[param.id]));\n  }\n\n  /**\n   * Checks if two param value objects are equal (for a set of [[Param]] objects)\n   *\n   * @param params The list of [[Param]] objects to check\n   * @param values1 The first set of param values\n   * @param values2 The second set of param values\n   *\n   * @returns true if the param values in values1 and values2 are equal\n   */\n  static equals(params: Param[], values1 = {}, values2 = {}): boolean {\n    return Param.changed(params, values1, values2).length === 0;\n  }\n\n  /** Returns true if a the parameter values are valid, accorLine truncated
-    "/** @module path */ /** for typedoc */\nimport { extend, applyPairs, find, allTrueR, pairs, arrayTuples } from '../common/common';\nimport { propEq } from '../common/hof';\nimport { StateObject } from '../state/stateObject';\nimport { RawParams } from '../params/interface';\nimport { Param } from '../params/param';\nimport { Resolvable } from '../resolve/resolvable';\nimport { ViewConfig } from '../view/interface';\n\n/**\n * @internalapi\n *\n * A node in a [[TreeChanges]] path\n *\n * For a [[TreeChanges]] path, this class holds the stateful information for a single node in the path.\n * Each PathNode corresponds to a state being entered, exited, or retained.\n * The stateful information includes parameter values and resolve data.\n */\nexport class PathNode {\n  /** The state being entered, exited, or retained */\n  public state: StateObject;\n  /** The parameters declared on the state */\n  public paramSchema: Param[];\n  /** The parameter values that belong to the state */\n  public paramValues: { [key: string]: any };\n  /** The individual (stateful) resolvable objects that belong to the state */\n  public resolvables: Resolvable[];\n  /** The state's declared view configuration objects */\n  public views: ViewConfig[];\n\n  /** Returns a clone of the PathNode */\n  static clone(node: PathNode) {\n    return new PathNode(node);\n  }\n\n  /** Creates a copy of a PathNode */\n  constructor(node: PathNode);\n  /** Creates a new (empty) PathNode for a State */\n  constructor(state: StateObject);\n  constructor(stateOrNode: any) {\n    if (stateOrNode instanceof PathNode) {\n      const node: PathNode = stateOrNode;\n      this.state = node.state;\n      this.paramSchema = node.paramSchema.slice();\n      this.paramValues = extend({}, node.paramValues);\n      this.resolvables = node.resolvables.slice();\n      this.views = node.views && node.views.slice();\n    } else {\n      const state: StateObject = stateOrNode;\n      this.state = state;\n      this.paramSchema = state.parameters({ inherit: false });\n      this.paramValues = {};\n      this.resolvables = state.resolvables.map(res => res.clone());\n    }\n  }\n\n  /** Sets [[paramValues]] for the node, from the values of an object hash */\n  applyRawParams(params: RawParams): PathNode {\n    const getParamVal = (paramDef: Param) => [ paramDef.id, paramDef.value(params[paramDef.id]) ];\n    this.paramValues = this.paramSchema.reduce((memo, pDef) => applyPairs(memo, getParamVal(pDef)), {});\n    return this;\n  }\n\n  /** Gets a specific [[Param]] metadata that belongs to the node */\n  parameter(name: string): Param {\n    return find(this.paramSchema, propEq('id', name));\n  }\n\n  /**\n   * @returns true if the state and parameter values for another PathNode are\n   * equal to the state and param values for this PathNode\n   */\n  equals(node: PathNode, paramsFn?: GetParamsFn): boolean {\n    const diff = this.diff(node, paramsFn);\n    return diff && diff.length === 0;\n  }\n\n  /**\n   * Finds Params with different parameter values on another PathNode.\n   *\n   * Given another node (of the same state), finds the parameter values which differ.\n   * Returns the [[Param]] (schema objects) whose parameter values differ.\n   *\n   * Given another node for a different state, returns `false`\n   *\n   * @param node The node to compare to\n   * @param paramsFn A function that returns which parameters should be compared.\n   * @returns The [[Param]]s which differ, or null if the two nodes are for different states\n   */\n  diff(node: PathNode, paramsFn?: GetParamsFn): Param[] | false {\n    if (this.state !== node.state) return false;\n\n    const params: Param[] = paramsFn ? paramsFn(this) : this.paramSchema;\n    return Param.changed(params, this.paramValues, node.paramValues);\n  }\n}\n\n/** @hidden */\nexport type GetParamsFn = (pathNode: PathNode) => Param[];\n",
-    "/** @module path */ /** for typedoc */\n\nimport {\n  extend, find, pick, omit, tail, mergeR, values, unnestR, Predicate, inArray, arrayTuples,\n} from '../common/common';\nimport { prop, propEq, not } from '../common/hof';\n\nimport { RawParams } from '../params/interface';\nimport { TreeChanges } from '../transition/interface';\nimport { ViewConfig } from '../view/interface';\nimport { _ViewDeclaration } from '../state/interface';\n\nimport { StateObject } from '../state/stateObject';\nimport { TargetState } from '../state/targetState';\nimport { GetParamsFn, PathNode } from './pathNode';\nimport { ViewService } from '../view/view';\nimport { Param } from '../params/param';\nimport { StateRegistry } from '../state';\n\n/**\n * This class contains functions which convert TargetStates, Nodes and paths from one type to another.\n */\nexport class PathUtils {\n  /** Given a PathNode[], create an TargetState */\n  static makeTargetState(registry: StateRegistry, path: PathNode[]): TargetState {\n    const state = tail(path).state;\n    return new TargetState(registry, state, path.map(prop('paramValues')).reduce(mergeR, {}), {});\n  }\n\n  static buildPath(targetState: TargetState) {\n    const toParams = targetState.params();\n    return targetState.$state().path.map(state => new PathNode(state).applyRawParams(toParams));\n  }\n\n  /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */\n  static buildToPath(fromPath: PathNode[], targetState: TargetState): PathNode[] {\n    const toPath: PathNode[] = PathUtils.buildPath(targetState);\n    if (targetState.options().inherit) {\n      return PathUtils.inheritParams(fromPath, toPath, Object.keys(targetState.params()));\n    }\n    return toPath;\n  }\n\n  /**\n   * Creates ViewConfig objects and adds to nodes.\n   *\n   * On each [[PathNode]], creates ViewConfig objects from the views: property of the node's state\n   */\n  static applyViewConfigs($view: ViewService, path: PathNode[], states: StateObject[]) {\n    // Only apply the viewConfigs to the nodes for the given states\n    path.filter(node => inArray(states, node.state)).forEach(node => {\n      const viewDecls: _ViewDeclaration[] = values(node.state.views || {});\n      const subPath = PathUtils.subPath(path, n => n === node);\n      const viewConfigs: ViewConfig[][] = viewDecls.map(view => $view.createViewConfig(subPath, view));\n      node.views = viewConfigs.reduce(unnestR, []);\n    });\n  }\n\n  /**\n   * Given a fromPath and a toPath, returns a new to path which inherits parameters from the fromPath\n   *\n   * For a parameter in a node to be inherited from the from path:\n   * - The toPath's node must have a matching node in the fromPath (by state).\n   * - The parameter name must not be found in the toKeys parameter array.\n   *\n   * Note: the keys provided in toKeys are intended to be those param keys explicitly specified by some\n   * caller, for instance, $state.transitionTo(..., toParams).  If a key was found in toParams,\n   * it is not inherited from the fromPath.\n   */\n  static inheritParams(fromPath: PathNode[], toPath: PathNode[], toKeys: string[] = []): PathNode[] {\n    function nodeParamVals(path: PathNode[], state: StateObject): RawParams {\n      const node: PathNode = find(path, propEq('state', state));\n      return extend({}, node && node.paramValues);\n    }\n\n    const noInherit = fromPath.map(node => node.paramSchema)\n        .reduce(unnestR, [])\n        .filter(param => !param.inherit)\n        .map(prop('id'));\n\n    /**\n     * Given an [[PathNode]] \"toNode\", return a new [[PathNode]] with param values inherited from the\n     * matching node in fromPath.  Only inherit keys that aren't found in \"toKeys\" from the node in \"fromPath\"\"\n     */\n    function makeInheritedParamsNode(toNode: PathNode): PathNode {\n      // All param values for the node (may include default key/vals, when key was not found in toParams)\n      let toParamVals = extend({}, toNode && toNode.paramValues);\n      // limited to only those keys found in toParams\n      const incomingParamVals = pick(toParamVals, toKeys);\n      toParamVals = omit(toParamVals, toKeys);\n      const fromParamVals = omit(nodeParamVals(fromPath, toNode.state) || {}, noInherit);\n      // extend toParamVals with any fromParamVals, then override any of those those with incomingParamVals\n      const ownParamVals: RawParams = extend(toParamVals, fromParamVals, incomingParamVals);\n      return new PathNode(toNode.state).applyRawParams(ownParamVals);\n    }\n\n    // The param keys specified by the incoming toParams\n    return <PathNode[]> toPath.map(makeInheritedParamsNode);\n  }\n\n  static nonDynamicParams = (node: PathNode): Param[] =>\n      node.state.parameters({ inherit: false })\n          .filter(param => !param.dynamic);\n\n  /**\n   * Computes the tree changes (entering, exiting) between a fromPath and toPath.\n   */\n  static treeChanges(fromPath: PathNode[], toPath: PaLine truncated
-    "/**\n * @coreapi\n * @module resolve\n */ /** for typedoc */\nimport { extend, equals, inArray, identity } from '../common/common';\nimport { services } from '../common/coreservices';\nimport { trace } from '../common/trace';\nimport { ResolvePolicy, ResolvableLiteral, resolvePolicies } from './interface';\n\nimport { ResolveContext } from './resolveContext';\nimport { stringify } from '../common/strings';\nimport { isFunction, isObject } from '../common/predicates';\nimport { Transition } from '../transition/transition';\nimport { StateObject } from '../state/stateObject';\nimport { PathNode } from '../path/pathNode';\nimport { isNullOrUndefined } from '../common/predicates';\n\n\n// TODO: explicitly make this user configurable\nexport let defaultResolvePolicy: ResolvePolicy = {\n  when: 'LAZY',\n  async: 'WAIT',\n};\n\n/**\n * The basic building block for the resolve system.\n *\n * Resolvables encapsulate a state's resolve's resolveFn, the resolveFn's declared dependencies, the wrapped (.promise),\n * and the unwrapped-when-complete (.data) result of the resolveFn.\n *\n * Resolvable.get() either retrieves the Resolvable's existing promise, or else invokes resolve() (which invokes the\n * resolveFn) and returns the resulting promise.\n *\n * Resolvable.get() and Resolvable.resolve() both execute within a context path, which is passed as the first\n * parameter to those fns.\n */\nexport class Resolvable implements ResolvableLiteral {\n  token: any;\n  policy: ResolvePolicy;\n  resolveFn: Function;\n  deps: any[];\n\n  data: any;\n  resolved = false;\n  promise: Promise<any> = undefined;\n\n  static fromData = (token: any, data: any) =>\n    new Resolvable(token, () => data, null, null, data);\n\n  /** This constructor creates a Resolvable copy */\n  constructor(resolvable: Resolvable)\n\n  /** This constructor creates a new Resolvable from the plain old [[ResolvableLiteral]] javascript object */\n  constructor(resolvable: ResolvableLiteral)\n\n  /**\n   * This constructor creates a new `Resolvable`\n   *\n   * #### Example:\n   * ```js\n   * var resolvable1 = new Resolvable('mytoken', http => http.get('foo.json').toPromise(), [Http]);\n   *\n   * var resolvable2 = new Resolvable(UserService, dep => new UserService(dep.data), [SomeDependency]);\n   *\n   * var resolvable1Clone = new Resolvable(resolvable1);\n   * ```\n   *\n   * @param token The new resolvable's injection token, such as `\"userList\"` (a string) or `UserService` (a class).\n   *              When this token is used during injection, the resolved value will be injected.\n   * @param resolveFn The function that returns the resolved value, or a promise for the resolved value\n   * @param deps An array of dependencies, which will be injected into the `resolveFn`\n   * @param policy the [[ResolvePolicy]] defines when and how the Resolvable is processed\n   * @param data Pre-resolved data. If the resolve value is already known, it may be provided here.\n   */\n  constructor(token: any, resolveFn: Function, deps?: any[], policy?: ResolvePolicy, data?: any)\n  constructor(arg1: any, resolveFn?: Function, deps?: any[], policy?: ResolvePolicy, data?: any) {\n    if (arg1 instanceof Resolvable) {\n      extend(this, arg1);\n    } else if (isFunction(resolveFn)) {\n      if (isNullOrUndefined(arg1)) throw new Error('new Resolvable(): token argument is required');\n      if (!isFunction(resolveFn)) throw new Error('new Resolvable(): resolveFn argument must be a function');\n\n      this.token = arg1;\n      this.policy = policy;\n      this.resolveFn = resolveFn;\n      this.deps = deps || [];\n\n      this.data = data;\n      this.resolved = data !== undefined;\n      this.promise = this.resolved ? services.$q.when(this.data) : undefined;\n    } else if (isObject(arg1) && arg1.token && isFunction(arg1.resolveFn)) {\n      const literal = <ResolvableLiteral> arg1;\n      return new Resolvable(literal.token, literal.resolveFn, literal.deps, literal.policy, literal.data);\n    }\n  }\n\n  getPolicy(state: StateObject): ResolvePolicy {\n    const thisPolicy = this.policy || {};\n    const statePolicy = state && state.resolvePolicy || {};\n    return {\n      when: thisPolicy.when || statePolicy.when || defaultResolvePolicy.when,\n      async: thisPolicy.async || statePolicy.async || defaultResolvePolicy.async,\n    };\n  }\n\n  /**\n   * Asynchronously resolve this Resolvable's data\n   *\n   * Given a ResolveContext that this Resolvable is found in:\n   * Wait for this Resolvable's dependencies, then invoke this Resolvable's function\n   * and update the Resolvable's state\n   */\n  resolve(resolveContext: ResolveContext, trans?: Transition) {\n    const $q = services.$q;\n\n    // Gets all dependencies from ResolveContext and wait for them to be resolved\n    const getResolvableDependencies = () =>\n        $q.all(resolveContext.getDependencies(this).map(resolvable =>\n            resolvable.get(resolveContext, trans))) as Promise<any[]>;\n\n    Line truncated
+    "/** @module path */ /** for typedoc */\nimport { extend, applyPairs, find, allTrueR, pairs, arrayTuples } from '../common/common';\nimport { propEq } from '../common/hof';\nimport { StateObject } from '../state/stateObject';\nimport { RawParams } from '../params/interface';\nimport { Param } from '../params/param';\nimport { Resolvable } from '../resolve/resolvable';\nimport { ViewConfig } from '../view/interface';\n\n/**\n * @internalapi\n *\n * A node in a [[TreeChanges]] path\n *\n * For a [[TreeChanges]] path, this class holds the stateful information for a single node in the path.\n * Each PathNode corresponds to a state being entered, exited, or retained.\n * The stateful information includes parameter values and resolve data.\n */\nexport class PathNode {\n  /** The state being entered, exited, or retained */\n  public state: StateObject;\n  /** The parameters declared on the state */\n  public paramSchema: Param[];\n  /** The parameter values that belong to the state */\n  public paramValues: { [key: string]: any };\n  /** The individual (stateful) resolvable objects that belong to the state */\n  public resolvables: Resolvable[];\n  /** The state's declared view configuration objects */\n  public views: ViewConfig[];\n\n  /**\n   * Returns a clone of the PathNode\n   * @deprecated use instance method `node.clone()`\n   */\n  static clone = (node: PathNode) => node.clone();\n\n  /** Creates a copy of a PathNode */\n  constructor(node: PathNode);\n  /** Creates a new (empty) PathNode for a State */\n  constructor(state: StateObject);\n  constructor(stateOrNode: any) {\n    if (stateOrNode instanceof PathNode) {\n      const node: PathNode = stateOrNode;\n      this.state = node.state;\n      this.paramSchema = node.paramSchema.slice();\n      this.paramValues = extend({}, node.paramValues);\n      this.resolvables = node.resolvables.slice();\n      this.views = node.views && node.views.slice();\n    } else {\n      const state: StateObject = stateOrNode;\n      this.state = state;\n      this.paramSchema = state.parameters({ inherit: false });\n      this.paramValues = {};\n      this.resolvables = state.resolvables.map(res => res.clone());\n    }\n  }\n\n  clone() {\n    return new PathNode(this);\n  }\n\n  /** Sets [[paramValues]] for the node, from the values of an object hash */\n  applyRawParams(params: RawParams): PathNode {\n    const getParamVal = (paramDef: Param) => [ paramDef.id, paramDef.value(params[paramDef.id]) ];\n    this.paramValues = this.paramSchema.reduce((memo, pDef) => applyPairs(memo, getParamVal(pDef)), {});\n    return this;\n  }\n\n  /** Gets a specific [[Param]] metadata that belongs to the node */\n  parameter(name: string): Param {\n    return find(this.paramSchema, propEq('id', name));\n  }\n\n  /**\n   * @returns true if the state and parameter values for another PathNode are\n   * equal to the state and param values for this PathNode\n   */\n  equals(node: PathNode, paramsFn?: GetParamsFn): boolean {\n    const diff = this.diff(node, paramsFn);\n    return diff && diff.length === 0;\n  }\n\n  /**\n   * Finds Params with different parameter values on another PathNode.\n   *\n   * Given another node (of the same state), finds the parameter values which differ.\n   * Returns the [[Param]] (schema objects) whose parameter values differ.\n   *\n   * Given another node for a different state, returns `false`\n   *\n   * @param node The node to compare to\n   * @param paramsFn A function that returns which parameters should be compared.\n   * @returns The [[Param]]s which differ, or null if the two nodes are for different states\n   */\n  diff(node: PathNode, paramsFn?: GetParamsFn): Param[] | false {\n    if (this.state !== node.state) return false;\n\n    const params: Param[] = paramsFn ? paramsFn(this) : this.paramSchema;\n    return Param.changed(params, this.paramValues, node.paramValues);\n  }\n}\n\n/** @hidden */\nexport type GetParamsFn = (pathNode: PathNode) => Param[];\n",
+    "/** @module path */ /** for typedoc */\n\nimport {\n  extend, find, pick, omit, tail, mergeR, values, unnestR, Predicate, inArray, arrayTuples,\n} from '../common/common';\nimport { prop, propEq, not } from '../common/hof';\n\nimport { RawParams } from '../params/interface';\nimport { TreeChanges } from '../transition/interface';\nimport { ViewConfig } from '../view/interface';\nimport { _ViewDeclaration } from '../state/interface';\n\nimport { StateObject } from '../state/stateObject';\nimport { TargetState } from '../state/targetState';\nimport { GetParamsFn, PathNode } from './pathNode';\nimport { ViewService } from '../view/view';\nimport { Param } from '../params/param';\nimport { StateRegistry } from '../state';\n\n/**\n * This class contains functions which convert TargetStates, Nodes and paths from one type to another.\n */\nexport class PathUtils {\n  /** Given a PathNode[], create an TargetState */\n  static makeTargetState(registry: StateRegistry, path: PathNode[]): TargetState {\n    const state = tail(path).state;\n    return new TargetState(registry, state, path.map(prop('paramValues')).reduce(mergeR, {}), {});\n  }\n\n  static buildPath(targetState: TargetState) {\n    const toParams = targetState.params();\n    return targetState.$state().path.map(state => new PathNode(state).applyRawParams(toParams));\n  }\n\n  /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */\n  static buildToPath(fromPath: PathNode[], targetState: TargetState): PathNode[] {\n    const toPath: PathNode[] = PathUtils.buildPath(targetState);\n    if (targetState.options().inherit) {\n      return PathUtils.inheritParams(fromPath, toPath, Object.keys(targetState.params()));\n    }\n    return toPath;\n  }\n\n  /**\n   * Creates ViewConfig objects and adds to nodes.\n   *\n   * On each [[PathNode]], creates ViewConfig objects from the views: property of the node's state\n   */\n  static applyViewConfigs($view: ViewService, path: PathNode[], states: StateObject[]) {\n    // Only apply the viewConfigs to the nodes for the given states\n    path.filter(node => inArray(states, node.state)).forEach(node => {\n      const viewDecls: _ViewDeclaration[] = values(node.state.views || {});\n      const subPath = PathUtils.subPath(path, n => n === node);\n      const viewConfigs: ViewConfig[][] = viewDecls.map(view => $view.createViewConfig(subPath, view));\n      node.views = viewConfigs.reduce(unnestR, []);\n    });\n  }\n\n  /**\n   * Given a fromPath and a toPath, returns a new to path which inherits parameters from the fromPath\n   *\n   * For a parameter in a node to be inherited from the from path:\n   * - The toPath's node must have a matching node in the fromPath (by state).\n   * - The parameter name must not be found in the toKeys parameter array.\n   *\n   * Note: the keys provided in toKeys are intended to be those param keys explicitly specified by some\n   * caller, for instance, $state.transitionTo(..., toParams).  If a key was found in toParams,\n   * it is not inherited from the fromPath.\n   */\n  static inheritParams(fromPath: PathNode[], toPath: PathNode[], toKeys: string[] = []): PathNode[] {\n    function nodeParamVals(path: PathNode[], state: StateObject): RawParams {\n      const node: PathNode = find(path, propEq('state', state));\n      return extend({}, node && node.paramValues);\n    }\n\n    const noInherit = fromPath.map(node => node.paramSchema)\n        .reduce(unnestR, [])\n        .filter(param => !param.inherit)\n        .map(prop('id'));\n\n    /**\n     * Given an [[PathNode]] \"toNode\", return a new [[PathNode]] with param values inherited from the\n     * matching node in fromPath.  Only inherit keys that aren't found in \"toKeys\" from the node in \"fromPath\"\"\n     */\n    function makeInheritedParamsNode(toNode: PathNode): PathNode {\n      // All param values for the node (may include default key/vals, when key was not found in toParams)\n      let toParamVals = extend({}, toNode && toNode.paramValues);\n      // limited to only those keys found in toParams\n      const incomingParamVals = pick(toParamVals, toKeys);\n      toParamVals = omit(toParamVals, toKeys);\n      const fromParamVals = omit(nodeParamVals(fromPath, toNode.state) || {}, noInherit);\n      // extend toParamVals with any fromParamVals, then override any of those those with incomingParamVals\n      const ownParamVals: RawParams = extend(toParamVals, fromParamVals, incomingParamVals);\n      return new PathNode(toNode.state).applyRawParams(ownParamVals);\n    }\n\n    // The param keys specified by the incoming toParams\n    return <PathNode[]> toPath.map(makeInheritedParamsNode);\n  }\n\n  static nonDynamicParams = (node: PathNode): Param[] =>\n      node.state.parameters({ inherit: false })\n          .filter(param => !param.dynamic);\n\n  /**\n   * Computes the tree changes (entering, exiting) between a fromPath and toPath.\n   */\n  static treeChanges(fromPath: PathNode[], toPath: PaLine truncated
+    "/**\n * @coreapi\n * @module resolve\n */ /** for typedoc */\nimport { extend, equals, inArray, identity } from '../common/common';\nimport { services } from '../common/coreservices';\nimport { trace } from '../common/trace';\nimport { ResolvePolicy, ResolvableLiteral, resolvePolicies } from './interface';\n\nimport { ResolveContext } from './resolveContext';\nimport { stringify } from '../common/strings';\nimport { isFunction, isObject } from '../common/predicates';\nimport { Transition } from '../transition/transition';\nimport { StateObject } from '../state/stateObject';\nimport { PathNode } from '../path/pathNode';\nimport { isNullOrUndefined } from '../common/predicates';\n\n\n// TODO: explicitly make this user configurable\nexport let defaultResolvePolicy: ResolvePolicy = {\n  when: 'LAZY',\n  async: 'WAIT',\n};\n\n/**\n * The basic building block for the resolve system.\n *\n * Resolvables encapsulate a state's resolve's resolveFn, the resolveFn's declared dependencies, the wrapped (.promise),\n * and the unwrapped-when-complete (.data) result of the resolveFn.\n *\n * Resolvable.get() either retrieves the Resolvable's existing promise, or else invokes resolve() (which invokes the\n * resolveFn) and returns the resulting promise.\n *\n * Resolvable.get() and Resolvable.resolve() both execute within a context path, which is passed as the first\n * parameter to those fns.\n */\nexport class Resolvable implements ResolvableLiteral {\n  token: any;\n  policy: ResolvePolicy;\n  resolveFn: Function;\n  deps: any[];\n\n  data: any;\n  resolved = false;\n  promise: Promise<any> = undefined;\n\n  static fromData = (token: any, data: any) =>\n    new Resolvable(token, () => data, null, null, data);\n\n  /** This constructor creates a Resolvable copy */\n  constructor(resolvable: Resolvable)\n\n  /** This constructor creates a new Resolvable from the plain old [[ResolvableLiteral]] javascript object */\n  constructor(resolvable: ResolvableLiteral)\n\n  /**\n   * This constructor creates a new `Resolvable`\n   *\n   * #### Example:\n   * ```js\n   * var resolvable1 = new Resolvable('mytoken', http => http.get('foo.json').toPromise(), [Http]);\n   *\n   * var resolvable2 = new Resolvable(UserService, dep => new UserService(dep.data), [SomeDependency]);\n   *\n   * var resolvable1Clone = new Resolvable(resolvable1);\n   * ```\n   *\n   * @param token The new resolvable's injection token, such as `\"userList\"` (a string) or `UserService` (a class).\n   *              When this token is used during injection, the resolved value will be injected.\n   * @param resolveFn The function that returns the resolved value, or a promise for the resolved value\n   * @param deps An array of dependencies, which will be injected into the `resolveFn`\n   * @param policy the [[ResolvePolicy]] defines when and how the Resolvable is processed\n   * @param data Pre-resolved data. If the resolve value is already known, it may be provided here.\n   */\n  constructor(token: any, resolveFn: Function, deps?: any[], policy?: ResolvePolicy, data?: any)\n  constructor(arg1: any, resolveFn?: Function, deps?: any[], policy?: ResolvePolicy, data?: any) {\n    if (arg1 instanceof Resolvable) {\n      extend(this, arg1);\n    } else if (isFunction(resolveFn)) {\n      if (isNullOrUndefined(arg1)) throw new Error('new Resolvable(): token argument is required');\n      if (!isFunction(resolveFn)) throw new Error('new Resolvable(): resolveFn argument must be a function');\n\n      this.token = arg1;\n      this.policy = policy;\n      this.resolveFn = resolveFn;\n      this.deps = deps || [];\n\n      this.data = data;\n      this.resolved = data !== undefined;\n      this.promise = this.resolved ? services.$q.when(this.data) : undefined;\n    } else if (isObject(arg1) && arg1.token && (arg1.hasOwnProperty('resolveFn') || arg1.hasOwnProperty('data'))) {\n      const literal = <ResolvableLiteral> arg1;\n      return new Resolvable(literal.token, literal.resolveFn, literal.deps, literal.policy, literal.data);\n    }\n  }\n\n  getPolicy(state: StateObject): ResolvePolicy {\n    const thisPolicy = this.policy || {};\n    const statePolicy = state && state.resolvePolicy || {};\n    return {\n      when: thisPolicy.when || statePolicy.when || defaultResolvePolicy.when,\n      async: thisPolicy.async || statePolicy.async || defaultResolvePolicy.async,\n    };\n  }\n\n  /**\n   * Asynchronously resolve this Resolvable's data\n   *\n   * Given a ResolveContext that this Resolvable is found in:\n   * Wait for this Resolvable's dependencies, then invoke this Resolvable's function\n   * and update the Resolvable's state\n   */\n  resolve(resolveContext: ResolveContext, trans?: Transition) {\n    const $q = services.$q;\n\n    // Gets all dependencies from ResolveContext and wait for them to be resolved\n    const getResolvableDependencies = () =>\n        $q.all(resolveContext.getDependencies(this).map(resolvable =>\n            resolvable.get(resolveConteLine truncated
     "/**\n * # The Resolve subsystem\n *\n * This subsystem is an asynchronous, hierarchical Dependency Injection system.\n *\n * Typically, resolve is configured on a state using a [[StateDeclaration.resolve]] declaration.\n *\n * @coreapi\n * @module resolve\n */ /** for typedoc */\nimport { Resolvable } from './resolvable';\n\n/**\n * An interface which is similar to an Angular 2 `Provider`\n */\nexport interface ProviderLike {\n  provide: any,\n  useClass?: any,\n  useFactory?: Function,\n  useValue?: any,\n  useExisting?: any,\n  deps?: any[]\n}\n\n/**\n * A plain object used to describe a [[Resolvable]]\n *\n * These objects may be used in the [[StateDeclaration.resolve]] array to declare\n * async data that the state or substates require.\n *\n * #### Example:\n * ```js\n *\n * var state = {\n *   name: 'main',\n *   resolve: [\n *     { token: 'myData', deps: [MyDataApi], resolveFn: (myDataApi) => myDataApi.getData() },\n *   ],\n * }\n * ```\n */\nexport interface ResolvableLiteral {\n  /**\n   * A Dependency Injection token\n   *\n   * This Resolvable's DI token.\n   * The Resolvable will be injectable elsewhere using the token.\n   */\n  token: any;\n\n  /**\n   * A function which fetches the Resolvable's data\n   *\n   * A function which returns one of:\n   *\n   * - The resolved value (synchronously)\n   * - A promise for the resolved value\n   * - An Observable of the resolved value(s)\n   *\n   * This function will be provided the dependencies listed in [[deps]] as its arguments.\n   * The resolve system will asynchronously fetch the dependencies before invoking this function.\n   */\n  resolveFn: Function;\n\n  /**\n   * Defines the Resolve Policy\n   *\n   * A policy that defines when to invoke the resolve,\n   * and whether to wait for async and unwrap the data\n   */\n  policy?: ResolvePolicy;\n\n  /**\n   * The Dependency Injection tokens\n   *\n   * This is an array of Dependency Injection tokens for the dependencies of the [[resolveFn]].\n   *\n   * The DI tokens are references to other `Resolvables`, or to other\n   * services from the native DI system.\n   */\n  deps?: any[];\n\n  /** Pre-resolved data. */\n  data?: any\n}\n\n/**\n * Defines how a resolve is processed during a transition\n *\n * This object is the [[StateDeclaration.resolvePolicy]] property.\n *\n * #### Example:\n * ```js\n * // Fetched when the resolve's state is being entered.\n * // Wait for the promise to resolve.\n * var policy1 = { when: \"LAZY\", async: \"WAIT\" }\n *\n * // Fetched when the Transition is starting.\n * // Do not wait for the returned promise to resolve.\n * // Inject the raw promise/value\n * var policy2 = { when: \"EAGER\", async: \"NOWAIT\" }\n * ```\n *\n * The policy for a given Resolvable is merged from three sources (highest priority first):\n *\n * - 1) Individual resolve definition\n * - 2) State definition\n * - 3) Global default\n *\n * #### Example:\n * ```js\n * // Wait for an Observable to emit one item.\n * // Since `wait` is not specified, it uses the `wait`\n * // policy defined on the state, or the global default\n * // if no `wait` policy is defined on the state\n * var myResolvablePolicy = { async: \"RXWAIT\" }\n * ```\n */\nexport interface ResolvePolicy {\n  /**\n   * Defines when a Resolvable is resolved (fetched) during a transition\n   *\n   * - `LAZY` (default)\n   *   - Resolved as the resolve's state is being entered\n   * - `EAGER`\n   *   - Resolved as the transition is starting\n   *\n   * #### Example:\n   * Resolves for `main` and `main.home` are fetched when each state is entered.\n   * All of `main` resolves are processed before fetching `main.home` resolves.\n   * ```js\n   * var state = {\n   *   name: 'main',\n   *   resolve: mainResolves, // defined elsewhere\n   *   resolvePolicy: { when: 'LAZY' }, // default\n   * }\n   *\n   * var state = {\n   *   name: 'main.home',\n   *   resolve: homeResolves, // defined elsewhere\n   *   resolvePolicy: { when: 'LAZY' }, // default\n   * }\n   * ```\n   *\n   * #### Example:\n   * Resolves for `main` and `main.home` are fetched at the same time when the transition starts.\n   * This happens earlier in the lifecycle than when states are entered.\n   * All of the `main` and `main.home` resolves are fetched as soon as possible.\n   * ```js\n   * var mainState = {\n   *   name: 'main',\n   *   resolve: mainResolves, // defined elsewhere\n   *   resolvePolicy: { when: 'EAGER' },\n   * }\n   *\n   * var homeState = {\n   *   name: 'main.home',\n   *   resolve: homeResolves, // defined elsewhere\n   *   resolvePolicy: { when: 'EAGER' },\n   * }\n   * ```\n   */\n  when?: PolicyWhen;\n\n  /**\n   * Determines the unwrapping behavior of asynchronous resolve values.\n   *\n   * - `WAIT` (default)\n   *   - If a promise is returned from the resolveFn, wait for the promise before proceeding\n   *   - The unwrapped value from the promise\n   * - `NOWAIT`\n   *   - If a promise is returned from the resolve, do not wait for the Line truncated
     "/** @module resolve */\n/** for typedoc */\nimport { find, tail, uniqR, unnestR, inArray } from '../common/common';\nimport { propEq, not } from '../common/hof';\nimport { trace } from '../common/trace';\nimport { services, $InjectorLike } from '../common/coreservices';\nimport { resolvePolicies, PolicyWhen, ResolvePolicy } from './interface';\nimport { PathNode } from '../path/pathNode';\nimport { Resolvable } from './resolvable';\nimport { StateObject } from '../state/stateObject';\nimport { PathUtils } from '../path/pathUtils';\nimport { stringify } from '../common/strings';\nimport { Transition } from '../transition/transition';\nimport { UIInjector } from '../interface';\nimport { isUndefined } from '../common';\n\nconst whens = resolvePolicies.when;\nconst ALL_WHENS = [whens.EAGER, whens.LAZY];\nconst EAGER_WHENS = [whens.EAGER];\n\n// tslint:disable-next-line:no-inferrable-types\nexport const NATIVE_INJECTOR_TOKEN: string = 'Native Injector';\n\n/**\n * Encapsulates Dependency Injection for a path of nodes\n *\n * UI-Router states are organized as a tree.\n * A nested state has a path of ancestors to the root of the tree.\n * When a state is being activated, each element in the path is wrapped as a [[PathNode]].\n * A `PathNode` is a stateful object that holds things like parameters and resolvables for the state being activated.\n *\n * The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.\n */\nexport class ResolveContext {\n  _injector: UIInjector;\n\n  constructor(private _path: PathNode[]) { }\n\n  /** Gets all the tokens found in the resolve context, de-duplicated */\n  getTokens(): any[] {\n    return this._path.reduce((acc, node) => acc.concat(node.resolvables.map(r => r.token)), []).reduce(uniqR, []);\n  }\n\n  /**\n   * Gets the Resolvable that matches the token\n   *\n   * Gets the last Resolvable that matches the token in this context, or undefined.\n   * Throws an error if it doesn't exist in the ResolveContext\n   */\n  getResolvable(token: any): Resolvable {\n    const matching = this._path.map(node => node.resolvables)\n        .reduce(unnestR, [])\n        .filter((r: Resolvable) => r.token === token);\n    return tail(matching);\n  }\n\n  /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */\n  getPolicy(resolvable: Resolvable): ResolvePolicy {\n    const node = this.findNode(resolvable);\n    return resolvable.getPolicy(node.state);\n  }\n\n  /**\n   * Returns a ResolveContext that includes a portion of this one\n   *\n   * Given a state, this method creates a new ResolveContext from this one.\n   * The new context starts at the first node (root) and stops at the node for the `state` parameter.\n   *\n   * #### Why\n   *\n   * When a transition is created, the nodes in the \"To Path\" are injected from a ResolveContext.\n   * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.\n   * The \"To State\" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).\n   * This method is used to create a narrower context when injecting ancestor nodes.\n   *\n   * @example\n   * `let ABCD = new ResolveContext([A, B, C, D]);`\n   *\n   * Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:\n   * When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.\n   * However, `B` should only be able to access resolvables from `A`, `B`.\n   *\n   * When resolving for the `B` node, first take the full \"To Path\" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.\n   * `let AB = ABCD.subcontext(a)`\n   */\n  subContext(state: StateObject): ResolveContext {\n    return new ResolveContext(PathUtils.subPath(this._path, node => node.state === state));\n  }\n\n  /**\n   * Adds Resolvables to the node that matches the state\n   *\n   * This adds a [[Resolvable]] (generally one created on the fly; not declared on a [[StateDeclaration.resolve]] block).\n   * The resolvable is added to the node matching the `state` parameter.\n   *\n   * These new resolvables are not automatically fetched.\n   * The calling code should either fetch them, fetch something that depends on them,\n   * or rely on [[resolvePath]] being called when some state is being entered.\n   *\n   * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.\n   *\n   * @param newResolvables the new Resolvables\n   * @param state Used to find the node to put the resolvable on\n   */\n  addResolvables(newResolvables: Resolvable[], state: StateObject) {\n    const node = <PathNode> find(this._path, propEq('state', state));\n    const keys = newResolvables.map(r => r.token);\n    node.resolvables = node.resolvables.filter(r => keys.indexOf(r.token) === -1).concat(newResolvables);\n  }\n\n  /**\n   * Returns a promise for an array of resolved path Element promises\n   *\n   * @param when\n   * @param traLine truncated
     "/**\n * @coreapi\n * @module transition\n */\n/** for typedoc */\nimport { trace } from '../common/trace';\nimport { services } from '../common/coreservices';\nimport { stringify } from '../common/strings';\nimport { map, find, extend, mergeR, tail, omit, arrayTuples, unnestR, identity, anyTrueR } from '../common/common';\nimport { isObject, isUndefined } from '../common/predicates';\nimport { prop, propEq, val, not, is } from '../common/hof';\nimport { StateDeclaration, StateOrName } from '../state/interface';\nimport {\n  TransitionOptions, TreeChanges, IHookRegistry, TransitionHookPhase, RegisteredHooks, HookRegOptions,\n  HookMatchCriteria, TransitionStateHookFn, TransitionHookFn,\n} from './interface'; // has or is using\nimport { TransitionHook } from './transitionHook';\nimport { matchState, makeEvent, RegisteredHook } from './hookRegistry';\nimport { HookBuilder } from './hookBuilder';\nimport { PathNode } from '../path/pathNode';\nimport { PathUtils } from '../path/pathUtils';\nimport { StateObject } from '../state/stateObject';\nimport { TargetState } from '../state/targetState';\nimport { Param } from '../params/param';\nimport { Resolvable } from '../resolve/resolvable';\nimport { ViewConfig } from '../view/interface';\nimport { ResolveContext } from '../resolve/resolveContext';\nimport { UIRouter } from '../router';\nimport { UIInjector } from '../interface';\nimport { RawParams } from '../params/interface';\nimport { ResolvableLiteral } from '../resolve/interface';\n\n/** @hidden */\nconst stateSelf: (_state: StateObject) => StateDeclaration = prop('self');\n\n/**\n * Represents a transition between two states.\n *\n * When navigating to a state, we are transitioning **from** the current state **to** the new state.\n *\n * This object contains all contextual information about the to/from states, parameters, resolves.\n * It has information about all states being entered and exited as a result of the transition.\n */\nexport class Transition implements IHookRegistry {\n\n  /** @hidden */\n  static diToken = Transition;\n\n  /**\n   * A unique identifier for the transition.\n   *\n   * This is an auto incrementing integer, starting from `0`.\n   */\n  $id: number;\n\n  /**\n   * A reference to the [[UIRouter]] instance\n   *\n   * This reference can be used to access the router services, such as the [[StateService]]\n   */\n  router: UIRouter;\n\n  /** @hidden */\n  private _deferred = services.$q.defer();\n  /**\n   * This promise is resolved or rejected based on the outcome of the Transition.\n   *\n   * When the transition is successful, the promise is resolved\n   * When the transition is unsuccessful, the promise is rejected with the [[Rejection]] or javascript error\n   */\n  promise: Promise<any> = this._deferred.promise;\n  /**\n   * A boolean which indicates if the transition was successful\n   *\n   * After a successful transition, this value is set to true.\n   * After an unsuccessful transition, this value is set to false.\n   *\n   * The value will be undefined if the transition is not complete\n   */\n  success: boolean;\n  /** @hidden */\n  _aborted: boolean;\n  /** @hidden */\n  private _error: any;\n\n  /** @hidden Holds the hook registration functions such as those passed to Transition.onStart() */\n  _registeredHooks: RegisteredHooks = { };\n\n  /** @hidden */\n  private _options: TransitionOptions;\n  /** @hidden */\n  private _treeChanges: TreeChanges;\n  /** @hidden */\n  private _targetState: TargetState;\n  /** @hidden */\n  private _hookBuilder = new HookBuilder(this);\n\n\n  /** @hidden */\n  onBefore(criteria: HookMatchCriteria, callback: TransitionHookFn, options?: HookRegOptions): Function { return; }\n  /** @inheritdoc */\n  onStart(criteria: HookMatchCriteria, callback: TransitionHookFn, options?: HookRegOptions): Function { return; }\n  /** @inheritdoc */\n  onExit(criteria: HookMatchCriteria, callback: TransitionStateHookFn, options?: HookRegOptions): Function { return; }\n  /** @inheritdoc */\n  onRetain(criteria: HookMatchCriteria, callback: TransitionStateHookFn, options?: HookRegOptions): Function { return; }\n  /** @inheritdoc */\n  onEnter(criteria: HookMatchCriteria, callback: TransitionStateHookFn, options?: HookRegOptions): Function { return; }\n  /** @inheritdoc */\n  onFinish(criteria: HookMatchCriteria, callback: TransitionHookFn, options?: HookRegOptions): Function { return; }\n  /** @inheritdoc */\n  onSuccess(criteria: HookMatchCriteria, callback: TransitionHookFn, options?: HookRegOptions): Function { return; }\n  /** @inheritdoc */\n  onError(criteria: HookMatchCriteria, callback: TransitionHookFn, options?: HookRegOptions): Function { return; }\n\n  /** @hidden\n   * Creates the transition-level hook registration functions\n   * (which can then be used to register hooks)\n   */\n  private createTransitionHookRegFns() {\n    this.router.transitionService._pluginapi._getEvents()\n        .filter(type => type.hookPhase !== TransitionHookPhaseLine truncated
@@ -125,8 +125,8 @@
     "/**\n * @coreapi\n * @module view\n */ /** for typedoc */\nimport { equals, applyPairs, removeFrom, TypedMap, inArray } from '../common/common';\nimport { curry, prop } from '../common/hof';\nimport { isString, isArray } from '../common/predicates';\nimport { trace } from '../common/trace';\nimport { PathNode } from '../path/pathNode';\nimport { ActiveUIView, ViewContext, ViewConfig } from './interface';\nimport { _ViewDeclaration } from '../state/interface';\n\nexport type ViewConfigFactory = (path: PathNode[], decl: _ViewDeclaration) => ViewConfig|ViewConfig[];\n\nexport interface ViewServicePluginAPI {\n  _rootViewContext(context?: ViewContext): ViewContext;\n  _viewConfigFactory(viewType: string, factory: ViewConfigFactory);\n  _registeredUIViews(): ActiveUIView[];\n  _activeViewConfigs(): ViewConfig[];\n  _onSync(listener: ViewSyncListener): Function;\n}\n\n// A uiView and its matching viewConfig\nexport interface ViewTuple {\n  uiView: ActiveUIView;\n  viewConfig: ViewConfig;\n}\n\nexport interface ViewSyncListener {\n  (viewTuples: ViewTuple[]): void;\n}\n\n/**\n * The View service\n *\n * This service pairs existing `ui-view` components (which live in the DOM)\n * with view configs (from the state declaration objects: [[StateDeclaration.views]]).\n *\n * - After a successful Transition, the views from the newly entered states are activated via [[activateViewConfig]].\n *   The views from exited states are deactivated via [[deactivateViewConfig]].\n *   (See: the [[registerActivateViews]] Transition Hook)\n *\n * - As `ui-view` components pop in and out of existence, they register themselves using [[registerUIView]].\n *\n * - When the [[sync]] function is called, the registered `ui-view`(s) ([[ActiveUIView]])\n * are configured with the matching [[ViewConfig]](s)\n *\n */\nexport class ViewService {\n  private _uiViews: ActiveUIView[] = [];\n  private _viewConfigs: ViewConfig[] = [];\n  private _rootContext: ViewContext;\n  private _viewConfigFactories: { [key: string]: ViewConfigFactory } = {};\n  private _listeners: ViewSyncListener[] = [];\n\n  public _pluginapi: ViewServicePluginAPI = {\n    _rootViewContext: this._rootViewContext.bind(this),\n    _viewConfigFactory: this._viewConfigFactory.bind(this),\n    _registeredUIViews: () => this._uiViews,\n    _activeViewConfigs: () => this._viewConfigs,\n    _onSync: (listener: ViewSyncListener) => {\n      this._listeners.push(listener);\n      return () => removeFrom(this._listeners, listener);\n    },\n  };\n\n  /**\n   * Given a ui-view and a ViewConfig, determines if they \"match\".\n   *\n   * A ui-view has a fully qualified name (fqn) and a context object.  The fqn is built from its overall location in\n   * the DOM, describing its nesting relationship to any parent ui-view tags it is nested inside of.\n   *\n   * A ViewConfig has a target ui-view name and a context anchor.  The ui-view name can be a simple name, or\n   * can be a segmented ui-view path, describing a portion of a ui-view fqn.\n   *\n   * In order for a ui-view to match ViewConfig, ui-view's $type must match the ViewConfig's $type\n   *\n   * If the ViewConfig's target ui-view name is a simple name (no dots), then a ui-view matches if:\n   * - the ui-view's name matches the ViewConfig's target name\n   * - the ui-view's context matches the ViewConfig's anchor\n   *\n   * If the ViewConfig's target ui-view name is a segmented name (with dots), then a ui-view matches if:\n   * - There exists a parent ui-view where:\n   *    - the parent ui-view's name matches the first segment (index 0) of the ViewConfig's target name\n   *    - the parent ui-view's context matches the ViewConfig's anchor\n   * - And the remaining segments (index 1..n) of the ViewConfig's target name match the tail of the ui-view's fqn\n   *\n   * Example:\n   *\n   * DOM:\n   * <ui-view>                        <!-- created in the root context (name: \"\") -->\n   *   <ui-view name=\"foo\">                <!-- created in the context named: \"A\"      -->\n   *     <ui-view>                    <!-- created in the context named: \"A.B\"    -->\n   *       <ui-view name=\"bar\">            <!-- created in the context named: \"A.B.C\"  -->\n   *       </ui-view>\n   *     </ui-view>\n   *   </ui-view>\n   * </ui-view>\n   *\n   * uiViews: [\n   *  { fqn: \"$default\",                  creationContext: { name: \"\" } },\n   *  { fqn: \"$default.foo\",              creationContext: { name: \"A\" } },\n   *  { fqn: \"$default.foo.$default\",     creationContext: { name: \"A.B\" } }\n   *  { fqn: \"$default.foo.$default.bar\", creationContext: { name: \"A.B.C\" } }\n   * ]\n   *\n   * These four view configs all match the ui-view with the fqn: \"$default.foo.$default.bar\":\n   *\n   * - ViewConfig1: { uiViewName: \"bar\",                       uiViewContextAnchor: \"A.B.C\" }\n   * - ViewConfig2: { uiViewName: \"$default.bar\",              uiViewContextAnchor: \"A.B\" }\n   * - ViewConfig3: { uiViewName: \"foo.$defLine truncated
     "/**\n * @coreapi\n * @module core\n */ /** */\nimport { StateParams } from './params/stateParams';\nimport { StateDeclaration } from './state/interface';\nimport { StateObject } from './state/stateObject';\nimport { Transition } from './transition/transition';\nimport { Queue } from './common/queue';\nimport { Disposable } from './interface';\n\n/**\n * Global router state\n *\n * This is where we hold the global mutable state such as current state, current\n * params, current transition, etc.\n */\nexport class UIRouterGlobals implements Disposable {\n  /**\n   * Current parameter values\n   *\n   * The parameter values from the latest successful transition\n   */\n  params: StateParams = new StateParams();\n\n  /**\n   * Current state\n   *\n   * The to-state from the latest successful transition\n   */\n  current: StateDeclaration;\n\n  /**\n   * Current state (internal object)\n   *\n   * The to-state from the latest successful transition\n   * @internalapi\n   */\n  $current: StateObject;\n\n  /**\n   * The current started/running transition.\n   * This transition has reached at least the onStart phase, but is not yet complete\n   */\n  transition: Transition;\n\n  /** @internalapi */\n  lastStartedTransitionId = -1;\n\n  /** @internalapi */\n  transitionHistory = new Queue<Transition>([], 1);\n\n  /** @internalapi */\n  successfulTransitions = new Queue<Transition>([], 1);\n\n  dispose() {\n    this.transitionHistory.clear();\n    this.successfulTransitions.clear();\n    this.transition = null;\n  }\n}\n",
     "/**\n * @coreapi\n * @module url\n */ /** */\n\nimport { UIRouter } from '../router';\nimport { LocationServices, notImplemented, LocationConfig } from '../common/coreservices';\nimport { noop, createProxyFunctions } from '../common/common';\nimport { UrlConfigApi, UrlSyncApi, UrlRulesApi, UrlParts, MatchResult } from './interface';\n\n/** @hidden */\nconst makeStub = (keys: string[]): any =>\n    keys.reduce((acc, key) => (acc[key] = notImplemented(key), acc), { dispose: noop });\n\n/* tslint:disable:align */\n/** @hidden */ const locationServicesFns = ['url', 'path', 'search', 'hash', 'onChange'];\n/** @hidden */ const locationConfigFns = ['port', 'protocol', 'host', 'baseHref', 'html5Mode', 'hashPrefix'];\n/** @hidden */ const umfFns = ['type', 'caseInsensitive', 'strictMode', 'defaultSquashPolicy'];\n/** @hidden */ const rulesFns = ['sort', 'when', 'initial', 'otherwise', 'rules', 'rule', 'removeRule'];\n/** @hidden */ const syncFns = ['deferIntercept', 'listen', 'sync', 'match'];\n/* tslint:enable:align */\n\n/**\n * API for URL management\n */\nexport class UrlService implements LocationServices, UrlSyncApi {\n  /** @hidden */\n  static locationServiceStub: LocationServices = makeStub(locationServicesFns);\n  /** @hidden */\n  static locationConfigStub: LocationConfig = makeStub(locationConfigFns);\n\n  /**\n   * A nested API for managing URL rules and rewrites\n   *\n   * See: [[UrlRulesApi]] for details\n   */\n  rules: UrlRulesApi;\n\n  /**\n   * A nested API to configure the URL and retrieve URL information\n   *\n   * See: [[UrlConfigApi]] for details\n   */\n  config: UrlConfigApi;\n\n  /** @hidden */\n  private router: UIRouter;\n\n  /** @hidden */\n  constructor(router: UIRouter, lateBind = true) {\n    this.router = router;\n    this.rules = {} as any;\n    this.config = {} as any;\n\n    // proxy function calls from UrlService to the LocationService/LocationConfig\n    const locationServices = () => router.locationService;\n    createProxyFunctions(locationServices, this, locationServices, locationServicesFns, lateBind);\n\n    const locationConfig = () => router.locationConfig;\n    createProxyFunctions(locationConfig, this.config, locationConfig, locationConfigFns, lateBind);\n\n    const umf = () => router.urlMatcherFactory;\n    createProxyFunctions(umf, this.config, umf, umfFns);\n\n    const urlRouter = () => router.urlRouter;\n    createProxyFunctions(urlRouter, this.rules, urlRouter, rulesFns);\n    createProxyFunctions(urlRouter, this, urlRouter, syncFns);\n  }\n\n  /** @inheritdoc */\n  url(): string;\n  /** @inheritdoc */\n  url(newurl: string, replace?: boolean, state?): void;\n  url(newurl?, replace?, state?): any { return; }\n  /** @inheritdoc */\n  path(): string { return; }\n  /** @inheritdoc */\n  search(): { [key: string]: any } { return; }\n  /** @inheritdoc */\n  hash(): string { return; }\n  /** @inheritdoc */\n  onChange(callback: Function): Function { return; }\n\n\n  /**\n   * Returns the current URL parts\n   *\n   * This method returns the current URL components as a [[UrlParts]] object.\n   *\n   * @returns the current url parts\n   */\n  parts(): UrlParts {\n    return { path: this.path(), search: this.search(), hash: this.hash() };\n  }\n\n  dispose() { }\n\n  /** @inheritdoc */\n  sync(evt?) { return; }\n  /** @inheritdoc */\n  listen(enabled?: boolean): Function { return; }\n  /** @inheritdoc */\n  deferIntercept(defer?: boolean) { return; }\n  /** @inheritdoc */\n  match(urlParts: UrlParts): MatchResult { return; }\n\n}\n",
-    "/**\n * @coreapi\n * @module core\n */ /** */\nimport { UrlMatcherFactory } from './url/urlMatcherFactory';\nimport { UrlRouter } from './url/urlRouter';\nimport { TransitionService } from './transition/transitionService';\nimport { ViewService } from './view/view';\nimport { StateRegistry } from './state/stateRegistry';\nimport { StateService } from './state/stateService';\nimport { UIRouterGlobals } from './globals';\nimport { UIRouterPlugin, Disposable } from './interface';\nimport { values, removeFrom } from './common/common';\nimport { isFunction } from './common/predicates';\nimport { UrlService } from './url/urlService';\nimport { LocationServices, LocationConfig } from './common/coreservices';\nimport { Trace, trace } from './common/trace';\n\n/** @hidden */\nlet _routerInstance = 0;\n\n/**\n * The master class used to instantiate an instance of UI-Router.\n *\n * UI-Router (for each specific framework) will create an instance of this class during bootstrap.\n * This class instantiates and wires the UI-Router services together.\n *\n * After a new instance of the UIRouter class is created, it should be configured for your app.\n * For instance, app states should be registered with the [[UIRouter.stateRegistry]].\n *\n * ---\n *\n * Normally the framework code will bootstrap UI-Router.\n * If you are bootstrapping UIRouter manually, tell it to monitor the URL by calling\n * [[UrlService.listen]] then [[UrlService.sync]].\n */\nexport class UIRouter {\n  /** @hidden */ $id = _routerInstance++;\n  /** @hidden */ _disposed = false;\n  /** @hidden */ private _disposables: Disposable[] = [];\n\n  /** Provides trace information to the console */\n  trace: Trace = trace;\n\n  /** Provides services related to ui-view synchronization */\n  viewService = new ViewService();\n\n  /** Provides services related to Transitions */\n  transitionService: TransitionService = new TransitionService(this);\n\n  /** Global router state */\n  globals: UIRouterGlobals = new UIRouterGlobals();\n\n  /**\n   * Deprecated for public use. Use [[urlService]] instead.\n   * @deprecated Use [[urlService]] instead\n   */\n  urlMatcherFactory: UrlMatcherFactory = new UrlMatcherFactory();\n\n  /**\n   * Deprecated for public use. Use [[urlService]] instead.\n   * @deprecated Use [[urlService]] instead\n   */\n  urlRouter: UrlRouter = new UrlRouter(this);\n\n  /** Provides a registry for states, and related registration services */\n  stateRegistry: StateRegistry = new StateRegistry(this);\n\n  /** Provides services related to states */\n  stateService = new StateService(this);\n\n  /** Provides services related to the URL */\n  urlService: UrlService = new UrlService(this);\n\n  /** @hidden plugin instances are registered here */\n  private _plugins: { [key: string]: UIRouterPlugin } = {};\n\n\n  /** Registers an object to be notified when the router is disposed */\n  disposable(disposable: Disposable) {\n    this._disposables.push(disposable);\n  }\n\n  /**\n   * Disposes this router instance\n   *\n   * When called, clears resources retained by the router by calling `dispose(this)` on all\n   * registered [[disposable]] objects.\n   *\n   * Or, if a `disposable` object is provided, calls `dispose(this)` on that object only.\n   *\n   * @param disposable (optional) the disposable to dispose\n   */\n  dispose(disposable?: any): void {\n    if (disposable && isFunction(disposable.dispose)) {\n      disposable.dispose(this);\n      return undefined;\n    }\n\n    this._disposed = true;\n    this._disposables.slice().forEach(d => {\n      try {\n        typeof d.dispose === 'function' && d.dispose(this);\n        removeFrom(this._disposables, d);\n      } catch (ignored) {}\n    });\n  }\n\n  /**\n   * Creates a new `UIRouter` object\n   *\n   * @param locationService a [[LocationServices]] implementation\n   * @param locationConfig a [[LocationConfig]] implementation\n   * @internalapi\n   */\n  constructor(\n      public locationService: LocationServices = UrlService.locationServiceStub,\n      public locationConfig: LocationConfig = UrlService.locationConfigStub,\n  ) {\n\n    this.viewService._pluginapi._rootViewContext(this.stateRegistry.root());\n    this.globals.$current = this.stateRegistry.root();\n    this.globals.current = this.globals.$current.self;\n\n    this.disposable(this.globals);\n    this.disposable(this.stateService);\n    this.disposable(this.stateRegistry);\n    this.disposable(this.transitionService);\n    this.disposable(this.urlRouter);\n    this.disposable(locationService);\n    this.disposable(locationConfig);\n  }\n\n  /** Add plugin (as ES6 class) */\n  plugin<T extends UIRouterPlugin>(plugin: { new(router: UIRouter, options?: any): T }, options?: any): T;\n  /** Add plugin (as javascript constructor function) */\n  plugin<T extends UIRouterPlugin>(plugin: { (router: UIRouter, options?: any): void }, options?: any): T;\n  /** Add plugin (as javascript factory function) */\n  plugin<T extends UIRouterPluLine truncated
-    "/** @module hooks */ /** */\nimport { Transition } from '../transition/transition';\nimport { UIRouter } from '../router';\nimport { TransitionService } from '../transition/transitionService';\n\nfunction addCoreResolvables(trans: Transition) {\n  trans.addResolvable({ token: UIRouter,       deps: [], resolveFn: () => trans.router,   data: trans.router },   '');\n  trans.addResolvable({ token: Transition,     deps: [], resolveFn: () => trans,          data: trans },          '');\n  trans.addResolvable({ token: '$transition$', deps: [], resolveFn: () => trans,          data: trans },          '');\n  trans.addResolvable({ token: '$stateParams', deps: [], resolveFn: () => trans.params(), data: trans.params() }, '');\n\n  trans.entering().forEach(state => {\n    trans.addResolvable({ token: '$state$',    deps: [], resolveFn: () => state,          data: state },       state);\n  });\n}\n\nexport const registerAddCoreResolvables = (transitionService: TransitionService) =>\n    transitionService.onCreate({}, addCoreResolvables);\n",
+    "/**\n * @coreapi\n * @module core\n */ /** */\nimport { UrlMatcherFactory } from './url/urlMatcherFactory';\nimport { UrlRouter } from './url/urlRouter';\nimport { TransitionService } from './transition/transitionService';\nimport { ViewService } from './view/view';\nimport { StateRegistry } from './state/stateRegistry';\nimport { StateService } from './state/stateService';\nimport { UIRouterGlobals } from './globals';\nimport { UIRouterPlugin, Disposable } from './interface';\nimport { values, removeFrom } from './common/common';\nimport { isFunction } from './common/predicates';\nimport { UrlService } from './url/urlService';\nimport { LocationServices, LocationConfig } from './common/coreservices';\nimport { Trace, trace } from './common/trace';\n\n/** @hidden */\nlet _routerInstance = 0;\n\n/**\n * The master class used to instantiate an instance of UI-Router.\n *\n * UI-Router (for each specific framework) will create an instance of this class during bootstrap.\n * This class instantiates and wires the UI-Router services together.\n *\n * After a new instance of the UIRouter class is created, it should be configured for your app.\n * For instance, app states should be registered with the [[UIRouter.stateRegistry]].\n *\n * ---\n *\n * Normally the framework code will bootstrap UI-Router.\n * If you are bootstrapping UIRouter manually, tell it to monitor the URL by calling\n * [[UrlService.listen]] then [[UrlService.sync]].\n */\nexport class UIRouter {\n  /** @hidden */ $id = _routerInstance++;\n  /** @hidden */ _disposed = false;\n  /** @hidden */ private _disposables: Disposable[] = [];\n\n  /** Provides trace information to the console */\n  trace: Trace = trace;\n\n  /** Provides services related to ui-view synchronization */\n  viewService = new ViewService();\n\n  /** Global router state */\n  globals: UIRouterGlobals = new UIRouterGlobals();\n\n  /** Provides services related to Transitions */\n  transitionService: TransitionService = new TransitionService(this);\n\n  /**\n   * Deprecated for public use. Use [[urlService]] instead.\n   * @deprecated Use [[urlService]] instead\n   */\n  urlMatcherFactory: UrlMatcherFactory = new UrlMatcherFactory();\n\n  /**\n   * Deprecated for public use. Use [[urlService]] instead.\n   * @deprecated Use [[urlService]] instead\n   */\n  urlRouter: UrlRouter = new UrlRouter(this);\n\n  /** Provides a registry for states, and related registration services */\n  stateRegistry: StateRegistry = new StateRegistry(this);\n\n  /** Provides services related to states */\n  stateService = new StateService(this);\n\n  /** Provides services related to the URL */\n  urlService: UrlService = new UrlService(this);\n\n  /** @hidden plugin instances are registered here */\n  private _plugins: { [key: string]: UIRouterPlugin } = {};\n\n\n  /** Registers an object to be notified when the router is disposed */\n  disposable(disposable: Disposable) {\n    this._disposables.push(disposable);\n  }\n\n  /**\n   * Disposes this router instance\n   *\n   * When called, clears resources retained by the router by calling `dispose(this)` on all\n   * registered [[disposable]] objects.\n   *\n   * Or, if a `disposable` object is provided, calls `dispose(this)` on that object only.\n   *\n   * @param disposable (optional) the disposable to dispose\n   */\n  dispose(disposable?: any): void {\n    if (disposable && isFunction(disposable.dispose)) {\n      disposable.dispose(this);\n      return undefined;\n    }\n\n    this._disposed = true;\n    this._disposables.slice().forEach(d => {\n      try {\n        typeof d.dispose === 'function' && d.dispose(this);\n        removeFrom(this._disposables, d);\n      } catch (ignored) {}\n    });\n  }\n\n  /**\n   * Creates a new `UIRouter` object\n   *\n   * @param locationService a [[LocationServices]] implementation\n   * @param locationConfig a [[LocationConfig]] implementation\n   * @internalapi\n   */\n  constructor(\n      public locationService: LocationServices = UrlService.locationServiceStub,\n      public locationConfig: LocationConfig = UrlService.locationConfigStub,\n  ) {\n\n    this.viewService._pluginapi._rootViewContext(this.stateRegistry.root());\n    this.globals.$current = this.stateRegistry.root();\n    this.globals.current = this.globals.$current.self;\n\n    this.disposable(this.globals);\n    this.disposable(this.stateService);\n    this.disposable(this.stateRegistry);\n    this.disposable(this.transitionService);\n    this.disposable(this.urlRouter);\n    this.disposable(locationService);\n    this.disposable(locationConfig);\n  }\n\n  /** Add plugin (as ES6 class) */\n  plugin<T extends UIRouterPlugin>(plugin: { new(router: UIRouter, options?: any): T }, options?: any): T;\n  /** Add plugin (as javascript constructor function) */\n  plugin<T extends UIRouterPlugin>(plugin: { (router: UIRouter, options?: any): void }, options?: any): T;\n  /** Add plugin (as javascript factory function) */\n  plugin<T extends UIRouterPluLine truncated
+    "/** @module hooks */ /** */\nimport { Transition } from '../transition/transition';\nimport { UIRouter } from '../router';\nimport { TransitionService } from '../transition/transitionService';\nimport { Resolvable } from '../resolve';\nimport { extend, inArray, map, mapObj, unnestR, values } from '../common';\nimport { PathNode } from '../path';\nimport { TreeChanges } from \"../transition\";\n\nfunction addCoreResolvables(trans: Transition) {\n  trans.addResolvable(Resolvable.fromData(UIRouter, trans.router), '');\n  trans.addResolvable(Resolvable.fromData(Transition, trans), '');\n  trans.addResolvable(Resolvable.fromData('$transition$', trans), '');\n  trans.addResolvable(Resolvable.fromData('$stateParams', trans.params()), '');\n\n  trans.entering().forEach(state => {\n    trans.addResolvable(Resolvable.fromData('$state$', state), state);\n  });\n}\n\nexport const registerAddCoreResolvables = (transitionService: TransitionService) =>\n    transitionService.onCreate({}, addCoreResolvables);\n\nconst TRANSITION_TOKENS = ['$transition$', Transition];\nconst isTransition = inArray(TRANSITION_TOKENS);\n\n// References to Transition in the treeChanges pathnodes makes all\n// previous Transitions reachable in memory, causing a memory leak\n// This function removes resolves for '$transition$' and `Transition` from the treeChanges.\n// Do not use this on current transitions, only on old ones.\nexport const treeChangesCleanup = (trans: Transition) => {\n  // If the resolvable is a Transition, return a new resolvable with null data\n  const replaceTransitionWithNull = (r: Resolvable): Resolvable =>\n    isTransition(r.token) ? Resolvable.fromData(r.token, null) : r;\n\n  const cleanPath = (path: PathNode[]) => path.map((node: PathNode) => {\n    const resolvables = node.resolvables.map(replaceTransitionWithNull);\n    return extend(node.clone(), { resolvables });\n  });\n\n  const treeChanges: TreeChanges = trans.treeChanges();\n  mapObj(treeChanges, cleanPath, treeChanges);\n};\n",
     "/** @module hooks */ /** */\nimport { isString, isFunction } from '../common/predicates';\nimport { Transition } from '../transition/transition';\nimport { services } from '../common/coreservices';\nimport { TargetState } from '../state/targetState';\nimport { TransitionService } from '../transition/transitionService';\nimport { TransitionHookFn } from '../transition/interface';\n\n/**\n * A [[TransitionHookFn]] that redirects to a different state or params\n *\n * Registered using `transitionService.onStart({ to: (state) => !!state.redirectTo }, redirectHook);`\n *\n * See [[StateDeclaration.redirectTo]]\n */\nconst redirectToHook: TransitionHookFn = (trans: Transition) => {\n  const redirect = trans.to().redirectTo;\n  if (!redirect) return;\n\n  const $state = trans.router.stateService;\n\n  function handleResult(result: any) {\n    if (!result) return;\n    if (result instanceof TargetState) return result;\n    if (isString(result)) return $state.target(<any> result, trans.params(), trans.options());\n    if (result['state'] || result['params'])\n      return $state.target(result['state'] || trans.to(), result['params'] || trans.params(), trans.options());\n  }\n\n  if (isFunction(redirect)) {\n    return services.$q.when(redirect(trans)).then(handleResult);\n  }\n  return handleResult(redirect);\n};\n\nexport const registerRedirectToHook = (transitionService: TransitionService) =>\n    transitionService.onStart({ to: (state) => !!state.redirectTo }, redirectToHook);\n",
     "/** @module hooks */\n/** for typedoc */\nimport { TransitionStateHookFn } from '../transition/interface';\nimport { Transition } from '../transition/transition';\nimport { TransitionService } from '../transition/transitionService';\nimport { StateDeclaration } from '../state/interface';\nimport { StateObject } from '../state/stateObject';\n\n/**\n * A factory which creates an onEnter, onExit or onRetain transition hook function\n *\n * The returned function invokes the (for instance) state.onEnter hook when the\n * state is being entered.\n *\n * @hidden\n */\nfunction makeEnterExitRetainHook(hookName: string): TransitionStateHookFn {\n  return (transition: Transition, state: StateDeclaration) => {\n    const _state: StateObject = state.$$state();\n    const hookFn: TransitionStateHookFn = _state[hookName];\n    return hookFn(transition, state);\n  };\n}\n\n/**\n * The [[TransitionStateHookFn]] for onExit\n *\n * When the state is being exited, the state's .onExit function is invoked.\n *\n * Registered using `transitionService.onExit({ exiting: (state) => !!state.onExit }, onExitHook);`\n *\n * See: [[IHookRegistry.onExit]]\n */\nconst onExitHook: TransitionStateHookFn = makeEnterExitRetainHook('onExit');\nexport const registerOnExitHook = (transitionService: TransitionService) =>\n    transitionService.onExit({ exiting: state => !!state.onExit }, onExitHook);\n\n/**\n * The [[TransitionStateHookFn]] for onRetain\n *\n * When the state was already entered, and is not being exited or re-entered, the state's .onRetain function is invoked.\n *\n * Registered using `transitionService.onRetain({ retained: (state) => !!state.onRetain }, onRetainHook);`\n *\n * See: [[IHookRegistry.onRetain]]\n */\nconst onRetainHook: TransitionStateHookFn = makeEnterExitRetainHook('onRetain');\nexport const registerOnRetainHook = (transitionService: TransitionService) =>\n    transitionService.onRetain({ retained: state => !!state.onRetain }, onRetainHook);\n\n/**\n * The [[TransitionStateHookFn]] for onEnter\n *\n * When the state is being entered, the state's .onEnter function is invoked.\n *\n * Registered using `transitionService.onEnter({ entering: (state) => !!state.onEnter }, onEnterHook);`\n *\n * See: [[IHookRegistry.onEnter]]\n */\nconst onEnterHook: TransitionStateHookFn = makeEnterExitRetainHook('onEnter');\nexport const registerOnEnterHook = (transitionService: TransitionService) =>\n    transitionService.onEnter({ entering: state => !!state.onEnter }, onEnterHook);\n\n",
     "/** @module hooks */\n/** for typedoc */\nimport { noop } from '../common/common';\nimport { Transition } from '../transition/transition';\nimport { ResolveContext } from '../resolve/resolveContext';\nimport { TransitionStateHookFn, TransitionHookFn } from '../transition/interface';\nimport { TransitionService } from '../transition/transitionService';\nimport { val } from '../common/hof';\nimport { StateDeclaration } from '../state/interface';\n\nexport const RESOLVE_HOOK_PRIORITY = 1000;\n\n/**\n * A [[TransitionHookFn]] which resolves all EAGER Resolvables in the To Path\n *\n * Registered using `transitionService.onStart({}, eagerResolvePath, { priority: 1000 });`\n *\n * When a Transition starts, this hook resolves all the EAGER Resolvables, which the transition then waits for.\n *\n * See [[StateDeclaration.resolve]]\n */\nconst eagerResolvePath: TransitionHookFn = (trans: Transition) =>\n    new ResolveContext(trans.treeChanges().to)\n        .resolvePath('EAGER', trans)\n        .then(noop);\n\nexport const registerEagerResolvePath = (transitionService: TransitionService) =>\n    transitionService.onStart({}, eagerResolvePath, { priority: RESOLVE_HOOK_PRIORITY });\n\n/**\n * A [[TransitionHookFn]] which resolves all LAZY Resolvables for the state (and all its ancestors) in the To Path\n *\n * Registered using `transitionService.onEnter({ entering: () => true }, lazyResolveState, { priority: 1000 });`\n *\n * When a State is being entered, this hook resolves all the Resolvables for this state, which the transition then waits for.\n *\n * See [[StateDeclaration.resolve]]\n */\nconst lazyResolveState: TransitionStateHookFn = (trans: Transition, state: StateDeclaration) =>\n    new ResolveContext(trans.treeChanges().to)\n        .subContext(state.$$state())\n        .resolvePath('LAZY', trans)\n        .then(noop);\n\nexport const registerLazyResolveState = (transitionService: TransitionService) =>\n    transitionService.onEnter({ entering: val(true) }, lazyResolveState, { priority: RESOLVE_HOOK_PRIORITY });\n\n\n/**\n * A [[TransitionHookFn]] which resolves any dynamically added (LAZY or EAGER) Resolvables.\n *\n * Registered using `transitionService.onFinish({}, eagerResolvePath, { priority: 1000 });`\n *\n * After all entering states have been entered, this hook resolves any remaining Resolvables.\n * These are typically dynamic resolves which were added by some Transition Hook using [[Transition.addResolvable]].\n *\n * See [[StateDeclaration.resolve]]\n */\nconst resolveRemaining: TransitionHookFn = (trans: Transition) =>\n  new ResolveContext(trans.treeChanges().to)\n    .resolvePath('LAZY', trans)\n    .then(noop);\n\nexport const registerResolveRemaining = (transitionService: TransitionService) =>\n  transitionService.onFinish({}, resolveRemaining, { priority: RESOLVE_HOOK_PRIORITY });\n",
@@ -137,7 +137,7 @@
     "/** @module transition */ /** */\nimport { TransitionHookPhase, PathType } from './interface';\nimport { GetErrorHandler, GetResultHandler, TransitionHook } from './transitionHook';\n/**\n * This class defines a type of hook, such as `onBefore` or `onEnter`.\n * Plugins can define custom hook types, such as sticky states does for `onInactive`.\n *\n * @interalapi\n */\nexport class TransitionEventType {\n  /* tslint:disable:no-inferrable-types */\n  constructor(public name:               string,\n              public hookPhase:          TransitionHookPhase,\n              public hookOrder:          number,\n              public criteriaMatchPath:  PathType,\n              public reverseSort:        boolean = false,\n              public getResultHandler:   GetResultHandler = TransitionHook.HANDLE_RESULT,\n              public getErrorHandler:    GetErrorHandler = TransitionHook.REJECT_ERROR,\n              public synchronous:        boolean = false,\n  ) { }\n}\n",
     "/** @module hooks */ /** */\n\nimport { trace } from '../common/trace';\nimport { Rejection } from '../transition/rejectFactory';\nimport { TransitionService } from '../transition/transitionService';\nimport { Transition } from '../transition/transition';\n\n/**\n * A [[TransitionHookFn]] that skips a transition if it should be ignored\n *\n * This hook is invoked at the end of the onBefore phase.\n *\n * If the transition should be ignored (because no parameter or states changed)\n * then the transition is ignored and not processed.\n */\nfunction ignoredHook(trans: Transition) {\n  const ignoredReason = trans._ignoredReason();\n  if (!ignoredReason) return;\n\n  trace.traceTransitionIgnored(trans);\n\n  const pending = trans.router.globals.transition;\n\n  // The user clicked a link going back to the *current state* ('A')\n  // However, there is also a pending transition in flight (to 'B')\n  // Abort the transition to 'B' because the user now wants to be back at 'A'.\n  if (ignoredReason === 'SameAsCurrent' && pending) {\n    pending.abort();\n  }\n\n  return Rejection.ignored().toPromise();\n}\n\nexport const registerIgnoredTransitionHook = (transitionService: TransitionService) =>\n    transitionService.onBefore({}, ignoredHook, { priority: -9999 });\n",
     "/** @module hooks */ /** */\n\nimport { TransitionService } from '../transition/transitionService';\nimport { Transition } from '../transition/transition';\n\n/**\n * A [[TransitionHookFn]] that rejects the Transition if it is invalid\n *\n * This hook is invoked at the end of the onBefore phase.\n * If the transition is invalid (for example, param values do not validate)\n * then the transition is rejected.\n */\nfunction invalidTransitionHook(trans: Transition) {\n  if (!trans.valid()) {\n    throw new Error(trans.error());\n  }\n}\n\nexport const registerInvalidTransitionHook = (transitionService: TransitionService) =>\n    transitionService.onBefore({}, invalidTransitionHook, { priority: -10000 });\n",
-    "/**\n * @coreapi\n * @module transition\n */\n/** for typedoc */\nimport {\n  IHookRegistry, TransitionOptions, TransitionHookScope, TransitionHookPhase, TransitionCreateHookFn, HookMatchCriteria,\n  HookRegOptions, PathTypes, PathType, RegisteredHooks, TransitionHookFn, TransitionStateHookFn,\n} from './interface';\nimport { Transition } from './transition';\nimport { makeEvent, RegisteredHook } from './hookRegistry';\nimport { TargetState } from '../state/targetState';\nimport { PathNode } from '../path/pathNode';\nimport { ViewService } from '../view/view';\nimport { UIRouter } from '../router';\nimport { registerAddCoreResolvables } from '../hooks/coreResolvables';\nimport { registerRedirectToHook } from '../hooks/redirectTo';\nimport { registerOnExitHook, registerOnRetainHook, registerOnEnterHook } from '../hooks/onEnterExitRetain';\nimport { registerEagerResolvePath, registerLazyResolveState, registerResolveRemaining } from '../hooks/resolve';\nimport { registerLoadEnteringViews, registerActivateViews } from '../hooks/views';\nimport { registerUpdateGlobalState } from '../hooks/updateGlobals';\nimport { registerUpdateUrl } from '../hooks/url';\nimport { registerLazyLoadHook } from '../hooks/lazyLoad';\nimport { TransitionEventType } from './transitionEventType';\nimport { TransitionHook, GetResultHandler, GetErrorHandler } from './transitionHook';\nimport { isDefined } from '../common/predicates';\nimport { removeFrom, values, createProxyFunctions } from '../common/common';\nimport { Disposable } from '../interface'; // has or is using\nimport { val } from '../common/hof';\nimport { registerIgnoredTransitionHook } from '../hooks/ignoredTransition';\nimport { registerInvalidTransitionHook } from '../hooks/invalidTransition';\n\n/**\n * The default [[Transition]] options.\n *\n * Include this object when applying custom defaults:\n * let reloadOpts = { reload: true, notify: true }\n * let options = defaults(theirOpts, customDefaults, defaultOptions);\n */\nexport let defaultTransOpts: TransitionOptions = {\n  location    : true,\n  relative    : null,\n  inherit     : false,\n  notify      : true,\n  reload      : false,\n  custom      : {},\n  current     : () => null,\n  source      : 'unknown',\n};\n\n\n/**\n * Plugin API for Transition Service\n * @internalapi\n */\nexport interface TransitionServicePluginAPI {\n  /**\n   * Adds a Path to be used as a criterion against a TreeChanges path\n   *\n   * For example: the `exiting` path in [[HookMatchCriteria]] is a STATE scoped path.\n   * It was defined by calling `defineTreeChangesCriterion('exiting', TransitionHookScope.STATE)`\n   * Each state in the exiting path is checked against the criteria and returned as part of the match.\n   *\n   * Another example: the `to` path in [[HookMatchCriteria]] is a TRANSITION scoped path.\n   * It was defined by calling `defineTreeChangesCriterion('to', TransitionHookScope.TRANSITION)`\n   * Only the tail of the `to` path is checked against the criteria and returned as part of the match.\n   */\n  _definePathType(name: string, hookScope: TransitionHookScope);\n\n  /**\n   * Gets a Path definition used as a criterion against a TreeChanges path\n   */\n  _getPathTypes(): PathTypes;\n\n  /**\n   * Defines a transition hook type and returns a transition hook registration\n   * function (which can then be used to register hooks of this type).\n   */\n  _defineEvent(name: string,\n               hookPhase: TransitionHookPhase,\n               hookOrder: number,\n               criteriaMatchPath: PathType,\n               reverseSort?: boolean,\n               getResultHandler?: GetResultHandler,\n               getErrorHandler?: GetErrorHandler,\n               rejectIfSuperseded?: boolean);\n\n  /**\n   * Returns the known event types, such as `onBefore`\n   * If a phase argument is provided, returns only events for the given phase.\n   */\n  _getEvents(phase?: TransitionHookPhase): TransitionEventType[];\n\n  /** Returns the hooks registered for the given hook name */\n  getHooks(hookName: string): RegisteredHook[];\n}\n\n/**\n * This class provides services related to Transitions.\n *\n * - Most importantly, it allows global Transition Hooks to be registered.\n * - It allows the default transition error handler to be set.\n * - It also has a factory function for creating new [[Transition]] objects, (used internally by the [[StateService]]).\n *\n * At bootstrap, [[UIRouter]] creates a single instance (singleton) of this class.\n */\nexport class TransitionService implements IHookRegistry, Disposable {\n  /** @hidden */\n  _transitionCount = 0;\n\n  /** @hidden */\n  public $view: ViewService;\n\n  /** @hidden The transition hook types, such as `onEnter`, `onStart`, etc */\n  private _eventTypes: TransitionEventType[] = [];\n  /** @hidden The registered transition hooks */\n  _registeredHooks = { } as RegisteredHooks;\n  /** @hidden The  paths on a criteria object */\n  private _criteriaPaths = { } as PathTypes;\Line truncated
+    "/**\n * @coreapi\n * @module transition\n */\n/** for typedoc */\nimport {\n  IHookRegistry, TransitionOptions, TransitionHookScope, TransitionHookPhase, TransitionCreateHookFn, HookMatchCriteria,\n  HookRegOptions, PathTypes, PathType, RegisteredHooks, TransitionHookFn, TransitionStateHookFn,\n} from './interface';\nimport { Transition } from './transition';\nimport { makeEvent, RegisteredHook } from './hookRegistry';\nimport { TargetState } from '../state/targetState';\nimport { PathNode } from '../path/pathNode';\nimport { ViewService } from '../view/view';\nimport { UIRouter } from '../router';\nimport { registerAddCoreResolvables, treeChangesCleanup } from '../hooks/coreResolvables';\nimport { registerRedirectToHook } from '../hooks/redirectTo';\nimport { registerOnExitHook, registerOnRetainHook, registerOnEnterHook } from '../hooks/onEnterExitRetain';\nimport { registerEagerResolvePath, registerLazyResolveState, registerResolveRemaining } from '../hooks/resolve';\nimport { registerLoadEnteringViews, registerActivateViews } from '../hooks/views';\nimport { registerUpdateGlobalState } from '../hooks/updateGlobals';\nimport { registerUpdateUrl } from '../hooks/url';\nimport { registerLazyLoadHook } from '../hooks/lazyLoad';\nimport { TransitionEventType } from './transitionEventType';\nimport { TransitionHook, GetResultHandler, GetErrorHandler } from './transitionHook';\nimport { isDefined } from '../common/predicates';\nimport { removeFrom, values, createProxyFunctions } from '../common/common';\nimport { Disposable } from '../interface'; // has or is using\nimport { val } from '../common/hof';\nimport { registerIgnoredTransitionHook } from '../hooks/ignoredTransition';\nimport { registerInvalidTransitionHook } from '../hooks/invalidTransition';\n\n/**\n * The default [[Transition]] options.\n *\n * Include this object when applying custom defaults:\n * let reloadOpts = { reload: true, notify: true }\n * let options = defaults(theirOpts, customDefaults, defaultOptions);\n */\nexport let defaultTransOpts: TransitionOptions = {\n  location    : true,\n  relative    : null,\n  inherit     : false,\n  notify      : true,\n  reload      : false,\n  custom      : {},\n  current     : () => null,\n  source      : 'unknown',\n};\n\n\n/**\n * Plugin API for Transition Service\n * @internalapi\n */\nexport interface TransitionServicePluginAPI {\n  /**\n   * Adds a Path to be used as a criterion against a TreeChanges path\n   *\n   * For example: the `exiting` path in [[HookMatchCriteria]] is a STATE scoped path.\n   * It was defined by calling `defineTreeChangesCriterion('exiting', TransitionHookScope.STATE)`\n   * Each state in the exiting path is checked against the criteria and returned as part of the match.\n   *\n   * Another example: the `to` path in [[HookMatchCriteria]] is a TRANSITION scoped path.\n   * It was defined by calling `defineTreeChangesCriterion('to', TransitionHookScope.TRANSITION)`\n   * Only the tail of the `to` path is checked against the criteria and returned as part of the match.\n   */\n  _definePathType(name: string, hookScope: TransitionHookScope);\n\n  /**\n   * Gets a Path definition used as a criterion against a TreeChanges path\n   */\n  _getPathTypes(): PathTypes;\n\n  /**\n   * Defines a transition hook type and returns a transition hook registration\n   * function (which can then be used to register hooks of this type).\n   */\n  _defineEvent(name: string,\n               hookPhase: TransitionHookPhase,\n               hookOrder: number,\n               criteriaMatchPath: PathType,\n               reverseSort?: boolean,\n               getResultHandler?: GetResultHandler,\n               getErrorHandler?: GetErrorHandler,\n               rejectIfSuperseded?: boolean);\n\n  /**\n   * Returns the known event types, such as `onBefore`\n   * If a phase argument is provided, returns only events for the given phase.\n   */\n  _getEvents(phase?: TransitionHookPhase): TransitionEventType[];\n\n  /** Returns the hooks registered for the given hook name */\n  getHooks(hookName: string): RegisteredHook[];\n}\n\n/**\n * This class provides services related to Transitions.\n *\n * - Most importantly, it allows global Transition Hooks to be registered.\n * - It allows the default transition error handler to be set.\n * - It also has a factory function for creating new [[Transition]] objects, (used internally by the [[StateService]]).\n *\n * At bootstrap, [[UIRouter]] creates a single instance (singleton) of this class.\n */\nexport class TransitionService implements IHookRegistry, Disposable {\n  /** @hidden */\n  _transitionCount = 0;\n\n  /** @hidden */\n  public $view: ViewService;\n\n  /** @hidden The transition hook types, such as `onEnter`, `onStart`, etc */\n  private _eventTypes: TransitionEventType[] = [];\n  /** @hidden The registered transition hooks */\n  _registeredHooks = { } as RegisteredHooks;\n  /** @hidden The  paths on a criteria object */\n  private _criteriaPaths Line truncated
     "/**\n * @coreapi\n * @module state\n */\n/** */\nimport { createProxyFunctions, defaults, extend, inArray, noop, removeFrom, silenceUncaughtInPromise, silentRejection } from '../common/common';\nimport { isDefined, isObject, isString } from '../common/predicates';\nimport { Queue } from '../common/queue';\nimport { services } from '../common/coreservices';\n\nimport { PathUtils } from '../path/pathUtils';\nimport { PathNode } from '../path/pathNode';\n\nimport { HookResult, TransitionOptions } from '../transition/interface';\nimport { defaultTransOpts } from '../transition/transitionService';\nimport { Rejection, RejectType } from '../transition/rejectFactory';\nimport { Transition } from '../transition/transition';\n\nimport { HrefOptions, LazyLoadResult, StateDeclaration, StateOrName, TransitionPromise } from './interface';\nimport { StateObject } from './stateObject';\nimport { TargetState } from './targetState';\n\nimport { RawParams } from '../params/interface';\nimport { Param } from '../params/param';\nimport { Glob } from '../common/glob';\nimport { UIRouter } from '../router';\nimport { UIInjector } from '../interface';\nimport { ResolveContext } from '../resolve/resolveContext';\nimport { lazyLoadState } from '../hooks/lazyLoad';\nimport { not, val } from '../common/hof';\nimport { StateParams } from '../params/stateParams';\n\nexport type OnInvalidCallback =\n    (toState?: TargetState, fromState?: TargetState, injector?: UIInjector) => HookResult;\n\n/**\n * Provides state related service functions\n *\n * This class provides services related to ui-router states.\n * An instance of this class is located on the global [[UIRouter]] object.\n */\nexport class StateService {\n  /** @internalapi */\n  invalidCallbacks: OnInvalidCallback[] = [];\n\n  /**\n   * The [[Transition]] currently in progress (or null)\n   *\n   * This is a passthrough through to [[UIRouterGlobals.transition]]\n   */\n  get transition() { return this.router.globals.transition; }\n  /**\n   * The latest successful state parameters\n   *\n   * This is a passthrough through to [[UIRouterGlobals.params]]\n   */\n  get params(): StateParams { return this.router.globals.params; }\n  /**\n   * The current [[StateDeclaration]]\n   *\n   * This is a passthrough through to [[UIRouterGlobals.current]]\n   */\n  get current() { return this.router.globals.current; }\n  /**\n   * The current [[StateObject]]\n   *\n   * This is a passthrough through to [[UIRouterGlobals.$current]]\n   */\n  get $current() { return this.router.globals.$current; }\n\n  /** @internalapi */\n  constructor(private router: UIRouter) {\n    const getters = ['current', '$current', 'params', 'transition'];\n    const boundFns = Object.keys(StateService.prototype).filter(not(inArray(getters)));\n    createProxyFunctions(val(StateService.prototype), this, val(this), boundFns);\n  }\n\n  /** @internalapi */\n  dispose() {\n    this.defaultErrorHandler(noop);\n    this.invalidCallbacks = [];\n  }\n\n  /**\n   * Handler for when [[transitionTo]] is called with an invalid state.\n   *\n   * Invokes the [[onInvalid]] callbacks, in natural order.\n   * Each callback's return value is checked in sequence until one of them returns an instance of TargetState.\n   * The results of the callbacks are wrapped in $q.when(), so the callbacks may return promises.\n   *\n   * If a callback returns an TargetState, then it is used as arguments to $state.transitionTo() and the result returned.\n   *\n   * @internalapi\n   */\n  private _handleInvalidTargetState(fromPath: PathNode[], toState: TargetState) {\n    const fromState = PathUtils.makeTargetState(this.router.stateRegistry, fromPath);\n    const globals = this.router.globals;\n    const latestThing = () => globals.transitionHistory.peekTail();\n    const latest = latestThing();\n    const callbackQueue = new Queue<OnInvalidCallback>(this.invalidCallbacks.slice());\n    const injector = new ResolveContext(fromPath).injector();\n\n    const checkForRedirect = (result: HookResult) => {\n      if (!(result instanceof TargetState)) {\n        return;\n      }\n\n      let target = <TargetState> result;\n      // Recreate the TargetState, in case the state is now defined.\n      target = this.target(target.identifier(), target.params(), target.options());\n\n      if (!target.valid()) {\n        return Rejection.invalid(target.error()).toPromise();\n      }\n\n      if (latestThing() !== latest) {\n        return Rejection.superseded().toPromise();\n      }\n\n      return this.transitionTo(target.identifier(), target.params(), target.options());\n    };\n\n    function invokeNextCallback() {\n      const nextCallback = callbackQueue.dequeue();\n      if (nextCallback === undefined) return Rejection.invalid(toState.error()).toPromise();\n\n      const callbackResult = services.$q.when(nextCallback(toState, fromState, injector));\n      return callbackResult.then(checkForRedirect).then(result => result || invokeNextCallback());\n   Line truncated
     "/**\n * # Transition subsystem\n *\n * This module contains APIs related to a Transition.\n *\n * See:\n * - [[TransitionService]]\n * - [[Transition]]\n * - [[HookFn]], [[TransitionHookFn]], [[TransitionStateHookFn]], [[HookMatchCriteria]], [[HookResult]]\n *\n * @coreapi\n * @preferred\n * @module transition\n */ /** for typedoc */\nexport * from './interface';\nexport * from './hookBuilder';\nexport * from './hookRegistry';\nexport * from './rejectFactory';\nexport * from './transition';\nexport * from './transitionHook';\nexport * from './transitionEventType';\nexport * from './transitionService';\n\n",
     "/**\n * @internalapi\n * @module vanilla\n */\n/** */\nimport { isArray, isObject, $QLike } from '../common/index';\n\n/**\n * An angular1-like promise api\n *\n * This object implements four methods similar to the\n * [angular 1 promise api](https://docs.angularjs.org/api/ng/service/$q)\n *\n * UI-Router evolved from an angular 1 library to a framework agnostic library.\n * However, some of the `@uirouter/core` code uses these ng1 style APIs to support ng1 style dependency injection.\n *\n * This API provides native ES6 promise support wrapped as a $q-like API.\n * Internally, UI-Router uses this $q object to perform promise operations.\n * The `angular-ui-router` (ui-router for angular 1) uses the $q API provided by angular.\n *\n * $q-like promise api\n */\nexport const $q = {\n  /** Normalizes a value as a promise */\n  when: (val) => new Promise((resolve, reject) => resolve(val)),\n\n  /** Normalizes a value as a promise rejection */\n  reject: (val) => new Promise((resolve, reject) => { reject(val); }),\n\n  /** @returns a deferred object, which has `resolve` and `reject` functions */\n  defer: () => {\n    const deferred: any = {};\n    deferred.promise = new Promise((resolve, reject) => {\n      deferred.resolve = resolve;\n      deferred.reject = reject;\n    });\n    return deferred;\n  },\n\n  /** Like Promise.all(), but also supports object key/promise notation like $q */\n  all: (promises: { [key: string]: Promise<any> } | Promise<any>[]) => {\n    if (isArray(promises)) {\n      return Promise.all(promises);\n    }\n\n    if (isObject(promises)) {\n      // Convert promises map to promises array.\n      // When each promise resolves, map it to a tuple { key: key, val: val }\n      const chain = Object.keys(promises)\n          .map(key => promises[key].then(val => ({ key, val })));\n\n      // Then wait for all promises to resolve, and convert them back to an object\n      return $q.all(chain).then(values =>\n        values.reduce((acc, tuple) => { acc[tuple.key] = tuple.val; return acc; }, {}));\n    }\n  },\n} as $QLike;\n",
@@ -161,7 +161,7 @@
     "/** @module url */ /** */\nimport {\n    UIRouter, UrlRouter, LocationServices, $InjectorLike, BaseUrlRule, UrlRuleHandlerFn, UrlMatcher,\n    IInjectable,\n} from '@uirouter/core';\nimport { services, isString, isFunction, isArray, identity } from '@uirouter/core';\n\nexport interface RawNg1RuleFunction {\n  ($injector: $InjectorLike, $location: LocationServices): string|void;\n}\n\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 * @deprecated\n */\nexport class UrlRouterProvider {\n  /** @hidden */ _router: UIRouter;\n  /** @hidden */ _urlRouter: UrlRouter;\n\n  static injectableHandler(router: UIRouter, handler): UrlRuleHandlerFn {\n    return match =>\n        services.$injector.invoke(handler, null, { $match: match, $stateParams: router.globals.params });\n  }\n\n  /** @hidden */\n  constructor(router: UIRouter) {\n    this._router = router;\n    this._urlRouter = router.urlRouter;\n  }\n\n  /** @hidden */\n  $get() {\n    const urlRouter = this._urlRouter;\n    urlRouter.update(true);\n    if (!urlRouter.interceptDeferred) urlRouter.listen();\n    return urlRouter;\n  }\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  rule(ruleFn: RawNg1RuleFunction): UrlRouterProvider {\n    if (!isFunction(ruleFn)) throw new Error(\"'rule' must be a function\");\n\n    const match = () =>\n        ruleFn(services.$injector, this._router.locationService);\n\n    const rule = new BaseUrlRule(match, identity);\n    this._urlRouter.rule(rule);\n    return this;\n  }\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  otherwise(rule: string | RawNg1RuleFunction): UrlRouterProvider {\n    const urlRouter = this._urlRouter;\n\n    if (isString(rule)) {\n      urlRouter.otherwise(rule);\n    } else if (isFunction(rule)) {\n      urlRouter.otherwise(() => rule(services.$injector, this._router.locationService));\n    } else {\n      throw new Error(\"'rule' must be a string or function\");\n    }\n\n    return this;\n  }\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 **truthyLine truncated
     "/**\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 * @module ng1\n * @preferred\n */\n/** for typedoc */\nimport { ng as angular } from './angular';\nimport {\n  IRootScopeService, IQService, ILocationService, ILocationProvider, IHttpService, ITemplateCacheService,\n} from 'angular';\nimport {\n  services, applyPairs, isString, trace, extend, UIRouter, StateService, UrlRouter, UrlMatcherFactory, ResolveContext,\n  unnestR, TypedMap,\n} from '@uirouter/core';\nimport { ng1ViewsBuilder, getNg1ViewConfigFactory } from './statebuilders/views';\nimport { TemplateFactory } from './templateFactory';\nimport { StateProvider } from './stateProvider';\nimport { getStateHookBuilder } from './statebuilders/onEnterExitRetain';\nimport { Ng1LocationServices } from './locationServices';\nimport { UrlRouterProvider } from './urlRouterProvider';\nimport IInjectorService = angular.auto.IInjectorService; // tslint:disable-line\n\nangular.module('ui.router.angular1', []);\nconst mod_init  = angular.module('ui.router.init',   []);\nconst mod_util  = angular.module('ui.router.util',   ['ng', 'ui.router.init']);\nconst mod_rtr   = angular.module('ui.router.router', ['ui.router.util']);\nconst mod_state = angular.module('ui.router.state',  ['ui.router.router', 'ui.router.util', 'ui.router.angular1']);\nconst mod_main  = angular.module('ui.router',        ['ui.router.init', 'ui.router.state', 'ui.router.angular1']);\nlet mod_cmpt  = angular.module('ui.router.compat', ['ui.router']); // tslint:disable-line\n\ndeclare module '@uirouter/core/lib/router' {\n  interface UIRouter { // tslint:disable-line:no-shadowed-variable\n    /** @hidden */\n    stateProvider: StateProvider;\n    /** @hidden */\n    urlRouterProvider: UrlRouterProvider;\n  }\n}\n\nlet router: UIRouter = null;\n\n$uiRouterProvider.$inject = ['$locationProvider'];\n/** This angular 1 provider instantiates a Router and exposes its services via the angular injector */\nfunction $uiRouterProvider($locationProvider: ILocationProvider) {\n\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\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\n  router.viewService._pluginapi._viewConfigFactory('ng1', getNg1ViewConfigFactory());\n\n  const ng1LocationService = router.locationService = router.locationConfig = new Ng1LocationServices($locationProvider);\n\n  Ng1LocationServices.monkeyPatchPathParameterType(router);\n\n  // backwards compat: also expose router instance as $uiRouterProvider.router\n  router['router'] = router;\n  router['$get'] = $get;\n  $get.$inject = ['$location', '$browser', '$sniffer', '$rootScope', '$http', '$templateCache'];\n  function $get($location: ILocationService, $browser: any, $sniffer: any, $rootScope: ng.IScope, $http: IHttpService, $templateCache: ITemplateCacheService) {\n    ng1LocationService._runtimeServices($rootScope, $location, $sniffer, $browser);\n    delete router['router'];\n    delete router['$get'];\n    return router;\n  }\n  return router;\n}\n\nconst getProviderFor = (serviceName) => [ '$uiRouterProvider', ($urp) => {\n  const service = $urp.router[serviceName];\n  service['$get'] = () => 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: IInjectorService, $q: IQService, $uiRouter: UIRouter) {\n  services.$injector = $injector;\n  services.$q = <any> $q;\n\n  // The $injector is now available.\n  // Find any resolvables that had dependency annotation deferred\n  $uiRouter.stateRegistry.get()\n      .map(x => x.$$state().resolvables)\n      .reduce(unnestR, [])\n      .filter(x => x.deps === 'deferred')\n      .forEach(resolvable => resolvable.deps = $injector.annotate(resolvable.resolveFn, $injector.strictDi));\n}\n\n// $urlRouter service and $urlRouterProvider\nconst getUrlRouterProvider = (uiRouter: UIRouter) =>\n  uiRouter.urlRouterProvider = new UrlRouterProvider(uiRouter);\n\n// $state service and $stateProvider\n// $urlRouter service and $urlRouterProvider\nconst getStateProvider = () =>\n    extend(router.stateProvider, { $get: () => router.stateService });\n\nwatchDigests.$inject = ['Line truncated
     "/**\n * # Angular 1 injectable services\n *\n * This is a list of the objects which can be injected using angular's injector.\n *\n * There are three different kind of injectable objects:\n *\n * ## **Provider** objects\n * #### injectable into a `.config()` block during configtime\n *\n * - [[$uiRouterProvider]]: The UI-Router instance\n * - [[$stateProvider]]: State registration\n * - [[$transitionsProvider]]: Transition hooks\n * - [[$urlServiceProvider]]: All URL related public APIs\n *\n * - [[$uiViewScrollProvider]]: Disable ui-router view scrolling\n * - [[$urlRouterProvider]]: (deprecated) Url matching rules\n * - [[$urlMatcherFactoryProvider]]: (deprecated) Url parsing config\n *\n * ## **Service** objects\n * #### injectable globally during runtime\n *\n * - [[$uiRouter]]: The UI-Router instance\n * - [[$trace]]: Enable transition trace/debug\n * - [[$transitions]]: Transition hooks\n * - [[$state]]: Imperative state related APIs\n * - [[$stateRegistry]]: State registration\n * - [[$urlService]]: All URL related public APIs\n * - [[$uiRouterGlobals]]: Global variables\n * - [[$uiViewScroll]]: Scroll an element into view\n *\n * - [[$stateParams]]: (deprecated) Global state param values\n * - [[$urlRouter]]: (deprecated) URL synchronization\n * - [[$urlMatcherFactory]]: (deprecated) URL parsing config\n *\n * ## **Per-Transition** objects\n *\n * - These kind of objects are injectable into:\n *   - Resolves ([[Ng1StateDeclaration.resolve]]),\n *   - Transition Hooks ([[TransitionService.onStart]], etc),\n *   - Routed Controllers ([[Ng1ViewDeclaration.controller]])\n *\n * #### Different instances are injected based on the [[Transition]]\n *\n * - [[$transition$]]: The current Transition object\n * - [[$stateParams]]: State param values for pending Transition (deprecated)\n * - Any resolve data defined using [[Ng1StateDeclaration.resolve]]\n *\n * @ng1api\n * @preferred\n * @module injectables\n */ /** */\n/* tslint:disable:prefer-const */\nimport { StateProvider } from './stateProvider';\nimport {\n    StateService, TransitionService, Transition, UrlRouter, UrlMatcherFactory,\n    StateParams, StateRegistry, UIRouterGlobals, UIRouter, Trace, UrlService,\n} from '@uirouter/core';\nimport { UIViewScrollProvider } from './viewScroll';\nimport { UrlRouterProvider } from './urlRouterProvider';\n\n/**\n * The current (or pending) State Parameters\n *\n * An injectable global **Service Object** which holds the state parameters for the latest **SUCCESSFUL** transition.\n *\n * The values are not updated until *after* a `Transition` successfully completes.\n *\n * **Also:** an injectable **Per-Transition Object** object which holds the pending state parameters for the pending `Transition` currently running.\n *\n * ### Deprecation warning:\n *\n * The value injected for `$stateParams` is different depending on where it is injected.\n *\n * - When injected into an angular service, the object injected is the global **Service Object** with the parameter values for the latest successful `Transition`.\n * - When injected into transition hooks, resolves, or view controllers, the object is the **Per-Transition Object** with the parameter values for the running `Transition`.\n *\n * Because of these confusing details, this service is deprecated.\n *\n * ### Instead of using the global `$stateParams` service object,\n * inject [[$uiRouterGlobals]] and use [[UIRouterGlobals.params]]\n *\n * ```js\n * MyService.$inject = ['$uiRouterGlobals'];\n * function MyService($uiRouterGlobals) {\n *   return {\n *     paramValues: function () {\n *       return $uiRouterGlobals.params;\n *     }\n *   }\n * }\n * ```\n *\n * ### Instead of using the per-transition `$stateParams` object,\n * inject the current `Transition` (as [[$transition$]]) and use [[Transition.params]]\n *\n * ```js\n * MyController.$inject = ['$transition$'];\n * function MyController($transition$) {\n *   var username = $transition$.params().username;\n *   // .. do something with username\n * }\n * ```\n *\n * ---\n *\n * This object can be injected into other services.\n *\n * #### Deprecated Example:\n * ```js\n * SomeService.$inject = ['$http', '$stateParams'];\n * function SomeService($http, $stateParams) {\n *   return {\n *     getUser: function() {\n *       return $http.get('/api/users/' + $stateParams.username);\n *     }\n *   }\n * };\n * angular.service('SomeService', SomeService);\n * ```\n * @deprecated\n */\nlet $stateParams: StateParams;\n\n/**\n * Global UI-Router variables\n *\n * The router global state as a **Service Object** (injectable during runtime).\n *\n * This object contains globals such as the current state and current parameter values.\n */\nlet $uiRouterGlobals: UIRouterGlobals;\n\n/**\n * The UI-Router instance\n *\n * The [[UIRouter]] singleton (the router instance) as a **Service Object** (injectable during runtime).\n *\n * This object is the UI-Router singleton instance, created by angular dependency injection duLine truncated
-    "/**\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 * @ng1api\n * @preferred\n * @module directives\n */ /** for typedoc */\nimport { ng as angular } from '../angular';\nimport { IAugmentedJQuery, ITimeoutService, IScope, IInterpolateService } from 'angular';\n\nimport {\n    Obj, extend, forEach, tail, isString, isObject, isArray, parse, noop, unnestR, identity, uniqR, inArray, removeFrom,\n    RawParams, PathNode, StateOrName, StateService, StateDeclaration, UIRouter,\n} from '@uirouter/core';\nimport { UIViewData } from './viewDirective';\nimport EventHandler = JQuery.EventHandler;\n\n/** @hidden Used for typedoc */\nexport interface ng1_directive {} // tslint:disable-line:class-name\n\n/** @hidden */\nfunction parseStateRef(ref: string) {\n  let parsed;\n  const paramsOnly = ref.match(/^\\s*({[^}]*})\\s*$/);\n  if (paramsOnly) ref = '(' + paramsOnly[1] + ')';\n\n  parsed = ref.replace(/\\n/g, ' ').match(/^\\s*([^(]*?)\\s*(\\((.*)\\))?\\s*$/);\n  if (!parsed || parsed.length !== 4) throw new Error(\"Invalid state ref '\" + ref + \"'\");\n  return { state: parsed[1] || null, paramExpr: parsed[3] || null };\n}\n\n/** @hidden */\nfunction stateContext(el: IAugmentedJQuery) {\n  const $uiView: UIViewData = (el.parent() as IAugmentedJQuery).inheritedData('$uiView');\n  const path: PathNode[] = parse('$cfg.path')($uiView);\n  return path ? tail(path).state.name : undefined;\n}\n\n/** @hidden */\nfunction processedDef($state: StateService, $element: IAugmentedJQuery, def: Def): Def {\n  const uiState = def.uiState || $state.current.name;\n  const uiStateOpts = extend(defaultOpts($element, $state), def.uiStateOpts || {});\n  const href = $state.href(uiState, def.uiStateParams, uiStateOpts);\n  return { uiState, uiStateParams: def.uiStateParams, uiStateOpts, href };\n}\n\n/** @hidden */\ninterface TypeInfo {\n  attr: string;\n  isAnchor: boolean;\n  clickable: boolean;\n}\n\n/** @hidden */\nfunction getTypeInfo(el: IAugmentedJQuery): TypeInfo {\n  // SVGAElement does not use the href attribute, but rather the 'xlinkHref' attribute.\n  const isSvg = Object.prototype.toString.call(el.prop('href')) === '[object SVGAnimatedString]';\n  const isForm = el[0].nodeName === 'FORM';\n\n  return {\n    attr: isForm ? 'action' : (isSvg ? 'xlink:href' : 'href'),\n    isAnchor: el.prop('tagName').toUpperCase() === 'A',\n    clickable: !isForm,\n  };\n}\n\n/** @hidden */\nfunction clickHook(el: IAugmentedJQuery, $state: StateService, $timeout: ITimeoutService, type: TypeInfo, getDef: () => Def) {\n  return function (e: JQueryMouseEventObject) {\n    const button = e.which || e.button, target = getDef();\n\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      const transition = $timeout(function () {\n        $state.go(target.uiState, target.uiStateParams, target.uiStateOpts);\n      });\n      e.preventDefault();\n\n      // if the state has no URL, ignore one preventDefault from the <a> directive.\n      let ignorePreventDefaultCount = type.isAnchor && !target.href ? 1 : 0;\n\n      e.preventDefault = function () {\n        if (ignorePreventDefaultCount-- <= 0) $timeout.cancel(transition);\n      };\n    }\n  };\n}\n\n/** @hidden */\nfunction defaultOpts(el: IAugmentedJQuery, $state: StateService) {\n  return {\n    relative: stateContext(el) || $state.$current,\n    inherit: true,\n    source: 'sref',\n  };\n}\n\n/** @hidden */\nfunction bindEvents(element: IAugmentedJQuery, scope: IScope, hookFn: EventHandler<any>, uiStateOpts: any): void {\n  let events;\n\n  if (uiStateOpts) {\n    events = uiStateOpts.events;\n  }\n\n  if (!isArray(events)) {\n    events = ['click'];\n  }\n\n  const on = element.on ? 'on' : 'bind';\n  for (const event of events) {\n    element[on](event, hookFn);\n  }\n\n  scope.$on('$destroy', function() {\n    const off = element.off ? 'off' : 'unbind';\n    for (const event of events) {\n      element[off](event, hookFn);\n    }\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 targLine truncated
+    "/**\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 * @ng1api\n * @preferred\n * @module directives\n */ /** for typedoc */\nimport { ng as angular } from '../angular';\nimport { IAugmentedJQuery, ITimeoutService, IScope, IInterpolateService } from 'angular';\n\nimport {\n    Obj, extend, forEach, tail, isString, isObject, isArray, parse, noop, unnestR, identity, uniqR, inArray, removeFrom,\n    RawParams, PathNode, StateOrName, StateService, StateDeclaration, UIRouter,\n} from '@uirouter/core';\nimport { UIViewData } from './viewDirective';\nimport EventHandler = JQuery.EventHandler;\n\n/** @hidden Used for typedoc */\nexport interface ng1_directive {} // tslint:disable-line:class-name\n\n/** @hidden */\nfunction parseStateRef(ref: string) {\n  let parsed;\n  const paramsOnly = ref.match(/^\\s*({[^}]*})\\s*$/);\n  if (paramsOnly) ref = '(' + paramsOnly[1] + ')';\n\n  parsed = ref.replace(/\\n/g, ' ').match(/^\\s*([^(]*?)\\s*(\\((.*)\\))?\\s*$/);\n  if (!parsed || parsed.length !== 4) throw new Error(\"Invalid state ref '\" + ref + \"'\");\n  return { state: parsed[1] || null, paramExpr: parsed[3] || null };\n}\n\n/** @hidden */\nfunction stateContext(el: IAugmentedJQuery) {\n  const $uiView: UIViewData = (el.parent() as IAugmentedJQuery).inheritedData('$uiView');\n  const path: PathNode[] = parse('$cfg.path')($uiView);\n  return path ? tail(path).state.name : undefined;\n}\n\n/** @hidden */\nfunction processedDef($state: StateService, $element: IAugmentedJQuery, def: Def): Def {\n  const uiState = def.uiState || $state.current.name;\n  const uiStateOpts = extend(defaultOpts($element, $state), def.uiStateOpts || {});\n  const href = $state.href(uiState, def.uiStateParams, uiStateOpts);\n  return { uiState, uiStateParams: def.uiStateParams, uiStateOpts, href };\n}\n\n/** @hidden */\ninterface TypeInfo {\n  attr: string;\n  isAnchor: boolean;\n  clickable: boolean;\n}\n\n/** @hidden */\nfunction getTypeInfo(el: IAugmentedJQuery): TypeInfo {\n  // SVGAElement does not use the href attribute, but rather the 'xlinkHref' attribute.\n  const isSvg = Object.prototype.toString.call(el.prop('href')) === '[object SVGAnimatedString]';\n  const isForm = el[0].nodeName === 'FORM';\n\n  return {\n    attr: isForm ? 'action' : (isSvg ? 'xlink:href' : 'href'),\n    isAnchor: el.prop('tagName').toUpperCase() === 'A',\n    clickable: !isForm,\n  };\n}\n\n/** @hidden */\nfunction clickHook(el: IAugmentedJQuery, $state: StateService, $timeout: ITimeoutService, type: TypeInfo, getDef: () => Def) {\n  return function (e: JQueryMouseEventObject) {\n    const button = e.which || e.button, target = getDef();\n\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      const transition = $timeout(function () {\n        $state.go(target.uiState, target.uiStateParams, target.uiStateOpts);\n      });\n      e.preventDefault();\n\n      // if the state has no URL, ignore one preventDefault from the <a> directive.\n      let ignorePreventDefaultCount = type.isAnchor && !target.href ? 1 : 0;\n\n      e.preventDefault = function () {\n        if (ignorePreventDefaultCount-- <= 0) $timeout.cancel(transition);\n      };\n    }\n  };\n}\n\n/** @hidden */\nfunction defaultOpts(el: IAugmentedJQuery, $state: StateService) {\n  return {\n    relative: stateContext(el) || $state.$current,\n    inherit: true,\n    source: 'sref',\n  };\n}\n\n/** @hidden */\nfunction bindEvents(element: IAugmentedJQuery, scope: IScope, hookFn: EventHandler<any>, uiStateOpts: any): void {\n  let events;\n\n  if (uiStateOpts) {\n    events = uiStateOpts.events;\n  }\n\n  if (!isArray(events)) {\n    events = ['click'];\n  }\n\n  const on = element.on ? 'on' : 'bind';\n  for (const event of events) {\n    element[on](event, hookFn);\n  }\n\n  scope.$on('$destroy', function() {\n    const off = element.off ? 'off' : 'unbind';\n    for (const event of events) {\n      element[off](event, hookFn);\n    }\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 targLine truncated
     "/** @module ng1 */ /** for typedoc */\n\nimport { ng as angular } from './angular';\nimport { Obj, StateService, StateOrName } from '@uirouter/core';\n\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'];\nexport function $IsStateFilter($state: StateService) {\n  const isFilter: any = function(state: StateOrName, params: Obj, options?: { relative?: StateOrName }) {\n    return $state.is(state, params, options);\n  };\n  isFilter.$stateful = true;\n  return isFilter;\n}\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'];\nexport function $IncludedByStateFilter($state: StateService) {\n  const includesFilter: any = function(state: StateOrName, params: Obj, options: { relative?: StateOrName }) {\n    return $state.includes(state, params, options);\n  };\n  includesFilter.$stateful = true;\n  return  includesFilter;\n}\n\nangular.module('ui.router.state')\n  .filter('isState', $IsStateFilter)\n  .filter('includedByState', $IncludedByStateFilter);\n",
     "/**\n * @ng1api\n * @module directives\n */ /** for typedoc */\nimport { ng as angular } from '../angular';\nimport { IInterpolateService, IScope, ITranscludeFunction, IAugmentedJQuery, ITimeoutService } from 'angular';\n\nimport {\n    extend, unnestR, filter, tail, isDefined, isFunction, isString, trace, parse,\n    ActiveUIView, TransitionService, ResolveContext, Transition, PathNode, StateDeclaration,\n    Param, kebobString, HookRegOptions, ViewService, $QLike, Obj, TypedMap, noop,\n} from '@uirouter/core';\nimport { Ng1ViewConfig } from '../statebuilders/views';\nimport { Ng1Controller, Ng1StateDeclaration } from '../interface';\nimport { getLocals } from '../services';\nimport { ng1_directive } from './stateDirectives';\n\n/** @hidden */\nexport type UIViewData = {\n  $cfg: Ng1ViewConfig;\n  $uiView: ActiveUIView;\n};\n\n/** @hidden */\nexport type UIViewAnimData = {\n  $animEnter: Promise<any>;\n  $animLeave: Promise<any>;\n  $$animLeave: { resolve: () => any; } // \"deferred\"\n};\n\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 */\nexport let uiView: ng1_directive;\nuiView = ['$view', '$animate', '$uiViewScroll', '$interpolate', '$q',\nfunction $ViewDirective($view: ViewService, $animate: any, $uiViewScroll: any, $interpolate: IInterpolateService, $q: $QLike) {\n\n  function getRenderer(attrs: Obj, scope: IScope) {\n    return {\n      enter: function(element: Line truncated
     "/** @module ng1 */ /** */\nimport { ng as angular } from './angular';\nimport { IServiceProviderFactory } from 'angular';\nimport IAnchorScrollService = angular.IAnchorScrollService;\nimport ITimeoutService = angular.ITimeoutService;\n\nexport interface UIViewScrollProvider {\n  /**\n   * Uses standard anchorScroll behavior\n   *\n   * Reverts [[$uiViewScroll]] back to using the core [`$anchorScroll`](http://docs.angularjs.org/api/ng.$anchorScroll)\n   * service for scrolling based on the url anchor.\n   */\n  useAnchorScroll(): void;\n}\n\n\n/** @hidden */\nfunction $ViewScrollProvider() {\n\n  let useAnchorScroll = false;\n\n  this.useAnchorScroll = function () {\n    useAnchorScroll = true;\n  };\n\n  this.$get = ['$anchorScroll', '$timeout', function ($anchorScroll: IAnchorScrollService, $timeout: ITimeoutService): Function {\n    if (useAnchorScroll) {\n      return $anchorScroll;\n    }\n\n    return function ($element: JQuery) {\n      return $timeout(function () {\n        $element[0].scrollIntoView();\n      }, 0, false);\n    };\n  }];\n}\n\nangular.module('ui.router.state').provider('$uiViewScroll', <IServiceProviderFactory> $ViewScrollProvider);\n",
@@ -186,5 +186,5 @@
     "__extends",
     "id"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;AAMA,IAAM,cAAc,GAAG,OAAO,CAAC;AAE/B,AAAO,IAAM,EAAE,GAAG,CAAC,cAAc,IAAIA,qBAAqB,IAAI,cAAc,GAAG,cAAc;;ACR7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,eAAsB,EAAY;IAChC,IAAM,YAAY,GAAG,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD,IAAM,gBAAgB,GAAG,EAAE,CAAC,MAAM,CAAC;IAEnC,iBAAiB,IAAW;QAC1B,IAAI,IAAI,CAAC,MAAM,IAAI,gBAAgB;YACjC,OAAO,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC9B,OAAO;YACL,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;SACxD,CAAC;KACH;IACD,OAAO,OAAO,CAAC,YAAY,CAAC,CAAC;CAC9B;;;;;;;AAUD;IACE,IAAM,IAAI,GAAG,SAAS,CAAC;IACvB,IAAM,KAAK,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;IAC9B,OAAO;QACL,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC3D,OAAO,CAAC,EAAE;YAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAChD,OAAO,MAAM,CAAC;KACf,CAAC;CACH;;;;;;;AAQD;IAAqB,eAAoB;SAApB,UAAoB,EAApB,qBAAoB,EAApB,IAAoB;QAApB,0BAAoB;;IACvC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;CAChE;;;;;;;AAQD,AAAO,IAAM,IAAI,GAAG,UAAC,IAAY;IAC7B,OAAA,UAAC,GAAQ,IAAK,OAAA,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,GAAA;CAAA,CAAC;;;;;;;;AASnC,AAAO,IAAM,MAAM,GAAG,KAAK,CAAC,UAAC,IAAY,EAAE,IAAS,EAAE,GAAQ,IAAK,OAAA,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,GAAA,CAAC,CAAC;;;;;;;;;AAU9F,AAAO,IAAM,KAAK,GAAG,UAAC,IAAY;IAC9B,OAAA,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;CAAA,CAAC;;;;;AAMhD,AAAO,IAAM,GAAG,GAA2C,UAAC,EAAkB;IAC1E,OAAA;QAAC,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,yBAAc;;QAAK,OAAA,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;KAAA;CAAA,CAAC;;;;;AAM9C,aAAoB,GAAmB,EAAE,GAAmB;IAC1D,OAAO;QAAC,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,yBAAc;;QAAK,OAAA,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;KAAA,CAAC;CAC3E;;;;;AAMD,YAAmB,GAAmB,EAAE,GAAmB;IACzD,OAAO;QAAC,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,yBAAc;;QAAK,OAAA,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;KAAA,CAAC;CAC3E;;;;;;;AAQD,AAAO,IAAM,GAAG,GAAG,UAAC,GAAmB;IACnC,OAAA,UAAC,GAAU,IAAK,OAAA,GAAG,CAAC,MAAM,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAA,EAAE,IAAI,CAAY,GAAA;CAAA,CAAC;;AAGzE,AAAO,IAAM,GAAG,GAAG,UAAC,GAAmB;IACnC,OAAA,UAAC,GAAU,IAAK,OAAA,GAAG,CAAC,MAAM,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAA,EAAE,KAAK,CAAY,GAAA;CAAA,CAAC;;AAG1E,AAAO,IAAM,EAAE,GAAG,UAAK,IAAyB;IAC5C,OAAA,UAAC,GAAQ;QACL,QAAC,GAAG,IAAI,IAAI,IAAI,GAAG,CAAC,WAAW,KAAK,IAAI,IAAI,GAAG,YAAY,IAAI;KAAC;CAAA,CAAC;;AAGzE,AAAO,IAAM,EAAE,GAAkC,UAAC,KAAU,IAAK,OAAA,UAAC,KAAU;IACxE,OAAA,KAAK,KAAK,KAAK;CAAA,GAAA,CAAC;;AAGpB,AAAO,IAAM,GAAG,GAAG,UAAK,CAAI,IAAK,OAAA,cAAM,OAAA,CAAC,GAAA,GAAA,CAAC;AAMzC,gBAAuB,MAAc,EAAE,IAAY;IACjD,OAAO,UAAC,GAAQ;QACZ,OAAA,GAAG,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC;KAAA,CAAC;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CD,iBAAwB,MAAoB;IAC1C,OAAO,UAAS,CAAM;QACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACtC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAAE,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC7C;KACF,CAAC;CACH;;AClOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA;IAeE,cAAY,IAAY;QACtB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAE5B,IAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;aACpC,GAAG,CAAC,UAAA,GAAG;YACN,IAAI,GAAG,KAAK,IAAI;gBAAE,OAAO,oBAAoB,CAAC;YAC9C,IAAI,GAAG,KAAK,GAAG;gBAAG,OAAO,UAAU,CAAC;YACpC,OAAyB,KAAK,GAAG,GAAG,CAAC;SACtC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAEhB,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,YAAY,GAAG,GAAG,CAAC,CAAC;KACpD;;IArBM,OAAE,GAAT,UAAU,IAAY;QACpB,OAAO,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KAC9B;;IAGM,eAAU,GAAjB,UAAkB,IAAY;QAC5B,OAAO,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;KAC9C;IAgBD,sBAAO,GAAP,UAAQ,IAAY;QAClB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;KACrC;IACH,WAAC;CAAA;;ACnED;;;;;;;;;;AAUA;;IA+GE,qBAAY,MAAyB;QACnC,OAAO,WAAW,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;KACzC;;;;;;;;;IAxBM,kBAAM,GAAb,UAAc,SAA4B;QACxC,SAAS,GAAG,WAAW,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,IAAI,SAAS,EAAE,GAAG,SAAS,CAAC;QAE9E,IAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC,SAAS,CAAC,CAAgB,CAAC;QAChF,SAAS,CAAC,OAAO,GAAG,cAAM,OAAA,KAAK,GAAA,CAAC;QAChC,KAAK,CAAC,IAAI,GAAG,SAAS,CAAC;QACvB,KAAK,CAAC,kBAAkB,GAAG;YACzB,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC;SACtC,CAAC;QACF,OAAO,KAAK,CAAC;KACd;;;;;;;;;;;;IA2BD,wBAAE,GAAF,UAAG,GAAwC;QACzC,OAAO,IAAI,KAAK,GAAG,IAAI,IAAI,CAAC,IAAI,KAAK,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,KAAK,GAAG,CAAC;KAChE;;;;;IAMD,yBAAG,GAAH;QACE,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE,IAAI,CAAC,MAAM,YAAY,IAAI,CAAC,WAAW,CAAC;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC;QACjF,IAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;QAC/B,OAAO,IAAI,GAAG,IAAI,GAAG,GAAG,GAAG,IALine truncated
+  "mappings": ";;;;;;;;;;;;;;;;AAMA,IAAM,cAAc,GAAG,OAAO,CAAC;AAE/B,AAAO,IAAM,EAAE,GAAG,CAAC,cAAc,IAAIA,qBAAqB,IAAI,cAAc,GAAG,cAAc;;ACR7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,eAAsB,EAAY;IAChC,IAAM,YAAY,GAAG,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD,IAAM,gBAAgB,GAAG,EAAE,CAAC,MAAM,CAAC;IAEnC,iBAAiB,IAAW;QAC1B,IAAI,IAAI,CAAC,MAAM,IAAI,gBAAgB;YACjC,OAAO,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC9B,OAAO;YACL,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;SACxD,CAAC;KACH;IACD,OAAO,OAAO,CAAC,YAAY,CAAC,CAAC;CAC9B;;;;;;;AAUD;IACE,IAAM,IAAI,GAAG,SAAS,CAAC;IACvB,IAAM,KAAK,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;IAC9B,OAAO;QACL,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC3D,OAAO,CAAC,EAAE;YAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAChD,OAAO,MAAM,CAAC;KACf,CAAC;CACH;;;;;;;AAQD;IAAqB,eAAoB;SAApB,UAAoB,EAApB,qBAAoB,EAApB,IAAoB;QAApB,0BAAoB;;IACvC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;CAChE;;;;;;;AAQD,AAAO,IAAM,IAAI,GAAG,UAAC,IAAY;IAC7B,OAAA,UAAC,GAAQ,IAAK,OAAA,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,GAAA;CAAA,CAAC;;;;;;;;AASnC,AAAO,IAAM,MAAM,GAAG,KAAK,CAAC,UAAC,IAAY,EAAE,IAAS,EAAE,GAAQ,IAAK,OAAA,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,GAAA,CAAC,CAAC;;;;;;;;;AAU9F,AAAO,IAAM,KAAK,GAAG,UAAC,IAAY;IAC9B,OAAA,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;CAAA,CAAC;;;;;AAMhD,AAAO,IAAM,GAAG,GAA2C,UAAC,EAAkB;IAC1E,OAAA;QAAC,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,yBAAc;;QAAK,OAAA,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;KAAA;CAAA,CAAC;;;;;AAM9C,aAAoB,GAAmB,EAAE,GAAmB;IAC1D,OAAO;QAAC,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,yBAAc;;QAAK,OAAA,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;KAAA,CAAC;CAC3E;;;;;AAMD,YAAmB,GAAmB,EAAE,GAAmB;IACzD,OAAO;QAAC,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,yBAAc;;QAAK,OAAA,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;KAAA,CAAC;CAC3E;;;;;;;AAQD,AAAO,IAAM,GAAG,GAAG,UAAC,GAAmB;IACnC,OAAA,UAAC,GAAU,IAAK,OAAA,GAAG,CAAC,MAAM,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAA,EAAE,IAAI,CAAY,GAAA;CAAA,CAAC;;AAGzE,AAAO,IAAM,GAAG,GAAG,UAAC,GAAmB;IACnC,OAAA,UAAC,GAAU,IAAK,OAAA,GAAG,CAAC,MAAM,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAA,EAAE,KAAK,CAAY,GAAA;CAAA,CAAC;;AAG1E,AAAO,IAAM,EAAE,GAAG,UAAK,IAAyB;IAC5C,OAAA,UAAC,GAAQ;QACL,QAAC,GAAG,IAAI,IAAI,IAAI,GAAG,CAAC,WAAW,KAAK,IAAI,IAAI,GAAG,YAAY,IAAI;KAAC;CAAA,CAAC;;AAGzE,AAAO,IAAM,EAAE,GAAkC,UAAC,KAAU,IAAK,OAAA,UAAC,KAAU;IACxE,OAAA,KAAK,KAAK,KAAK;CAAA,GAAA,CAAC;;AAGpB,AAAO,IAAM,GAAG,GAAG,UAAK,CAAI,IAAK,OAAA,cAAM,OAAA,CAAC,GAAA,GAAA,CAAC;AAMzC,gBAAuB,MAAc,EAAE,IAAY;IACjD,OAAO,UAAC,GAAQ;QACZ,OAAA,GAAG,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC;KAAA,CAAC;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CD,iBAAwB,MAAoB;IAC1C,OAAO,UAAS,CAAM;QACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACtC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAAE,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC7C;KACF,CAAC;CACH;;AClOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA;IAeE,cAAY,IAAY;QACtB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAE5B,IAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;aACpC,GAAG,CAAC,UAAA,GAAG;YACN,IAAI,GAAG,KAAK,IAAI;gBAAE,OAAO,oBAAoB,CAAC;YAC9C,IAAI,GAAG,KAAK,GAAG;gBAAG,OAAO,UAAU,CAAC;YACpC,OAAyB,KAAK,GAAG,GAAG,CAAC;SACtC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAEhB,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,YAAY,GAAG,GAAG,CAAC,CAAC;KACpD;;IArBM,OAAE,GAAT,UAAU,IAAY;QACpB,OAAO,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KAC9B;;IAGM,eAAU,GAAjB,UAAkB,IAAY;QAC5B,OAAO,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;KAC9C;IAgBD,sBAAO,GAAP,UAAQ,IAAY;QAClB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;KACrC;IACH,WAAC;CAAA;;ACnED;;;;;;;;;;AAUA;;IA+GE,qBAAY,MAAyB;QACnC,OAAO,WAAW,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;KACzC;;;;;;;;;IAxBM,kBAAM,GAAb,UAAc,SAA4B;QACxC,SAAS,GAAG,WAAW,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,IAAI,SAAS,EAAE,GAAG,SAAS,CAAC;QAE9E,IAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC,SAAS,CAAC,CAAgB,CAAC;QAChF,SAAS,CAAC,OAAO,GAAG,cAAM,OAAA,KAAK,GAAA,CAAC;QAChC,KAAK,CAAC,IAAI,GAAG,SAAS,CAAC;QACvB,KAAK,CAAC,kBAAkB,GAAG;YACzB,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC;SACtC,CAAC;QACF,OAAO,KAAK,CAAC;KACd;;;;;;;;;;;;IA2BD,wBAAE,GAAF,UAAG,GAAwC;QACzC,OAAO,IAAI,KAAK,GAAG,IAAI,IAAI,CAAC,IAAI,KAAK,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,KAAK,GAAG,CAAC;KAChE;;;;;IAMD,yBAAG,GAAH;QACE,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE,IAAI,CAAC,MAAM,YAAY,IAAI,CAAC,WAAW,CAAC;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC;QACjF,IAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;QAC/B,OAAO,IAAI,GAAG,IAAI,GAAG,GAAG,GAAG,IALine truncated
 }

UI/WebServerResources/js/vendor/angular-ui-router.min.js

@@ -4,9 +4,9 @@
  *         This causes it to be incompatible with plugins that depend on @uirouter/core.
  *         We recommend switching to the ui-router-core.js and ui-router-angularjs.js bundles instead.
  *         For more information, see https://ui-router.github.io/blog/uirouter-for-angularjs-umd-bundles
- * @version v1.0.13
+ * @version v1.0.14
  * @link https://ui-router.github.io
  * @license MIT License, http://www.opensource.org/licenses/MIT
  */
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("angular")):"function"==typeof define&&define.amd?define(["exports","angular"],e):e(t["@uirouter/angularjs"]={},t.angular)}(this,function(t,e){"use strict";function r(t){function e(r){return r.length>=n?t.apply(null,r):function(){return e(r.concat([].slice.apply(arguments)))}}var r=[].slice.apply(arguments,[1]),n=t.length;return e(r)}function n(){var t=arguments,e=t.length-1;return function(){for(var r=e,n=t[e].apply(this,arguments);r--;)n=t[r].call(this,n);return n}}function i(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return n.apply(null,[].slice.call(arguments).reverse())}function o(t,e){return function(){for(var r=[],n=0;n<arguments.length;n++)r[n]=arguments[n];return t.apply(null,r)&&e.apply(null,r)}}function a(t,e){return function(){for(var r=[],n=0;n<arguments.length;n++)r[n]=arguments[n];return t.apply(null,r)||e.apply(null,r)}}function u(t,e){return function(r){return r[t].apply(r,e)}}function s(t){return function(e){for(var r=0;r<t.length;r++)if(t[r][0](e))return t[r][1](e)}}function c(t){if(te(t)&&t.length){var e=t.slice(0,-1),r=t.slice(-1);return!(e.filter(Ht(Zt)).length||r.filter(Ht(Kt)).length)}return Kt(t)}function f(t){return t}function l(){}function h(t,e,r,n,i){void 0===i&&(i=!1);var o=function(e){return t()[e].bind(r())},a=function(t){return function(){return e[t]=o(t),e[t].apply(null,arguments)}};return(n=n||Object.keys(t())).reduce(function(t,e){return t[e]=i?a(e):o(e),t},e)}function p(t,e){return-1!==t.indexOf(e)}function d(t,e){var r=t.indexOf(e);return r>=0&&t.splice(r,1),t}function v(t,e){return t.push(e),e}function m(t){for(var e=[],r=1;r<arguments.length;r++)e[r-1]=arguments[r];var n=e.concat({}).reverse(),i=he.apply(null,n);return he({},i,g(t||{},Object.keys(i)))}function y(t,e){var r=[];for(var n in t.path){if(t.path[n]!==e.path[n])break;r.push(t.path[n])}return r}function g(t,e){var r={};for(var n in t)-1!==e.indexOf(n)&&(r[n]=t[n]);return r}function _(t,e){return Object.keys(t).filter(Ht(ve(e))).reduce(function(e,r){return e[r]=t[r],e},{})}function w(t,e){return b(t,Vt(e))}function $(t,e){var r=te(t),n=r?[]:{},i=r?function(t){return n.push(t)}:function(t,e){return n[e]=t};return le(t,function(t,r){e(t,r)&&i(t,r)}),n}function S(t,e){var r;return le(t,function(t,n){r||e(t,n)&&(r=t)}),r}function b(t,e){var r=te(t)?[]:{};return le(t,function(t,n){return r[n]=e(t,n)}),r}function R(t,e){return t.push(e),t}function E(t,e){return void 0===e&&(e="assert failure"),function(r){var n=t(r);if(!n)throw new Error(Kt(e)?e(r):e);return n}}function C(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];if(0===t.length)return[];for(var r=t.reduce(function(t,e){return Math.min(e.length,t)},9007199254740991),n=[],i=0;i<r;i++)!function(e){switch(t.length){case 1:n.push([t[0][e]]);break;case 2:n.push([t[0][e],t[1][e]]);break;case 3:n.push([t[0][e],t[1][e],t[2][e]]);break;case 4:n.push([t[0][e],t[1][e],t[2][e],t[3][e]]);break;default:n.push(t.map(function(t){return t[e]}))}}(i);return n}function T(t,e){var r,n;if(te(e)&&(r=e[0],n=e[1]),!Zt(r))throw new Error("invalid parameters to applyPairs");return t[r]=n,t}function P(t){return t.length&&t[t.length-1]||void 0}function k(t,e){return e&&Object.keys(e).forEach(function(t){return delete e[t]}),e||(e={}),he(e,t)}function O(t){for(var e=1;e<arguments.length;e++){var r=arguments[e];if(r)for(var n=Object.keys(r),i=0;i<n.length;i++)t[n[i]]=r[n[i]]}return t}function x(t,e){if(t===e)return!0;if(null===t||null===e)return!1;if(t!==t&&e!==e)return!0;var r=typeof t;if(r!==typeof e||"object"!==r)return!1;var n=[t,e];if(qt(te)(n))return I(t,e);if(qt(ee)(n))return t.getTime()===e.getTime();if(qt(re)(n))return t.toString()===e.toString();if(qt(Kt)(n))return!0;if([Kt,te,ee,re].map(Dt).reduce(function(t,e){return t||!!e(n)},!1))return!1;var i={};for(var o in t){if(!x(t[o],e[o]))return!1;i[o]=!0}for(var o in e)if(!i[o])return!1;return!0}function I(t,e){return t.length===e.length&&C(t,e).reduce(function(t,e){return t&&x(e[0],e[1])},!0)}function V(t){if(!t)return"ui-view (defunct)";var e=t.creationContext?t.creationContext.name||"(root)":"(none)";return"[ui-view#"+t.id+" "+t.$type+":"+t.fqn+" ("+t.name+"@"+e+")]"}function j(e){return Yt(e)?t.Category[e]:t.Category[t.Category[e]]}function A(t,e){var r=Zt(e)?[e]:e;return!!(Kt(r)?r:function(t){for(var e=r,n=0;n<e.length;n++){var i=new Lt(e[n]);if(i&&i.matches(t.name)||!i&&e[n]===t.name)return!0}return!1})(t)}function H(t,e,r){function n(t,n,a){void 0===a&&(a={});var u=new Je(e,r,n,t,o,a);return i.push(u),u.deregister.bind(u)}var i=(t._registeredHooks=t._registeredHooks||{})[r.name]=[],o=me(i);return t[r.name]=n,n}function q(t){return void 0===t&&(t=!1),function(e,r){var n=t?-1:1,i=(e.node.state.path.length-r.node.state.path.length)*n;return 0!==i?i:r.hook.priority-e.hook.priority}}function D(t,e){function r(t){return te(t)?t:zt(t)?[t]:[]}function n(t){switch(t.length){case 0:return;case 1:return"auto"===e?t[0]:t;defLine truncated
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("angular")):"function"==typeof define&&define.amd?define(["exports","angular"],e):e(t["@uirouter/angularjs"]={},t.angular)}(this,function(t,e){"use strict";var r=angular,n=e&&e.module?e:r;function i(t){var e=[].slice.apply(arguments,[1]),r=t.length;return function e(n){return n.length>=r?t.apply(null,n):function(){return e(n.concat([].slice.apply(arguments)))}}(e)}function o(){var t=arguments,e=t.length-1;return function(){for(var r=e,n=t[e].apply(this,arguments);r--;)n=t[r].call(this,n);return n}}function a(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return o.apply(null,[].slice.call(arguments).reverse())}var u=function(t){return function(e){return e&&e[t]}},s=i(function(t,e,r){return r&&r[t]===e}),c=function(t){return a.apply(null,t.split(".").map(u))},f=function(t){return function(){for(var e=[],r=0;r<arguments.length;r++)e[r]=arguments[r];return!t.apply(null,e)}};function l(t,e){return function(){for(var r=[],n=0;n<arguments.length;n++)r[n]=arguments[n];return t.apply(null,r)&&e.apply(null,r)}}function h(t,e){return function(){for(var r=[],n=0;n<arguments.length;n++)r[n]=arguments[n];return t.apply(null,r)||e.apply(null,r)}}var p=function(t){return function(e){return e.reduce(function(e,r){return e&&!!t(r)},!0)}},v=function(t){return function(e){return e.reduce(function(e,r){return e||!!t(r)},!1)}},d=function(t){return function(e){return null!=e&&e.constructor===t||e instanceof t}},m=function(t){return function(e){return t===e}},y=function(t){return function(){return t}};function g(t,e){return function(r){return r[t].apply(r,e)}}function _(t){return function(e){for(var r=0;r<t.length;r++)if(t[r][0](e))return t[r][1](e)}}var w=function(){function t(t){this.text=t,this.glob=t.split(".");var e=this.text.split(".").map(function(t){return"**"===t?"(?:|(?:\\.[^.]*)*)":"*"===t?"\\.[^.]*":"\\."+t}).join("");this.regexp=new RegExp("^"+e+"$")}return t.is=function(t){return!!/[!,*]+/.exec(t)},t.fromString=function(e){return t.is(e)?new t(e):null},t.prototype.matches=function(t){return this.regexp.test("."+t)},t}(),$=function(){function t(e){return t.create(e||{})}return t.create=function(e){e=t.isStateClass(e)?new e:e;var r=K(K(e,t.prototype));return e.$$state=function(){return r},r.self=e,r.__stateObjectCache={nameGlob:w.fromString(r.name)},r},t.prototype.is=function(t){return this===t||this.self===t||this.fqn()===t},t.prototype.fqn=function(){if(!(this.parent&&this.parent instanceof this.constructor))return this.name;var t=this.parent.fqn();return t?t+"."+this.name:this.name},t.prototype.root=function(){return this.parent&&this.parent.root()||this},t.prototype.parameters=function(t){return((t=it(t,{inherit:!0,matchingKeys:null})).inherit&&this.parent&&this.parent.parameters()||[]).concat(vt(this.params)).filter(function(e){return!t.matchingKeys||t.matchingKeys.hasOwnProperty(e.id)})},t.prototype.parameter=function(t,e){return void 0===e&&(e={}),this.url&&this.url.parameter(t,e)||lt(vt(this.params),s("id",t))||e.inherit&&this.parent&&this.parent.parameter(t)},t.prototype.toString=function(){return this.fqn()},t.isStateClass=function(t){return P(t)&&!0===t.__uiRouterState},t.isState=function(t){return x(t.__stateObjectCache)},t}(),S=Object.prototype.toString,b=function(t){return function(e){return typeof e===t}},R=b("undefined"),E=f(R),C=function(t){return null===t},T=h(C,R),P=b("function"),k=b("number"),O=b("string"),x=function(t){return null!==t&&"object"==typeof t},I=Array.isArray,V=function(t){return"[object Date]"===S.call(t)},j=function(t){return"[object RegExp]"===S.call(t)},A=$.isState;function H(t){if(I(t)&&t.length){var e=t.slice(0,-1),r=t.slice(-1);return!(e.filter(f(O)).length||r.filter(f(P)).length)}return P(t)}var D=l(x,a(u("then"),P)),q=function(t){return function(){throw new Error(t+"(): No coreservices implementation for UI-Router is loaded.")}},N={$q:void 0,$injector:void 0},F="object"==typeof self&&self.self===self&&self||"object"==typeof global&&global.global===global&&global||void 0,U=F.angular||{},L=U.fromJson||JSON.parse.bind(JSON),M=U.toJson||JSON.stringify.bind(JSON),B=U.forEach||function(t,e,r){if(I(t))return t.forEach(e,r);Object.keys(t).forEach(function(r){return e(t[r],r)})},G=Object.assign||xt,W=U.equals||It;function z(t){return t}function J(){}function Q(t,e,r,n,i){void 0===i&&(i=!1);var o=function(e){return t()[e].bind(r())};return(n=n||Object.keys(t())).reduce(function(t,r){var n;return t[r]=i?(n=r,function(){return e[n]=o(n),e[n].apply(null,arguments)}):o(r),t},e)}var K=function(t,e){return G(Object.create(t),e)},Y=i(Z);function Z(t,e){return-1!==t.indexOf(e)}var X=i(tt);function tt(t,e){var r=t.indexOf(e);return r>=0&&t.splice(r,1),t}var et=i(rt);function rt(t,e){return t.push(e),e}var nt=function(t){return t.slice().forEach(function(e){"function"==typeof e&&e(),X(t,e)})};function it(t){for(var e=[],r=1;r<arguments.length;r++)e[r-1]=arguments[r];var n=e.concat({}).reverse(),i=G.Line truncated
 //# sourceMappingURL=angular-ui-router.min.js.map