{"version":3,"sources":["(webpack)/buildin/global.js","./node_modules/@fxp/fxpservices/index.js","./node_modules/@uirouter/core/lib/common/common.js","./node_modules/@uirouter/core/lib/common/coreservices.js","./node_modules/@uirouter/core/lib/common/glob.js","./node_modules/@uirouter/core/lib/common/hof.js","./node_modules/@uirouter/core/lib/common/index.js","./node_modules/@uirouter/core/lib/common/predicates.js","./node_modules/@uirouter/core/lib/common/queue.js","./node_modules/@uirouter/core/lib/common/strings.js","./node_modules/@uirouter/core/lib/common/trace.js","./node_modules/@uirouter/core/lib/globals.js","./node_modules/@uirouter/core/lib/hooks/coreResolvables.js","./node_modules/@uirouter/core/lib/hooks/ignoredTransition.js","./node_modules/@uirouter/core/lib/hooks/invalidTransition.js","./node_modules/@uirouter/core/lib/hooks/lazyLoad.js","./node_modules/@uirouter/core/lib/hooks/onEnterExitRetain.js","./node_modules/@uirouter/core/lib/hooks/redirectTo.js","./node_modules/@uirouter/core/lib/hooks/resolve.js","./node_modules/@uirouter/core/lib/hooks/updateGlobals.js","./node_modules/@uirouter/core/lib/hooks/url.js","./node_modules/@uirouter/core/lib/hooks/views.js","./node_modules/@uirouter/core/lib/index.js","./node_modules/@uirouter/core/lib/interface.js","./node_modules/@uirouter/core/lib/params/index.js","./node_modules/@uirouter/core/lib/params/param.js","./node_modules/@uirouter/core/lib/params/paramType.js","./node_modules/@uirouter/core/lib/params/paramTypes.js","./node_modules/@uirouter/core/lib/params/stateParams.js","./node_modules/@uirouter/core/lib/path/index.js","./node_modules/@uirouter/core/lib/path/pathNode.js","./node_modules/@uirouter/core/lib/path/pathUtils.js","./node_modules/@uirouter/core/lib/resolve/index.js","./node_modules/@uirouter/core/lib/resolve/interface.js","./node_modules/@uirouter/core/lib/resolve/resolvable.js","./node_modules/@uirouter/core/lib/resolve/resolveContext.js","./node_modules/@uirouter/core/lib/router.js","./node_modules/@uirouter/core/lib/state/index.js","./node_modules/@uirouter/core/lib/state/stateBuilder.js","./node_modules/@uirouter/core/lib/state/stateMatcher.js","./node_modules/@uirouter/core/lib/state/stateObject.js","./node_modules/@uirouter/core/lib/state/stateQueueManager.js","./node_modules/@uirouter/core/lib/state/stateRegistry.js","./node_modules/@uirouter/core/lib/state/stateService.js","./node_modules/@uirouter/core/lib/state/targetState.js","./node_modules/@uirouter/core/lib/transition/hookBuilder.js","./node_modules/@uirouter/core/lib/transition/hookRegistry.js","./node_modules/@uirouter/core/lib/transition/index.js","./node_modules/@uirouter/core/lib/transition/interface.js","./node_modules/@uirouter/core/lib/transition/rejectFactory.js","./node_modules/@uirouter/core/lib/transition/transition.js","./node_modules/@uirouter/core/lib/transition/transitionEventType.js","./node_modules/@uirouter/core/lib/transition/transitionHook.js","./node_modules/@uirouter/core/lib/transition/transitionService.js","./node_modules/@uirouter/core/lib/url/index.js","./node_modules/@uirouter/core/lib/url/urlMatcher.js","./node_modules/@uirouter/core/lib/url/urlMatcherFactory.js","./node_modules/@uirouter/core/lib/url/urlRouter.js","./node_modules/@uirouter/core/lib/url/urlRule.js","./node_modules/@uirouter/core/lib/url/urlService.js","./node_modules/@uirouter/core/lib/vanilla.js","./node_modules/@uirouter/core/lib/vanilla/baseLocationService.js","./node_modules/@uirouter/core/lib/vanilla/browserLocationConfig.js","./node_modules/@uirouter/core/lib/vanilla/hashLocationService.js","./node_modules/@uirouter/core/lib/vanilla/index.js","./node_modules/@uirouter/core/lib/vanilla/injector.js","./node_modules/@uirouter/core/lib/vanilla/memoryLocationConfig.js","./node_modules/@uirouter/core/lib/vanilla/memoryLocationService.js","./node_modules/@uirouter/core/lib/vanilla/plugins.js","./node_modules/@uirouter/core/lib/vanilla/pushStateLocationService.js","./node_modules/@uirouter/core/lib/vanilla/q.js","./node_modules/@uirouter/core/lib/vanilla/utils.js","./node_modules/@uirouter/core/lib/view/index.js","./node_modules/@uirouter/core/lib/view/view.js","./src/app/common/rm-routes-constant.ts","./src/environments/common/appsettingsGenerator.ts","./src/environments/configs/appSettings.aurorasit.ts","./src/environments/configs/appSettings.dev.ts","./src/environments/configs/appSettings.prod.ts","./src/environments/configs/appSettings.sit.ts","./src/environments/configs/appSettings.ts","./src/environments/configs/appSettings.uat.ts","./src/routes.ts"],"names":["g","this","Function","e","window","module","exports","__esModule","Fxp","fxpComponentRegistrationService","partnerAppRegistrationService","adminLandingService","dashboardService","fxpAuthorizationService","fxpBreadcrumbService","userProfileService","userClaimsService","adalLoginHelperService","fxpMessageService","notificationStore","fxpConfigurationService","fxpFeedbackService","fxpRouteService","fxpStorageService","fxpToastNotificationService","helpCentralService","notificationActionCenter","notificationService","oBOUserService","pageLoaderService","pageTourEventService","personalizationService","plannedDownTimeService","systemMessagesService","timeZoneHelper","userInfoService","fxpBotService","fxpBotServiceProvider","businessProcessEvent","featureUsageEvent","systemEvent","componentType","environmentData","eventData","eventTypes","environment","fxpBroadcastedEvents","fxpLoggerService","fxpLoggerServiceExtension","telemetryConfiguration","userInfo","telemetryContext","fxpLoggingStrategyFactory","fxpOnlineLoggingStrategy","fxpHttpService","authorNotificationConstant","createAskOpsModalConstant","helpArticleImageModalConstant","sessionTimeoutModalConstant","SYSTEM_MESSAGE_UI","fxpEventBroadCastService","fxpIrisBotService","confitService","featureFlagService","fxpUIData","deviceFactoryProvider","fxpConstants","settingsServiceProvider","fxpContext","fxpPartnerHttpInterceptorHooks","fxpGlobalStoreService","fxpOCVFeedbackService","fxpSignalRService","errorSeverityLevel","fxpTelemActionType","fxpTelemEventName","fxpTelemActionStatus","commonUtils","componentFramework","Utils","Services","DeviceFactoryProvider","AdalLoginHelperService","CommonUtils","Factory","FxpUIData","Common","Constants","FxpConstants","Environment","ComponentFramework","FxpComponentRegistrationService","PartnerAppRegistrationService","UserProfileService","UserClaimsService","FxpMessageService","FxpEventBroadCastService","FxpIrisBotService","FxpHttpService","NotificationStore","AdminLandingService","DashboardService","FxpAuthorizationService","FxpBreadcrumbService","FxpConfigurationService","FxpFeedbackService","FxpRouteService","FxpStorageService","FxpToastNotificationService","HelpCentralService","NotificationActionCenter","NotificationService","OBOUserService","PageLoaderService","PageTourEventServiceAlias","PersonalizationService","PlannedDownTimeService","SystemMessagesService","TimeZoneHelper","UserInfoService","FxpBotService","FxpBotServiceProvider","SettingsServiceProvider","Telemetry","BusinessProcessEvent","FeatureUsageEvent","SystemEvent","ComponentType","ErrorSeverityLevel","FxpTelemActionType","FxpTelemEventName","FxpTelemActionStatus","EnvironmentData","EventData","EventTypes","FxpBroadcastedEvents","FxpLoggerService","FxpLoggerServiceExtension","TelemetryConfiguration","UserInfo","TelemetryContext","FxpLoggingStrategyFactory","FxpOnlineLoggingStrategy","AuthorNotificationConstant","HelpArticleImageModalConstant","SessionTimeoutModalConstant","ConFitService","FeatureFlagService","FxpPartnerHttpInterceptorHooks","FxpGlobalStoreService","FxpOCVFeedbackService","FxpSignalRService","Context","FxpContext","CreateAskOpsModalConstant","StorageType","ItEventType","ActionType","EventName","Object","defineProperty","value","predicates_1","hof_1","coreservices_1","root","self","global","angular","_inArray","array","obj","indexOf","_removeFrom","idx","splice","_pushTo","arr","val","push","pick","propNames","objCopy","_prop","map","collection","callback","target","isArray","forEach","item","i","pushR","assertFn","predicateOrMap","errMsg","result","Error","isFunction","arrayTuples","args","_i","arguments","length","maxArrayLen","reduce","min","Math","_loop_1","_extend","toObj","keys","j","_equals","o1","o2","t1","a1","a2","tup","all","b","t","isDate","getTime","isRegExp","toString","any","fn","key","fromJson","JSON","parse","bind","toJson","stringify","cb","_this","extend","assign","equals","identity","x","noop","createProxyFunctions","source","fnNames","latebind","bindFunction","fnName","acc","name","apply","inherit","parent","extra","create","inArray","curry","removeFrom","pushTo","deregAll","functions","slice","defaults","opts","defaultsList","_defaultsList","concat","reverse","defaultVals","mergeR","memo","ancestors","first","second","path","n","omit","filter","not","pluck","propName","prop","accept","find","mapObj","values","allTrueR","elem","anyTrueR","unnestR","flattenR","uniqR","token","unnest","flatten","assertPredicate","assertMap","pairs","applyPairs","keyValTuple","isString","tail","undefined","copy","src","dest","silenceUncaughtInPromise","promise","catch","silentRejection","error","services","$q","reject","notImplemented","fnname","$injector","Glob","text","glob","split","regexpString","seg","join","regexp","RegExp","is","exec","fromString","prototype","matches","test","initial_args","func_args_length","curried","compose","start","call","pipe","funcs","propEq","_val","and","fn1","fn2","or","ctor","constructor","eq","other","v","invoke","pattern","struct","__export","m","p","hasOwnProperty","stateObject_1","toStr","tis","isUndefined","isDefined","isNull","o","isNullOrUndefined","isNumber","isObject","Array","isState","StateObject","isInjectable","head","isPromise","common_1","Queue","_items","_limit","_evictListeners","onEvict","enqueue","items","evict","shift","dequeue","size","clear","current","remove","peekTail","peekHead","rejectFactory_1","transition_1","resolvable_1","functionToString","fnStr","fnToString","namedFunctionMatch","match","substr","_fn","maxLength","max","str","padString","kebobString","camelCase","replace","$1","toLowerCase","stringifyPatternFn","seen","format","isRejection","Rejection","isRejectionPromise","_transitionRejection","Transition","Resolvable","stringifyPattern","beforeAfterSubstr","char","hostRegex","stripLastPathElement","splitHash","splitQuery","splitEqual","trimHashVal","splitOnDelim","delim","re","joinNeighborsR","strings_1","uiViewString","uiview","state","creationContext","id","$type","fqn","normalizedCat","input","Category","consoleLog","console","log","consoletable","table","_tid","_rid","transLbl","trans","Trace","_enabled","approximateDigests","_set","enabled","categories","k","parseInt","isNaN","category","enable","disable","traceTransitionStart","TRANSITION","traceTransitionIgnored","traceHookInvocation","step","options","HOOK","event","context","registeredHook","traceHookResult","hookResult","transitionOptions","traceResolvePath","when","RESOLVE","traceResolvableResolved","resolvable","data","traceError","reason","traceSuccess","finalState","traceUIViewEvent","viewData","UIVIEW","traceUIViewConfigUpdated","traceUIViewFill","html","traceViewSync","VIEWCONFIG","uivheader","mapping","_a","_b","uiView","viewConfig","uiv","cfg","viewDecl","$context","$name","sort","a","localeCompare","traceViewServiceEvent","view","$id","$uiViewName","$uiViewContextAnchor","viewConfigString","traceViewServiceUIViewEvent","trace","stateParams_1","queue_1","UIRouterGlobals","params","StateParams","lastStartedTransitionId","transitionHistory","successfulTransitions","dispose","transition","router_1","resolve_1","addCoreResolvables","addResolvable","fromData","UIRouter","router","entering","registerAddCoreResolvables","transitionService","onCreate","TRANSITION_TOKENS","isTransition","treeChangesCleanup","nodes","treeChanges","replaceTransitionWithNull","r","node","resolvables","trace_1","ignoredHook","ignoredReason","_ignoredReason","pending","globals","abort","ignored","toPromise","registerIgnoredTransitionHook","onBefore","priority","invalidTransitionHook","valid","registerInvalidTransitionHook","lazyLoadHook","promises","$$state","lazyLoad","lazyLoadState","then","originalTransition","orig","targetState","stateService","identifier","$url","urlService","parts","rule","type","sync","lazyLoadFn","states","_state","stateRegistry","register","err","registerLazyLoadHook","makeEnterExitRetainHook","hookName","hookFn","onExitHook","registerOnExitHook","onExit","exiting","onRetainHook","registerOnRetainHook","onRetain","retained","onEnterHook","registerOnEnterHook","onEnter","targetState_1","redirectToHook","redirect","to","redirectTo","$state","handleResult","TargetState","registerRedirectToHook","onStart","resolveContext_1","RESOLVE_HOOK_PRIORITY","eagerResolvePath","ResolveContext","resolvePath","registerEagerResolvePath","lazyResolveState","subContext","registerLazyResolveState","resolveRemaining","registerResolveRemaining","onFinish","updateGlobalState","clearCurrentTransition","onSuccess","$current","$to","registerUpdateGlobalState","updateUrl","$urlRouter","urlRouter","location","navigable","urlOptions","url","update","registerUpdateUrl","loadEnteringViews","enteringViews","views","load","registerLoadEnteringViews","activateViews","exitingViews","$view","viewService","vc","deactivateViewConfig","activateViewConfig","registerActivateViews","UIRouterPluginBase","DefType","paramType_1","hasOwn","unwrapShorthand","getStaticDefaultValue","isShorthand","$$fn","Param","config","urlMatcherFactory","urlType","paramTypes","CONFIG","PATH","SEARCH","ParamType","getType","arrayDefaults","arrayParamNomenclature","arrayMode","$asArray","isOptional","dynamic","raw","squash","defaultPolicy","getSquashPolicy","defaultSquashPolicy","from","configuredKeys","getReplace","paramValues","params_1","param","changed","values1","values2","validates","isDefaultValue","tuple","replaceSpecialValues","_defaultValueCache","defaultValue","getDefaultValue","$normalize","isSearch","normalized","encoded","encode","def","decode","$subPattern","sub","mode","ArrayType","arrayWrap","arrayHandler","allTruthyMode","arrayUnwrap","arrayEqualsHandler","val1","val2","left","right","paramTypeFn","wrapperFn","$arrayMode","makeDefaultType","ParamTypes","typeQueue","defaultTypes","types","definition","definitionFn","_flushTypeQueue","valToString","defaultTypeBase","String","string","query","hash","int","bool","Boolean","date","getFullYear","getMonth","getDate","capture","Date","valueOf","l","json","$inherit","newParams","parentParams","parents","inherited","inheritList","param_1","PathNode","stateOrNode","paramSchema","parameters","res","clone","applyRawParams","pDef","paramDef","parameter","paramsFn","diff","pathNode_1","PathUtils","makeTargetState","registry","buildPath","toParams","buildToPath","fromPath","toPath","inheritParams","applyViewConfigs","viewDecls","subPath","viewConfigs","createViewConfig","toKeys","noInherit","toNode","toParamVals","incomingParamVals","fromParamVals","ownParamVals","reloadState","node1","node2","keep","nonDynamicParams","retainedWithToParams","retainedNode","cloned","matching","pathA","pathB","done","nodeA","nodeB","predicate","elementIdx","resolvePolicies","LAZY","EAGER","async","WAIT","NOWAIT","RXWAIT","predicates_2","defaultResolvePolicy","arg1","resolveFn","deps","policy","resolved","literal","getPolicy","thisPolicy","statePolicy","resolvePolicy","resolve","resolveContext","findNode","maybeWaitForRx","observable$","cached","cache","take","getDependencies","get","resolvedDeps","resolvedValue","interface_1","pathUtils_1","common_2","whens","ALL_WHENS","EAGER_WHENS","NATIVE_INJECTOR_TOKEN","_path","getTokens","getResolvable","addResolvables","newResolvables","matchedWhens","matchesPolicy","acceptedVals","whenOrAsync","nodeResolvables","nowait","wait","getResult","injector","_injector","UIInjectorImpl","availableResolvables","_node","fromInjector","getNative","native","getAsync","urlMatcherFactory_1","urlRouter_1","transitionService_1","view_1","stateRegistry_1","stateService_1","globals_1","urlService_1","_routerInstance","locationService","locationConfig","UrlService","locationServiceStub","locationConfigStub","_disposed","_disposables","ViewService","TransitionService","UrlMatcherFactory","UrlRouter","StateRegistry","StateService","_plugins","_pluginapi","_rootViewContext","disposable","d","plugin","pluginInstance","getPlugin","pluginName","nameBuilder","selfBuilder","dataBuilder","getUrlBuilder","$urlMatcherFactoryProvider","stateDec","parsed","charAt","substring","parseUrl","compile","paramMap","paramConfig","reloadOnSearch","isMatcher","append","getNavigableBuilder","isRoot","pathBuilder","includesBuilder","includes","resolvablesBuilder","resolveObj","getToken","provide","literal2Resolvable","useFactory","dependencies","useClass","useValue","useExisting","tuple2Resolvable","annotate","strictDi","item2Resolvable","decl","StateBuilder","matcher","paramFactory","builders","parentName","urlParams","nonUrlParams","fromConfig","builder","build","chain","parentFn","segments","pop","StateMatcher","_states","isRelative","stateName","stateOrName","base","matchGlob","isStr","__stateObjectCache","nameGlob","baseState","splitName","pathLength","relName","glob_1","stateDecl","isStateClass","ref","matchingKeys","StateQueueManager","$registry","listeners","queue","flush","registered","orphans","previousQueueLength","getState","notifyListeners","listener","s","name_1","orphanIdx","existingState","existingFutureState","deregister","attachRoute","prev","abstract","urlRuleFactory","stateMatcher_1","stateBuilder_1","stateQueueManager_1","_router","stateQueue","_registerRoot","_root","onStatesChanged","stateDefinition","_deregisterTree","getChildren","_children","children","deregistered","$ur","rules","removeRule","deregisteredStates","found","decorator","func","lazyLoad_1","invalidCallbacks","_defaultErrorHandler","$error$","stack","detail","boundFns","enumerable","configurable","defaultErrorHandler","_handleInvalidTargetState","toState","fromState","latestThing","latest","callbackQueue","checkForRedirect","superseded","transitionTo","invalid","invokeNextCallback","nextCallback","onInvalid","reload","notify","go","defautGoOpts","relative","transOpts","defaultTransOpts","reg","getCurrentPath","latestSuccess","currentPath","exists","rejectedTransitionHandler","isLatest","RejectType","IGNORED","SUPERSEDED","redirected","run","ABORTED","errorHandler","transitionToPromise","schema","include","href","defaultHrefOpts","lossy","absolute","nav","handler","_stateRegistry","_identifier","_params","_options","_definition","withState","withParams","withOptions","newOpts","isDef","transitionHook_1","HookBuilder","buildHooksForPhase","phase","_getEvents","buildHooks","hookType","matchingHooks","getMatchingHooks","baseHookOptions","hook","criteriaMatchPath","traceData","scope","TransitionHookScope","STATE","transitionHook","TransitionHook","reverseDepthSort","factor","depthDelta","tupleSort","reverseSort","isCreate","hookPhase","TransitionHookPhase","CREATE","$transitions","getHooks","matchState","criterion","toMatch","globStrings","RegisteredHook","tranSvc","eventType","matchCriteria","removeHookFromRegistry","invokeCount","_deregistered","invokeLimit","_matchingNodes","_getDefaultMatchCriteria","_getPathTypes","_getMatchingNodes","criteria","mn","pathtype","isStateHook","every","makeEvent","hooks","_registeredHooks","removeHookFn","hookRegistrationFn","matchObject","message","rejection","INVALID","aborted","errored","ERROR","normalize","hookRegistry_1","hookBuilder_1","stateSelf","_deferred","defer","_hookBuilder","isActive","_targetState","_transitionCount","_treeChanges","createTransitionHookRegFns","onCreateHooks","invokeHooks","onError","enteringStates","$from","compare","pathname","freeze","pathName","getResolveTokens","topath","targetNode","redirectedFrom","rf","redirects","redirectOpts","newOptions","newTransition","originalEnteringNodes","redirectEnteringNodes","_changedParams","tc","nodeSchemas","toValues","fromValues","toVals","fromVals","changes","same","newTC","pendTC","runAllHooks","getHooksFor","allBeforeHooks","BEFORE","allRunHooks","RUN","success","SUCCESS","_error","_aborted","paramDefs","invalidParams","invalidValues","fromStateOrName","toStateOrName","avoidEmptyHash","diToken","TransitionEventType","hookOrder","getResultHandler","getErrorHandler","synchronous","HANDLE_RESULT","REJECT_ERROR","defaultOptions","stateContext","isSuperseded","waitFor","nextHook","invokeHook","doneCallback","remainingHooks","logError","notCurrent","getNotCurrentRejection","handleError","handleHookResult","isTargetState","LOG_REJECTED_RESULT","LOG_ERROR","THROW_ERROR","coreResolvables_1","redirectTo_1","onEnterExitRetain_1","views_1","updateGlobals_1","url_1","transitionEventType_1","ignoredTransition_1","invalidTransition_1","custom","_eventTypes","_criteriaPaths","_deregisterHookFns","_defineCorePaths","_defineCoreEvents","_registerCoreTransitionHooks","hooksArray","Phase","TH","paths","_defineEvent","_definePathType","cmpByPhase","hookScope","fns","addCoreResolves","eagerResolve","lazyResolve","resolveAll","loadViews","updateGlobals","quoteRegExp","surroundPattern","splitOnSlash","UrlMatcher","_cache","_segments","_compiled","strict","caseInsensitive","matchArray","segment","placeholder","searchPlaceholder","patterns","last","checkParamErrors","nameValidator","matchDetails","index","lastIndex","search","fromSearch","_pattern","encodeDashes","encodeURIComponent","c","charCodeAt","toUpperCase","pathSegmentsAndParams","staticSegments","pathParams","queryParams","weights","weightsA","weightsB","padVal","len","padArrays","cmp","_pairs","reverseString","allReversed","allParams","searchParams","nPathSegments","urlm","findParam","urlMatchers","getDetails","isValid","pathString","queryString","paramDetails","urlMatcher_1","paramTypes_1","_isCaseInsensitive","_isStrictMode","_defaultSquashPolicy","_getConfig","strictMode","object","$get","urlRule_1","defaultRuleSortFn","prioritySort","URLMATCHER","REGEXP","RAW","OTHER","typeSort","urlMatcher","urlMatcherSort","useMatchPriority","idSort","_sortFn","_rules","interceptDeferred","_id","_sorted","UrlRuleFactory","listen","_otherwiseFn","compareFn","stableSort","ensureSorted","arrOfWrapper","wrapperA","wrapperB","cmpDiff","wrapper","best","weight","matchPriority","evt","defaultPrevented","newurl","applyResult","_stopFn","onChange","read","isHtml5","html5Mode","hashPrefix","baseHref","appendBasePath","slash","cfgPort","port","protocol","host","isUrlRule","otherwise","handlerFn","getHandlerFn","initial","urlParts","deferIntercept","what","makeRule","_what","fromUrlMatcher","fromRegExp","BaseUrlRule","_handler","details","optional","sticky","Number","makeStub","locationServicesFns","locationConfigFns","umfFns","rulesFns","syncFns","lateBind","locationServices","umf","utils_1","BaseLocationServices","fireAfterUpdate","_listeners","_listener","_get","getParams","_location","_history","history","buildUrl","BrowserLocationConfig","_isHtml5","_baseHref","_hashPrefix","hostname","newprefix","applyDocumentBaseHref","baseTag","document","getElementsByTagName","origin","extendStatics","__extends","setPrototypeOf","__proto__","__","HashLocationService","_super","addEventListener","title","removeEventListener","index_1","STRIP_COMMENTS","ARGUMENT_NAMES","has","locals","ensureExist","$inject","MemoryLocationConfig","_port","_protocol","_host","newval","MemoryLocationService","_url","browserLocationConfig_1","hashLocationService_1","pushStateLocationService_1","memoryLocationService_1","memoryLocationConfig_1","injector_1","q_1","servicesPlugin","hashLocationPlugin","locationPluginFactory","pushStateLocationPlugin","PushStateLocationService","memoryLocationPlugin","baseLocationService_1","_config","_getBasePrefix","basePrefix","exactBaseHrefMatch","startsWithBase","fullUrl","replaceState","pushState","Promise","deferred","keyValsToObjectR","accum","orEmptyString","beforehash","loc","searchObject","serviceClass","configurationClass","uiRouter","service","configuration","_uiViews","_viewConfigs","_viewConfigFactories","_viewConfigFactory","_registeredUIViews","_activeViewConfigs","_onSync","normalizeUIViewTarget","rawViewName","viewAtContext","uiViewName","uiViewContextAnchor","relativeViewNameSugar","anchorState","anchor","_rootContext","viewType","factory","cfgFactory","cfgs","uiViewsByFqn","viewConfigDepth","count","depthCompare","depthFn","posNeg","uiViewTuples","stateDepth","matchingConfigs","matchedViewConfigs","unmatchedConfigTuples","configUpdated","allTuples","registerUIView","uiViews","available","active","vcSegments","uivSegments","negOffset","fqnToFirstSegment","uiViewContext","RelationshipManagement","RmDeliveryRouteName","RmDeliveryRouteUrl","RmDashboardRouteName","RmDashboardRouteUrl","RmSearchReportsUnauthorizedRoute","RmSearchReportsUnauthorizedRouteUrl","RmSearchReportsUnAuthorizedOwnerCoOwnerList","sdpId","sdpName","RmReportCases","RmReportCasesRouteUrl","RmGenerateReport","RmGenerateReportRouteUrl","RmDashboardSummary","RmDashboardSummaryRouteUrl","RmDashboardAgreements","RmDashboardAgreementsRouteUrl","RmDashboardPrograms","RmDashboardProgramsRouteUrl","RmDashboardDeliveries","RmDashboardDeliveriesRouteUrl","RmDashboardCases","RmDashboardCasesRouteUrl","RmDashboardUtilizationView","RmDashboardUtilizationViewUrl","RmDashboardAccounts","RmDashboardAccountsRouteUrl","CSATView","CSATViewUrl","CloudKnowsPremier","CloudKnowsPremierUrl","CloudKnowsPremierSearch","CloudKnowsPremierSearchUrl","RmDashboardSoftwareAssurance","RmDashboardSoftwareRouteUrl","DmmRouteName","DmmRouteUrl","DmmPorfolioRouteName","DmmPortfolioRouteUrl","DmmPortfolio","DmmUtilization","DmmUtilizationRouteUrl","DmmActionView","DmmActionViewRouteUrl","DmmSdpReview","DmmSdpReviewRouteUrl","DmmCpeSurvey","DmmCpeSurveyRouteUrl","DmmCpeSurveyDetails","DmmCpeSurveyDetailsRouteUrl","DmmSoftwareAssurance","DmmSoftwareRouteUrl","DmmCkp","DmmCkpRouteUrl","CKPView","CKPViewUrl","RmRouteName","RmRouteUrl","RmRouteParamTab","RmRouteParamItemType","RmRouteAccountItemType","RmRoutePortfolioItemType","RmRouteTabSummary","RmRouteTabContacts","RmRouteTabPrograms","RmRouteTabAccount","RmRouteTabOpportunities","RmRouteTabSuccessEngagements","AccountRouteName","AccountRouteUrl","RmRoutesConstant","AccountRouteParamTab","AccountRouteParamAccountId","AccountRouteTabSummary","AccountRouteTabOpportunities","AccountRouteTabContacts","AccountRouteAccountItemType","AccountRouteTabSuccessEngagements","ProgramManagement","ProgramManagementRouteUrl","PortfolioSummary","PortfolioSummaryRouteUrl","PortfolioTabSummary","PortfolioTabPrograms","PortfolioTabDeliveries","PortfolioTabAccounts","PortfolioAccounts","PortfolioAccountsRouteUrl","PortfolioPrograms","PortfolioProgramsRouteUrl","PortfolioDeliveries","PortfolioDeliveriesRouteUrl","UnassignedPackages","UnassignedPackagesRouteUrl","UnlinkedRequests","UnlinkedRequestsRouteUrl","UnlinkedProjects","PortfolioCases","PortfolioCasesRouteUrl","PortfolioAgreements","PortfolioAgreementsRouteUrl","PortfolioUtilizationView","PortfolioUtilizationViewUrl","ServiceDeliveryPlan","ServiceDeliveryPlanRouteUrl","SdpRouteParamSdpId","SdpSummary","SdpSummaryRouteUrl","SdpPrograms","SdpProgramsRouteUrl","SupportProjects","SdpCreateProgram","SdpCreateProgramRouteUrl","SdpEditPrograms","SdpEditProgramsRouteUrl","SdpDeliveries","SdpDeliveriesRouteUrl","SdpContacts","SdpContactsRouteUrl","SdpAccessId","SdpAccessIdRouteUrl","SdpViewProgram","SdpViewProgramRouteUrl","SdpProgramRouteParamProgramId","SdpProgramRouteParamIsProspectiveCustomer","SdpEditProgram","SdpEditProgramRouteUrl","SdpCreateDelivery","SdpCreateDeliveryRouteUrl","SdpViewDelivery","SdpViewDeliveryRouteUrl","SdpDeliveryRouteParamDeliveryId","SdpEditDelivery","SdpEditDeliveryRouteUrl","SdpOutcomes","SdpOutcomesRouteUrl","SdpAgreements","SdpAgreementsRouteUrl","SuccessEngagement","SuccessEngagementUrl","SdpLeads","SdpLeadsRouteUrl","SdpCreateLead","SdpCreateLeadRouteUrl","SdpEditLead","SdpEditLeadRouteUrl","SDPPackageSummary","PackageSummaryRouteUrl","PackageRouteCombinedPackageId","SdpConsumption","PackageConsumptionRouteUrl","SdpPackageService","PackageServiceRouteUrl","SdpCases","PackageCasesRouteUrl","SdpPackageCustomerContacts","PackageCustomerContactsRouteUrl","SdpPackageContacts","PackageContactsRouteUrl","SdpPackageMailingList","PackageMailingListRouteUrl","UnassignedPackageSummary","UnassignedPackageConsumption","UnassignedPackageService","UnassignedPackageCases","UnassignedPackageContacts","UnAuthorized","UnAuthorizedRouteUrl","UnAuthorizedOwnerCoOwnerList","QueryRouteName","QueryRouteUrl","ManageQueriesRouteName","ManageQueriesRouteUrl","AgreementCase","AgreementRouteCombinedAgreementId","AgreementCaseRouteUrl","AgreementConsumption","AgreementConsumptionRouteUrl","AgreementDetails","AgreementDetailseRouteUrl","mergeObjects","destination","sourceLength","sources","objIndex","keysLength","keyIndex","appSettings","environmentAppSetting","EnvironmentName","Dev","Sit","Uat","AuroraSit","Prod","aurorasit","cdnBaseUrl","serviceEndPoints","clientId","serviceEndPoint","RmAppConfiguration","dev","prod","sit","settings","uat","getRoutes","fxpAppContext","applicationName","sharedBundles","routes","generatedBundle","headerName","partnerTelemetryName","appNameForTelemetry","pageNameForTelemetry","featureName","actionName","breadcrumbText","pageTitle","style","includeRootModule","surveyId","packageId","regionType","ownersList","gridName","tpid","grid","tab","subFeatureName","isNewSupportProjectExperience","combinedPackageId","isProspectiveCustomer","programId","serviceId","leadId","lead","queryName","combinedAgreementId","OwnerCoOwnerList","getServiceEndPoints","getBundles","baseUrl","files","sequentialLoading","getGeneratedBundles","currentScriptUrl","currentScript","lastIndexOf","registerLazyLoadedApp","RMApp_routes"],"mappings":"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","file":"routes.bundle.js","sourcesContent":["var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","\"use strict\";\r\nexports.__esModule = true;\r\nvar Fxp = window['Fxp'] || {};\r\nvar fxpComponentRegistrationService = null;\r\nvar partnerAppRegistrationService = null;\r\nvar adminLandingService = null;\r\nvar dashboardService = null;\r\nvar fxpAuthorizationService = null;\r\nvar fxpBreadcrumbService = null;\r\nvar userProfileService = null;\r\nvar userClaimsService = null;\r\nvar adalLoginHelperService = null;\r\nvar fxpMessageService = null;\r\nvar notificationStore = null;\r\nvar fxpConfigurationService = null;\r\nvar fxpFeedbackService = null;\r\nvar fxpRouteService = null;\r\nvar fxpStorageService = null;\r\nvar fxpToastNotificationService = null;\r\nvar helpCentralService = null;\r\nvar notificationActionCenter = null;\r\nvar notificationService = null;\r\nvar oBOUserService = null;\r\nvar pageLoaderService = null;\r\nvar pageTourEventService = null;\r\nvar personalizationService = null;\r\nvar plannedDownTimeService = null;\r\nvar systemMessagesService = null;\r\nvar timeZoneHelper = null;\r\nvar userInfoService = null;\r\nvar fxpBotService = null;\r\nvar fxpBotServiceProvider = null;\r\n\r\nvar businessProcessEvent = null;\r\nvar featureUsageEvent = null;\r\nvar systemEvent = null;\r\nvar componentType = null;\r\nvar environmentData = null;\r\nvar eventData = null;\r\nvar eventTypes = null;\r\nvar environment = null;\r\nvar fxpBroadcastedEvents = null;\r\nvar fxpLoggerService = null;\r\nvar fxpLoggerServiceExtension = null;\r\nvar telemetryConfiguration = null;\r\nvar userInfo = null;\r\nvar telemetryContext = null;\r\nvar fxpLoggingStrategyFactory = null;\r\nvar fxpOnlineLoggingStrategy = null;\r\nvar fxpHttpService = null;\r\nvar authorNotificationConstant = null;\r\nvar createAskOpsModalConstant = null;\r\nvar helpArticleImageModalConstant = null;\r\nvar sessionTimeoutModalConstant = null;\r\nvar SYSTEM_MESSAGE_UI = null;\r\nvar fxpEventBroadCastService = null;\r\nvar fxpIrisBotService = null;\r\nvar confitService = null;\r\nvar featureFlagService = null;\r\nvar fxpUIData = null;\r\nvar deviceFactoryProvider = null;\r\nvar fxpConstants = null;\r\nvar settingsServiceProvider = null;\r\nvar fxpContext = null;\r\nvar fxpPartnerHttpInterceptorHooks = null;\r\nvar fxpGlobalStoreService = null;\r\nvar fxpOCVFeedbackService = null\r\nvar fxpSignalRService = null;\r\nvar errorSeverityLevel = null;\r\nvar fxpTelemActionType = null;\r\nvar fxpTelemEventName = null;\r\nvar fxpTelemActionStatus = null;\r\nvar commonUtils = null;\r\nvar componentFramework = null; \r\n\r\nif (Fxp && Fxp.Utils && Fxp.Utils.Services) {\r\n    deviceFactoryProvider = Fxp.Utils.DeviceFactoryProvider;\r\n    adalLoginHelperService = Fxp.Utils.Services.AdalLoginHelperService;\r\n    commonUtils = Fxp.Utils.CommonUtils; \r\n}\r\nif(Fxp && Fxp.Factory){\r\n    fxpUIData = Fxp.Factory.FxpUIData;\r\n}\r\nif(Fxp && Fxp.Common){\r\n    fxpConstants = Fxp.Common.Constants.FxpConstants;\r\n    environment = Fxp.Common.Environment;\r\n    componentFramework = Fxp.Common.ComponentFramework;\r\n}\r\n\r\nif (Fxp && Fxp.Services) {\r\n    fxpComponentRegistrationService = Fxp.Services.FxpComponentRegistrationService;\r\n    partnerAppRegistrationService = Fxp.Services.PartnerAppRegistrationService;\r\n    userProfileService = Fxp.Services.UserProfileService;\r\n    userClaimsService = Fxp.Services.UserClaimsService;\r\n    fxpMessageService = Fxp.Services.FxpMessageService;\r\n    fxpEventBroadCastService = Fxp.Services.FxpEventBroadCastService;\r\n\tfxpIrisBotService = Fxp.Services.FxpIrisBotService;\r\n    fxpHttpService = Fxp.Services.FxpHttpService;\r\n    notificationStore = Fxp.Services.NotificationStore;\r\n    adminLandingService = Fxp.Services.AdminLandingService;\r\n    dashboardService = Fxp.Services.DashboardService;\r\n    fxpAuthorizationService = Fxp.Services.FxpAuthorizationService;\r\n    fxpBreadcrumbService = Fxp.Services.FxpBreadcrumbService;\r\n    fxpConfigurationService = Fxp.Services.FxpConfigurationService;\r\n    fxpFeedbackService = Fxp.Services.FxpFeedbackService;\r\n    fxpRouteService = Fxp.Services.FxpRouteService;\r\n    fxpStorageService = Fxp.Services.FxpStorageService;\r\n    fxpToastNotificationService = Fxp.Services.FxpToastNotificationService;\r\n    helpCentralService = Fxp.Services.HelpCentralService;\r\n    notificationActionCenter = Fxp.Services.NotificationActionCenter;\r\n    notificationService = Fxp.Services.NotificationService;\r\n    oBOUserService = Fxp.Services.OBOUserService;\r\n    pageLoaderService = Fxp.Services.PageLoaderService;\r\n    pageTourEventService = Fxp.Services.PageTourEventServiceAlias;\r\n    personalizationService = Fxp.Services.PersonalizationService;\r\n    plannedDownTimeService = Fxp.Services.PlannedDownTimeService;\r\n    systemMessagesService = Fxp.Services.SystemMessagesService;\r\n    timeZoneHelper = Fxp.Services.TimeZoneHelper;\r\n    userInfoService = Fxp.Services.UserInfoService;\r\n    fxpBotService = Fxp.Services.FxpBotService;\r\n    fxpBotServiceProvider = Fxp.Services.FxpBotServiceProvider;\r\n    settingsServiceProvider = Fxp.Services.SettingsServiceProvider;\r\n\r\n    businessProcessEvent = Fxp.Telemetry.BusinessProcessEvent;\r\n    featureUsageEvent = Fxp.Telemetry.FeatureUsageEvent;\r\n    systemEvent = Fxp.Telemetry.SystemEvent;\r\n    componentType = Fxp.Telemetry.ComponentType;\r\n    errorSeverityLevel = Fxp.Telemetry.ErrorSeverityLevel;\r\n    fxpTelemActionType = Fxp.Telemetry.FxpTelemActionType;\r\n    fxpTelemEventName = Fxp.Telemetry.FxpTelemEventName;\r\n    fxpTelemActionStatus = Fxp.Telemetry.FxpTelemActionStatus;\r\n    environmentData = Fxp.Telemetry.EnvironmentData;\r\n    eventData = Fxp.Telemetry.EventData;\r\n    eventTypes = Fxp.Telemetry.EventTypes;\r\n    fxpBroadcastedEvents = Fxp.Services.FxpBroadcastedEvents;\r\n    fxpLoggerService = Fxp.Telemetry.FxpLoggerService;\r\n    fxpLoggerServiceExtension = Fxp.Telemetry.FxpLoggerServiceExtension;\r\n    telemetryConfiguration = Fxp.Telemetry.TelemetryConfiguration;\r\n    userInfo = Fxp.Telemetry.UserInfo;\r\n    telemetryContext = Fxp.Telemetry.TelemetryContext;\r\n    fxpLoggingStrategyFactory = Fxp.Telemetry.FxpLoggingStrategyFactory;\r\n    fxpOnlineLoggingStrategy = Fxp.Telemetry.FxpOnlineLoggingStrategy;\r\n    authorNotificationConstant = Fxp.Constants.AuthorNotificationConstant;\r\n    createAskOpsModalConstant = Fxp.Constants.createAskOpsModalConstant;\r\n    helpArticleImageModalConstant = Fxp.Constants.HelpArticleImageModalConstant;\r\n    sessionTimeoutModalConstant = Fxp.Constants.SessionTimeoutModalConstant;\r\n    SYSTEM_MESSAGE_UI = Fxp.Constants.SYSTEM_MESSAGE_UI;\r\n    confitService = Fxp.Services.ConFitService;\r\n    featureFlagService = Fxp.Services.FeatureFlagService;\r\n    fxpPartnerHttpInterceptorHooks = Fxp.Services.FxpPartnerHttpInterceptorHooks;\r\n    fxpGlobalStoreService = Fxp.Services.FxpGlobalStoreService;\r\n    fxpOCVFeedbackService = Fxp.Services.FxpOCVFeedbackService;\r\n    fxpSignalRService = Fxp.Services.FxpSignalRService;\r\n\r\n}\r\nif (Fxp && Fxp.Context){\r\n    fxpContext = Fxp.Context.FxpContext;\r\n}\r\nexports.Fxp = Fxp;\r\nexports.AuthorNotificationConstant = authorNotificationConstant;\r\nexports.CreateAskOpsModalConstant = createAskOpsModalConstant;\r\nexports.HelpArticleImageModalConstant = helpArticleImageModalConstant;\r\nexports.SessionTimeoutModalConstant = sessionTimeoutModalConstant;\r\nexports.SYSTEM_MESSAGE_UI = SYSTEM_MESSAGE_UI;\r\nexports.FxpComponentRegistrationService = fxpComponentRegistrationService;\r\nexports.PartnerAppRegistrationService = partnerAppRegistrationService;\r\nexports.UserProfileService = userProfileService;\r\nexports.UserClaimsService = userClaimsService;\r\nexports.FxpMessageService = fxpMessageService;\r\nexports.FxpBroadcastedEvents = fxpBroadcastedEvents;\r\nexports.FxpEventBroadCastService = fxpEventBroadCastService;\r\nexports.FxpIrisBotService = fxpIrisBotService;\r\nexports.FxpHttpService = fxpHttpService;\r\nexports.NotificationStore = notificationStore;\r\nexports.AdalLoginHelperService = adalLoginHelperService;\r\nexports.AdminLandingService = adminLandingService;\r\nexports.DashboardService = dashboardService;\r\nexports.FxpAuthorizationService = fxpAuthorizationService;\r\nexports.FxpBreadcrumbService = fxpBreadcrumbService;\r\nexports.FxpConfigurationService = fxpConfigurationService;\r\nexports.FxpFeedbackService = fxpFeedbackService;\r\nexports.FxpRouteService = fxpRouteService;\r\nexports.FxpStorageService = fxpStorageService;\r\nexports.FxpToastNotificationService = fxpToastNotificationService;\r\nexports.HelpCentralService = helpCentralService;\r\nexports.NotificationActionCenter = notificationActionCenter;\r\nexports.NotificationService = notificationService;\r\nexports.OBOUserService = oBOUserService;\r\nexports.PageLoaderService = pageLoaderService;\r\nexports.pageTourEventService = pageTourEventService;\r\nexports.PersonalizationService = personalizationService;\r\nexports.PlannedDownTimeService = plannedDownTimeService;\r\nexports.SystemMessagesService = systemMessagesService;\r\nexports.TimeZoneHelper = timeZoneHelper;\r\nexports.UserInfoService = userInfoService;\r\nexports.FxpBotService = fxpBotService;\r\nexports.FxpBotServiceProvider = fxpBotServiceProvider;\r\nexports.BusinessProcessEvent = businessProcessEvent;\r\nexports.FeatureUsageEvent = featureUsageEvent;\r\nexports.SystemEvent = systemEvent;\r\nexports.ComponentType = componentType;\r\nexports.ErrorSeverityLevel = errorSeverityLevel;\r\nexports.FxpTelemActionType = fxpTelemActionType;\r\nexports.FxpTelemEventName = fxpTelemEventName;\r\nexports.FxpTelemActionStatus = fxpTelemActionStatus;\r\nexports.EnvironmentData = environmentData;\r\nexports.EventData = eventData;\r\nexports.EventTypes = eventTypes;\r\nexports.FxpLoggerService = fxpLoggerService;\r\nexports.FxpLoggerServiceExtension = fxpLoggerServiceExtension;\r\nexports.TelemetryConfiguration = telemetryConfiguration;\r\nexports.UserInfo = userInfo;\r\nexports.TelemetryContext = telemetryContext;\r\nexports.FxpLoggingStrategyFactory = fxpLoggingStrategyFactory;\r\nexports.FxpOnlineLoggingStrategy = fxpOnlineLoggingStrategy;\r\nexports.ConFitService = confitService;\r\nexports.FeatureFlagService = featureFlagService;\r\nexports.FxpUIData = fxpUIData;\r\nexports.DeviceFactoryProvider = deviceFactoryProvider;\r\nexports.FxpConstants = fxpConstants;\r\nexports.SettingsServiceProvider = settingsServiceProvider;\r\nexports.Environment = environment;\r\nexports.FxpContext = fxpContext;\r\nexports.FxpPartnerHttpInterceptorHooks = fxpPartnerHttpInterceptorHooks;\r\nexports.FxpGlobalStoreService = fxpGlobalStoreService;\r\nexports.FxpSignalRService = fxpSignalRService;\r\nexports.FxpGlobalStoreService = fxpGlobalStoreService;\r\nexports.FxpOCVFeedbackService = fxpOCVFeedbackService;\r\nexports.CommonUtils = commonUtils;\r\nexports.ComponentFramework = componentFramework;\r\n\r\n\r\nexports.StorageType = exports.ItEventType = exports.ActionType = exports.EventName = exports.ComponentType = exports.FxpTelemActionType = exports.FxpTelemEventName = exports.FxpTelemActionStatus = void 0;\r\nvar ComponentType;\r\n(function (ComponentType) {\r\n    ComponentType[ComponentType[\"Web\"] = 0] = \"Web\";\r\n    ComponentType[ComponentType[\"SmartApp\"] = 1] = \"SmartApp\";\r\n    ComponentType[ComponentType[\"Device\"] = 2] = \"Device\";\r\n    ComponentType[ComponentType[\"BackgroundProcess\"] = 3] = \"BackgroundProcess\";\r\n    ComponentType[ComponentType[\"WebService\"] = 4] = \"WebService\";\r\n    ComponentType[ComponentType[\"Executable\"] = 5] = \"Executable\";\r\n    ComponentType[ComponentType[\"DynamicLinkLibrary\"] = 6] = \"DynamicLinkLibrary\";\r\n    ComponentType[ComponentType[\"JobService\"] = 7] = \"JobService\";\r\n    ComponentType[ComponentType[\"WorkflowComponent\"] = 8] = \"WorkflowComponent\";\r\n    ComponentType[ComponentType[\"DataStore\"] = 9] = \"DataStore\";\r\n    ComponentType[ComponentType[\"Other\"] = 10] = \"Other\";\r\n})(ComponentType = exports.ComponentType || (exports.ComponentType = {}));\r\nvar EventName;\r\n(function (EventName) {\r\n    EventName[\"PageLoad\"] = \"PageLoad\";\r\n    EventName[\"DropdownSelected\"] = \"DropdownSelected\";\r\n    EventName[\"DropdownChange\"] = \"DropdownChange\";\r\n    EventName[\"PageNavigation\"] = \"PageNavigation\";\r\n    EventName[\"CheckboxChange\"] = \"CheckboxChange\";\r\n    EventName[\"ListChange\"] = \"ListChange\";\r\n    EventName[\"ButtonClick\"] = \"ButtonClick\";\r\n    EventName[\"TabChange\"] = \"TabChange\";\r\n    EventName[\"TabNavigation\"] = \"TabNavigation\";\r\n    EventName[\"PanelOpened\"] = \"PanelOpened\";\r\n    EventName[\"PanelClosed\"] = \"PanelClosed\";\r\n    EventName[\"PickerSelected\"] = \"PickerSelected\";\r\n    EventName[\"PickerDeselected\"] = \"PickerDeselected\";\r\n    EventName[\"TileAdded\"] = \"TileAdded\";\r\n    EventName[\"TileClicked\"] = \"TileClicked\";\r\n    EventName[\"TileDeleted\"] = \"TileDeleted\";\r\n    EventName[\"TileLoaded\"] = \"TileLoaded\";\r\n    EventName[\"OnFocus\"] = \"OnFocus\";\r\n    EventName[\"OnBlur\"] = \"OnBlur\";\r\n    EventName[\"TextChange\"] = \"TextChange\";\r\n    EventName[\"Scroll\"] = \"Scroll\";\r\n    EventName[\"SectionRendering\"] = \"SectionRendering\";\r\n    EventName[\"BackEndAPICall\"] = \"BackEndAPICall\";\r\n    EventName[\"Rendering\"] = \"Rendering\";\r\n    EventName[\"NA\"] = \"NA\";\r\n    EventName[\"Hover\"] = \"Hover\";\r\n    EventName[\"LinkClicked\"] = \"LinkClicked\";\r\n})(EventName = exports.EventName || (exports.EventName = {}));\r\nvar ActionType;\r\n(function (ActionType) {\r\n    ActionType[\"User\"] = \"User\";\r\n    ActionType[\"System\"] = \"System\";\r\n    ActionType[\"Aware\"] = \"Aware\";\r\n})(ActionType = exports.ActionType || (exports.ActionType = {}));\r\nvar ItEventType;\r\n(function (ItEventType) {\r\n    ItEventType[ItEventType[\"FeatureUsageEvent\"] = 0] = \"FeatureUsageEvent\";\r\n    ItEventType[ItEventType[\"BusinessProcessEvent\"] = 1] = \"BusinessProcessEvent\";\r\n    ItEventType[ItEventType[\"BusinessEventMessageExchange\"] = 2] = \"BusinessEventMessageExchange\";\r\n    ItEventType[ItEventType[\"BusinessEventEntityUpdate\"] = 3] = \"BusinessEventEntityUpdate\";\r\n    ItEventType[ItEventType[\"BusinessEventDatabaseRecord\"] = 4] = \"BusinessEventDatabaseRecord\";\r\n    ItEventType[ItEventType[\"SystemEvent\"] = 5] = \"SystemEvent\";\r\n    ItEventType[ItEventType[\"Other\"] = 6] = \"Other\";\r\n})(ItEventType = exports.ItEventType || (exports.ItEventType = {}));\r\nvar StorageType;\r\n(function (StorageType) {\r\n    StorageType[StorageType[\"LocalStorage\"] = 0] = \"LocalStorage\";\r\n    StorageType[StorageType[\"SessionStorage\"] = 1] = \"SessionStorage\";\r\n})(StorageType = exports.StorageType || (exports.StorageType = {}));\r\nvar FxpTelemActionType;\r\n(function (FxpTelemActionType) {\r\n    FxpTelemActionType[\"User\"] = \"User\";\r\n    FxpTelemActionType[\"System\"] = \"System\";\r\n    FxpTelemActionType[\"Aware\"] = \"Aware\";\r\n})(FxpTelemActionType = exports.FxpTelemActionType || (exports.FxpTelemActionType = {}));\r\nvar FxpTelemEventName;\r\n(function (FxpTelemEventName) {\r\n    FxpTelemEventName[\"PageLoad\"] = \"PageLoad\";\r\n    FxpTelemEventName[\"DropdownSelected\"] = \"DropdownSelected\";\r\n    FxpTelemEventName[\"DropdownChange\"] = \"DropdownChange\";\r\n    FxpTelemEventName[\"PageNavigation\"] = \"PageNavigation\";\r\n    FxpTelemEventName[\"CheckboxChange\"] = \"CheckboxChange\";\r\n    FxpTelemEventName[\"ListChange\"] = \"ListChange\";\r\n    FxpTelemEventName[\"ButtonClick\"] = \"ButtonClick\";\r\n    FxpTelemEventName[\"TabChange\"] = \"TabChange\";\r\n    FxpTelemEventName[\"TabNavigation\"] = \"TabNavigation\";\r\n    FxpTelemEventName[\"PanelOpened\"] = \"PanelOpened\";\r\n    FxpTelemEventName[\"PanelClosed\"] = \"PanelClosed\";\r\n    FxpTelemEventName[\"PickerSelected\"] = \"PickerSelected\";\r\n    FxpTelemEventName[\"PickerDeselected\"] = \"PickerDeselected\";\r\n    FxpTelemEventName[\"TileAdded\"] = \"TileAdded\";\r\n    FxpTelemEventName[\"TileClicked\"] = \"TileClicked\";\r\n    FxpTelemEventName[\"TileDeleted\"] = \"TileDeleted\";\r\n    FxpTelemEventName[\"TileLoaded\"] = \"TileLoaded\";\r\n    FxpTelemEventName[\"OnFocus\"] = \"OnFocus\";\r\n    FxpTelemEventName[\"OnBlur\"] = \"OnBlur\";\r\n    FxpTelemEventName[\"TextChange\"] = \"TextChange\";\r\n    FxpTelemEventName[\"Scroll\"] = \"Scroll\";\r\n    FxpTelemEventName[\"SectionRendering\"] = \"SectionRendering\";\r\n    FxpTelemEventName[\"BackEndAPICall\"] = \"BackEndAPICall\";\r\n    FxpTelemEventName[\"Rendering\"] = \"Rendering\";\r\n    FxpTelemEventName[\"NA\"] = \"NA\";\r\n    FxpTelemEventName[\"Hover\"] = \"Hover\";\r\n    FxpTelemEventName[\"LinkClicked\"] = \"LinkClicked\";\r\n})(FxpTelemEventName = exports.FxpTelemEventName || (exports.FxpTelemEventName = {}));\r\n\r\nvar FxpTelemActionStatus;\r\n(function (FxpTelemActionStatus) {\r\n    FxpTelemActionStatus[\"Succeeded\"] = \"Succeeded\";\r\n    FxpTelemActionStatus[\"Failed\"] = \"Failed\";\r\n    FxpTelemActionStatus[\"NA\"] = \"NA\";\r\n})(FxpTelemActionStatus = exports.FxpTelemActionStatus || (exports.FxpTelemActionStatus = {}));","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\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 */\nvar predicates_1 = require(\"./predicates\");\nvar hof_1 = require(\"./hof\");\nvar coreservices_1 = require(\"./coreservices\");\nexports.root = (typeof self === 'object' && self.self === self && self) ||\n    (typeof global === 'object' && global.global === global && global) ||\n    this;\nvar angular = exports.root.angular || {};\nexports.fromJson = angular.fromJson || JSON.parse.bind(JSON);\nexports.toJson = angular.toJson || JSON.stringify.bind(JSON);\nexports.forEach = angular.forEach || _forEach;\nexports.extend = Object.assign || _extend;\nexports.equals = angular.equals || _equals;\nfunction identity(x) {\n    return x;\n}\nexports.identity = identity;\nfunction noop() { }\nexports.noop = noop;\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 */\nfunction createProxyFunctions(source, target, bind, fnNames, latebind) {\n    if (latebind === void 0) { latebind = false; }\n    var bindFunction = function (fnName) { return source()[fnName].bind(bind()); };\n    var makeLateRebindFn = function (fnName) {\n        return function lateRebindFunction() {\n            target[fnName] = bindFunction(fnName);\n            return target[fnName].apply(null, arguments);\n        };\n    };\n    fnNames = fnNames || Object.keys(source());\n    return fnNames.reduce(function (acc, name) {\n        acc[name] = latebind ? makeLateRebindFn(name) : bindFunction(name);\n        return acc;\n    }, target);\n}\nexports.createProxyFunctions = createProxyFunctions;\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 */\nexports.inherit = function (parent, extra) { return exports.extend(Object.create(parent), extra); };\n/** Given an array, returns true if the object is found in the array, (using indexOf) */\nexports.inArray = hof_1.curry(_inArray);\nfunction _inArray(array, obj) {\n    return array.indexOf(obj) !== -1;\n}\nexports._inArray = _inArray;\n/**\n * Given an array, and an item, if the item is found in the array, it removes it (in-place).\n * The same array is returned\n */\nexports.removeFrom = hof_1.curry(_removeFrom);\nfunction _removeFrom(array, obj) {\n    var idx = array.indexOf(obj);\n    if (idx >= 0)\n        array.splice(idx, 1);\n    return array;\n}\nexports._removeFrom = _removeFrom;\n/** pushes a values to an array and returns the value */\nexports.pushTo = hof_1.curry(_pushTo);\nfunction _pushTo(arr, val) {\n    return arr.push(val), val;\n}\nexports._pushTo = _pushTo;\n/** Given an array of (deregistration) functions, calls all functions and removes each one from the source array */\nexports.deregAll = function (functions) {\n    return functions.slice().forEach(function (fn) {\n        typeof fn === 'function' && fn();\n        exports.removeFrom(functions, fn);\n    });\n};\n/**\n * Applies a set of defaults to an options object.  The options object is filtered\n * to only those properties of the objects in the defaultsList.\n * Earlier objects in the defaultsList take precedence when applying defaults.\n */\nfunction defaults(opts) {\n    var defaultsList = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        defaultsList[_i - 1] = arguments[_i];\n    }\n    var _defaultsList = defaultsList.concat({}).reverse();\n    var defaultVals = exports.extend.apply(null, _defaultsList);\n    return exports.extend({}, defaultVals, pick(opts || {}, Object.keys(defaultVals)));\n}\nexports.defaults = defaults;\n/** Reduce function that merges each element of the list into a single object, using extend */\nexports.mergeR = function (memo, item) { return exports.extend(memo, item); };\n/**\n * Finds the common ancestor path between two states.\n *\n * @param {Object} first The first state.\n * @param {Object} second The second state.\n * @return {Array} Returns an array of state names in descending order, not including the root.\n */\nfunction ancestors(first, second) {\n    var path = [];\n    // tslint:disable-next-line:forin\n    for (var n in first.path) {\n        if (first.path[n] !== second.path[n])\n            break;\n        path.push(first.path[n]);\n    }\n    return path;\n}\nexports.ancestors = ancestors;\n/**\n * Return a copy of the object only containing the whitelisted properties.\n *\n * #### Example:\n * ```\n * var foo = { a: 1, b: 2, c: 3 };\n * var ab = pick(foo, ['a', 'b']); // { a: 1, b: 2 }\n * ```\n * @param obj the source object\n * @param propNames an Array of strings, which are the whitelisted property names\n */\nfunction pick(obj, propNames) {\n    var objCopy = {};\n    for (var _prop in obj) {\n        if (propNames.indexOf(_prop) !== -1) {\n            objCopy[_prop] = obj[_prop];\n        }\n    }\n    return objCopy;\n}\nexports.pick = pick;\n/**\n * Return a copy of the object omitting the blacklisted properties.\n *\n * @example\n * ```\n *\n * var foo = { a: 1, b: 2, c: 3 };\n * var ab = omit(foo, ['a', 'b']); // { c: 3 }\n * ```\n * @param obj the source object\n * @param propNames an Array of strings, which are the blacklisted property names\n */\nfunction omit(obj, propNames) {\n    return Object.keys(obj)\n        .filter(hof_1.not(exports.inArray(propNames)))\n        .reduce(function (acc, key) { return ((acc[key] = obj[key]), acc); }, {});\n}\nexports.omit = omit;\n/**\n * Maps an array, or object to a property (by name)\n */\nfunction pluck(collection, propName) {\n    return map(collection, hof_1.prop(propName));\n}\nexports.pluck = pluck;\n/** Filters an Array or an Object's properties based on a predicate */\nfunction filter(collection, callback) {\n    var arr = predicates_1.isArray(collection), result = arr ? [] : {};\n    var accept = arr ? function (x) { return result.push(x); } : function (x, key) { return (result[key] = x); };\n    exports.forEach(collection, function (item, i) {\n        if (callback(item, i))\n            accept(item, i);\n    });\n    return result;\n}\nexports.filter = filter;\n/** Finds an object from an array, or a property of an object, that matches a predicate */\nfunction find(collection, callback) {\n    var result;\n    exports.forEach(collection, function (item, i) {\n        if (result)\n            return;\n        if (callback(item, i))\n            result = item;\n    });\n    return result;\n}\nexports.find = find;\n/** Given an object, returns a new object, where each property is transformed by the callback function */\nexports.mapObj = map;\n/** Maps an array or object properties using a callback function */\nfunction map(collection, callback, target) {\n    target = target || (predicates_1.isArray(collection) ? [] : {});\n    exports.forEach(collection, function (item, i) { return (target[i] = callback(item, i)); });\n    return target;\n}\nexports.map = map;\n/**\n * Given an object, return its enumerable property values\n *\n * @example\n * ```\n *\n * let foo = { a: 1, b: 2, c: 3 }\n * let vals = values(foo); // [ 1, 2, 3 ]\n * ```\n */\nexports.values = function (obj) { return Object.keys(obj).map(function (key) { return obj[key]; }); };\n/**\n * Reduce function that returns true if all of the values are truthy.\n *\n * @example\n * ```\n *\n * let vals = [ 1, true, {}, \"hello world\"];\n * vals.reduce(allTrueR, true); // true\n *\n * vals.push(0);\n * vals.reduce(allTrueR, true); // false\n * ```\n */\nexports.allTrueR = function (memo, elem) { return memo && elem; };\n/**\n * Reduce function that returns true if any of the values are truthy.\n *\n *  * @example\n * ```\n *\n * let vals = [ 0, null, undefined ];\n * vals.reduce(anyTrueR, true); // false\n *\n * vals.push(\"hello world\");\n * vals.reduce(anyTrueR, true); // true\n * ```\n */\nexports.anyTrueR = function (memo, elem) { return memo || elem; };\n/**\n * Reduce function which un-nests a single level of arrays\n * @example\n * ```\n *\n * let input = [ [ \"a\", \"b\" ], [ \"c\", \"d\" ], [ [ \"double\", \"nested\" ] ] ];\n * input.reduce(unnestR, []) // [ \"a\", \"b\", \"c\", \"d\", [ \"double, \"nested\" ] ]\n * ```\n */\nexports.unnestR = function (memo, elem) { return memo.concat(elem); };\n/**\n * Reduce function which recursively un-nests all arrays\n *\n * @example\n * ```\n *\n * let input = [ [ \"a\", \"b\" ], [ \"c\", \"d\" ], [ [ \"double\", \"nested\" ] ] ];\n * input.reduce(unnestR, []) // [ \"a\", \"b\", \"c\", \"d\", \"double, \"nested\" ]\n * ```\n */\nexports.flattenR = function (memo, elem) {\n    return predicates_1.isArray(elem) ? memo.concat(elem.reduce(exports.flattenR, [])) : pushR(memo, elem);\n};\n/**\n * Reduce function that pushes an object to an array, then returns the array.\n * Mostly just for [[flattenR]] and [[uniqR]]\n */\nfunction pushR(arr, obj) {\n    arr.push(obj);\n    return arr;\n}\nexports.pushR = pushR;\n/** Reduce function that filters out duplicates */\nexports.uniqR = function (acc, token) { return (exports.inArray(acc, token) ? acc : pushR(acc, token)); };\n/**\n * Return a new array with a single level of arrays unnested.\n *\n * @example\n * ```\n *\n * let input = [ [ \"a\", \"b\" ], [ \"c\", \"d\" ], [ [ \"double\", \"nested\" ] ] ];\n * unnest(input) // [ \"a\", \"b\", \"c\", \"d\", [ \"double, \"nested\" ] ]\n * ```\n */\nexports.unnest = function (arr) { return arr.reduce(exports.unnestR, []); };\n/**\n * Return a completely flattened version of an array.\n *\n * @example\n * ```\n *\n * let input = [ [ \"a\", \"b\" ], [ \"c\", \"d\" ], [ [ \"double\", \"nested\" ] ] ];\n * flatten(input) // [ \"a\", \"b\", \"c\", \"d\", \"double, \"nested\" ]\n * ```\n */\nexports.flatten = function (arr) { return arr.reduce(exports.flattenR, []); };\n/**\n * Given a .filter Predicate, builds a .filter Predicate which throws an error if any elements do not pass.\n * @example\n * ```\n *\n * let isNumber = (obj) => typeof(obj) === 'number';\n * let allNumbers = [ 1, 2, 3, 4, 5 ];\n * allNumbers.filter(assertPredicate(isNumber)); //OK\n *\n * let oneString = [ 1, 2, 3, 4, \"5\" ];\n * oneString.filter(assertPredicate(isNumber, \"Not all numbers\")); // throws Error(\"\"Not all numbers\"\");\n * ```\n */\nexports.assertPredicate = assertFn;\n/**\n * Given a .map function, builds a .map function which throws an error if any mapped elements do not pass a truthyness test.\n * @example\n * ```\n *\n * var data = { foo: 1, bar: 2 };\n *\n * let keys = [ 'foo', 'bar' ]\n * let values = keys.map(assertMap(key => data[key], \"Key not found\"));\n * // values is [1, 2]\n *\n * let keys = [ 'foo', 'bar', 'baz' ]\n * let values = keys.map(assertMap(key => data[key], \"Key not found\"));\n * // throws Error(\"Key not found\")\n * ```\n */\nexports.assertMap = assertFn;\nfunction assertFn(predicateOrMap, errMsg) {\n    if (errMsg === void 0) { errMsg = 'assert failure'; }\n    return function (obj) {\n        var result = predicateOrMap(obj);\n        if (!result) {\n            throw new Error(predicates_1.isFunction(errMsg) ? errMsg(obj) : errMsg);\n        }\n        return result;\n    };\n}\nexports.assertFn = assertFn;\n/**\n * Like _.pairs: Given an object, returns an array of key/value pairs\n *\n * @example\n * ```\n *\n * pairs({ foo: \"FOO\", bar: \"BAR }) // [ [ \"foo\", \"FOO\" ], [ \"bar\": \"BAR\" ] ]\n * ```\n */\nexports.pairs = function (obj) { return Object.keys(obj).map(function (key) { return [key, obj[key]]; }); };\n/**\n * Given two or more parallel arrays, returns an array of tuples where\n * each tuple is composed of [ a[i], b[i], ... z[i] ]\n *\n * @example\n * ```\n *\n * let foo = [ 0, 2, 4, 6 ];\n * let bar = [ 1, 3, 5, 7 ];\n * let baz = [ 10, 30, 50, 70 ];\n * arrayTuples(foo, bar);       // [ [0, 1], [2, 3], [4, 5], [6, 7] ]\n * arrayTuples(foo, bar, baz);  // [ [0, 1, 10], [2, 3, 30], [4, 5, 50], [6, 7, 70] ]\n * ```\n */\nfunction arrayTuples() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    if (args.length === 0)\n        return [];\n    var maxArrayLen = args.reduce(function (min, arr) { return Math.min(arr.length, min); }, 9007199254740991); // aka 2^53 − 1 aka Number.MAX_SAFE_INTEGER\n    var result = [];\n    var _loop_1 = function (i) {\n        // This is a hot function\n        // Unroll when there are 1-4 arguments\n        switch (args.length) {\n            case 1:\n                result.push([args[0][i]]);\n                break;\n            case 2:\n                result.push([args[0][i], args[1][i]]);\n                break;\n            case 3:\n                result.push([args[0][i], args[1][i], args[2][i]]);\n                break;\n            case 4:\n                result.push([args[0][i], args[1][i], args[2][i], args[3][i]]);\n                break;\n            default:\n                result.push(args.map(function (array) { return array[i]; }));\n                break;\n        }\n    };\n    for (var i = 0; i < maxArrayLen; i++) {\n        _loop_1(i);\n    }\n    return result;\n}\nexports.arrayTuples = arrayTuples;\n/**\n * Reduce function which builds an object from an array of [key, value] pairs.\n *\n * Each iteration sets the key/val pair on the memo object, then returns the memo for the next iteration.\n *\n * Each keyValueTuple should be an array with values [ key: string, value: any ]\n *\n * @example\n * ```\n *\n * var pairs = [ [\"fookey\", \"fooval\"], [\"barkey\", \"barval\"] ]\n *\n * var pairsToObj = pairs.reduce((memo, pair) => applyPairs(memo, pair), {})\n * // pairsToObj == { fookey: \"fooval\", barkey: \"barval\" }\n *\n * // Or, more simply:\n * var pairsToObj = pairs.reduce(applyPairs, {})\n * // pairsToObj == { fookey: \"fooval\", barkey: \"barval\" }\n * ```\n */\nfunction applyPairs(memo, keyValTuple) {\n    var key, value;\n    if (predicates_1.isArray(keyValTuple))\n        key = keyValTuple[0], value = keyValTuple[1];\n    if (!predicates_1.isString(key))\n        throw new Error('invalid parameters to applyPairs');\n    memo[key] = value;\n    return memo;\n}\nexports.applyPairs = applyPairs;\n/** Get the last element of an array */\nfunction tail(arr) {\n    return (arr.length && arr[arr.length - 1]) || undefined;\n}\nexports.tail = tail;\n/**\n * shallow copy from src to dest\n */\nfunction copy(src, dest) {\n    if (dest)\n        Object.keys(dest).forEach(function (key) { return delete dest[key]; });\n    if (!dest)\n        dest = {};\n    return exports.extend(dest, src);\n}\nexports.copy = copy;\n/** Naive forEach implementation works with Objects or Arrays */\nfunction _forEach(obj, cb, _this) {\n    if (predicates_1.isArray(obj))\n        return obj.forEach(cb, _this);\n    Object.keys(obj).forEach(function (key) { return cb(obj[key], key); });\n}\nfunction _extend(toObj) {\n    for (var i = 1; i < arguments.length; i++) {\n        var obj = arguments[i];\n        if (!obj)\n            continue;\n        var keys = Object.keys(obj);\n        for (var j = 0; j < keys.length; j++) {\n            toObj[keys[j]] = obj[keys[j]];\n        }\n    }\n    return toObj;\n}\nexports._extend = _extend;\nfunction _equals(o1, o2) {\n    if (o1 === o2)\n        return true;\n    if (o1 === null || o2 === null)\n        return false;\n    if (o1 !== o1 && o2 !== o2)\n        return true; // NaN === NaN\n    var t1 = typeof o1, t2 = typeof o2;\n    if (t1 !== t2 || t1 !== 'object')\n        return false;\n    var tup = [o1, o2];\n    if (hof_1.all(predicates_1.isArray)(tup))\n        return _arraysEq(o1, o2);\n    if (hof_1.all(predicates_1.isDate)(tup))\n        return o1.getTime() === o2.getTime();\n    if (hof_1.all(predicates_1.isRegExp)(tup))\n        return o1.toString() === o2.toString();\n    if (hof_1.all(predicates_1.isFunction)(tup))\n        return true; // meh\n    var predicates = [predicates_1.isFunction, predicates_1.isArray, predicates_1.isDate, predicates_1.isRegExp];\n    if (predicates.map(hof_1.any).reduce(function (b, fn) { return b || !!fn(tup); }, false))\n        return false;\n    var keys = {};\n    // tslint:disable-next-line:forin\n    for (var key in o1) {\n        if (!_equals(o1[key], o2[key]))\n            return false;\n        keys[key] = true;\n    }\n    for (var key in o2) {\n        if (!keys[key])\n            return false;\n    }\n    return true;\n}\nfunction _arraysEq(a1, a2) {\n    if (a1.length !== a2.length)\n        return false;\n    return arrayTuples(a1, a2).reduce(function (b, t) { return b && _equals(t[0], t[1]); }, true);\n}\n// issue #2676\nexports.silenceUncaughtInPromise = function (promise) { return promise.catch(function (e) { return 0; }) && promise; };\nexports.silentRejection = function (error) { return exports.silenceUncaughtInPromise(coreservices_1.services.$q.reject(error)); };\n//# sourceMappingURL=common.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.notImplemented = function (fnname) { return function () {\n    throw new Error(fnname + \"(): No coreservices implementation for UI-Router is loaded.\");\n}; };\nvar services = {\n    $q: undefined,\n    $injector: undefined,\n};\nexports.services = services;\n//# sourceMappingURL=coreservices.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module core\n */\n/**\n * Matches state names using glob-like pattern strings.\n *\n * Globs can be used in specific APIs including:\n *\n * - [[StateService.is]]\n * - [[StateService.includes]]\n * - The first argument to Hook Registration functions like [[TransitionService.onStart]]\n *    - [[HookMatchCriteria]] and [[HookMatchCriterion]]\n *\n * A `Glob` string is a pattern which matches state names.\n * Nested state names are split into segments (separated by a dot) when processing.\n * The state named `foo.bar.baz` is split into three segments ['foo', 'bar', 'baz']\n *\n * Globs work according to the following rules:\n *\n * ### Exact match:\n *\n * The glob `'A.B'` matches the state named exactly `'A.B'`.\n *\n * | Glob        |Matches states named|Does not match state named|\n * |:------------|:--------------------|:---------------------|\n * | `'A'`       | `'A'`               | `'B'` , `'A.C'`      |\n * | `'A.B'`     | `'A.B'`             | `'A'` , `'A.B.C'`    |\n * | `'foo'`     | `'foo'`             | `'FOO'` , `'foo.bar'`|\n *\n * ### Single star (`*`)\n *\n * A single star (`*`) is a wildcard that matches exactly one segment.\n *\n * | Glob        |Matches states named  |Does not match state named |\n * |:------------|:---------------------|:--------------------------|\n * | `'*'`       | `'A'` , `'Z'`        | `'A.B'` , `'Z.Y.X'`       |\n * | `'A.*'`     | `'A.B'` , `'A.C'`    | `'A'` , `'A.B.C'`         |\n * | `'A.*.*'`   | `'A.B.C'` , `'A.X.Y'`| `'A'`, `'A.B'` , `'Z.Y.X'`|\n *\n * ### Double star (`**`)\n *\n * A double star (`'**'`) is a wildcard that matches *zero or more segments*\n *\n * | Glob        |Matches states named                           |Does not match state named         |\n * |:------------|:----------------------------------------------|:----------------------------------|\n * | `'**'`      | `'A'` , `'A.B'`, `'Z.Y.X'`                    | (matches all states)              |\n * | `'A.**'`    | `'A'` , `'A.B'` , `'A.C.X'`                   | `'Z.Y.X'`                         |\n * | `'**.X'`    | `'X'` , `'A.X'` , `'Z.Y.X'`                   | `'A'` , `'A.login.Z'`             |\n * | `'A.**.X'`  | `'A.X'` , `'A.B.X'` , `'A.B.C.X'`             | `'A'` , `'A.B.C'`                 |\n *\n */\nvar Glob = /** @class */ (function () {\n    function Glob(text) {\n        this.text = text;\n        this.glob = text.split('.');\n        var regexpString = this.text\n            .split('.')\n            .map(function (seg) {\n            if (seg === '**')\n                return '(?:|(?:\\\\.[^.]*)*)';\n            if (seg === '*')\n                return '\\\\.[^.]*';\n            return '\\\\.' + seg;\n        })\n            .join('');\n        this.regexp = new RegExp('^' + regexpString + '$');\n    }\n    /** Returns true if the string has glob-like characters in it */\n    Glob.is = function (text) {\n        return !!/[!,*]+/.exec(text);\n    };\n    /** Returns a glob from the string, or null if the string isn't Glob-like */\n    Glob.fromString = function (text) {\n        return Glob.is(text) ? new Glob(text) : null;\n    };\n    Glob.prototype.matches = function (name) {\n        return this.regexp.test('.' + name);\n    };\n    return Glob;\n}());\nexports.Glob = Glob;\n//# sourceMappingURL=glob.js.map","\"use strict\";\n/**\n * Higher order functions\n *\n * These utility functions are exported, but are subject to change without notice.\n *\n * @module common_hof\n */ /** */\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Returns a new function for [Partial Application](https://en.wikipedia.org/wiki/Partial_application) of the original function.\n *\n * Given a function with N parameters, returns a new function that supports partial application.\n * The new function accepts anywhere from 1 to N parameters.  When that function is called with M parameters,\n * where M is less than N, it returns a new function that accepts the remaining parameters.  It continues to\n * accept more parameters until all N parameters have been supplied.\n *\n *\n * This contrived example uses a partially applied function as an predicate, which returns true\n * if an object is found in both arrays.\n * @example\n * ```\n * // returns true if an object is in both of the two arrays\n * function inBoth(array1, array2, object) {\n *   return array1.indexOf(object) !== -1 &&\n *          array2.indexOf(object) !== 1;\n * }\n * let obj1, obj2, obj3, obj4, obj5, obj6, obj7\n * let foos = [obj1, obj3]\n * let bars = [obj3, obj4, obj5]\n *\n * // A curried \"copy\" of inBoth\n * let curriedInBoth = curry(inBoth);\n * // Partially apply both the array1 and array2\n * let inFoosAndBars = curriedInBoth(foos, bars);\n *\n * // Supply the final argument; since all arguments are\n * // supplied, the original inBoth function is then called.\n * let obj1InBoth = inFoosAndBars(obj1); // false\n *\n * // Use the inFoosAndBars as a predicate.\n * // Filter, on each iteration, supplies the final argument\n * let allObjs = [ obj1, obj2, obj3, obj4, obj5, obj6, obj7 ];\n * let foundInBoth = allObjs.filter(inFoosAndBars); // [ obj3 ]\n *\n * ```\n *\n * Stolen from: http://stackoverflow.com/questions/4394747/javascript-curry-function\n *\n * @param fn\n * @returns {*|function(): (*|any)}\n */\nfunction curry(fn) {\n    var initial_args = [].slice.apply(arguments, [1]);\n    var func_args_length = fn.length;\n    function curried(args) {\n        if (args.length >= func_args_length)\n            return fn.apply(null, args);\n        return function () {\n            return curried(args.concat([].slice.apply(arguments)));\n        };\n    }\n    return curried(initial_args);\n}\nexports.curry = curry;\n/**\n * Given a varargs list of functions, returns a function that composes the argument functions, right-to-left\n * given: f(x), g(x), h(x)\n * let composed = compose(f,g,h)\n * then, composed is: f(g(h(x)))\n */\nfunction compose() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function () {\n        var i = start, result = args[start].apply(this, arguments);\n        while (i--)\n            result = args[i].call(this, result);\n        return result;\n    };\n}\nexports.compose = compose;\n/**\n * Given a varargs list of functions, returns a function that is composes the argument functions, left-to-right\n * given: f(x), g(x), h(x)\n * let piped = pipe(f,g,h);\n * then, piped is: h(g(f(x)))\n */\nfunction pipe() {\n    var funcs = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        funcs[_i] = arguments[_i];\n    }\n    return compose.apply(null, [].slice.call(arguments).reverse());\n}\nexports.pipe = pipe;\n/**\n * Given a property name, returns a function that returns that property from an object\n * let obj = { foo: 1, name: \"blarg\" };\n * let getName = prop(\"name\");\n * getName(obj) === \"blarg\"\n */\nexports.prop = function (name) { return function (obj) { return obj && obj[name]; }; };\n/**\n * Given a property name and a value, returns a function that returns a boolean based on whether\n * the passed object has a property that matches the value\n * let obj = { foo: 1, name: \"blarg\" };\n * let getName = propEq(\"name\", \"blarg\");\n * getName(obj) === true\n */\nexports.propEq = curry(function (name, _val, obj) { return obj && obj[name] === _val; });\n/**\n * Given a dotted property name, returns a function that returns a nested property from an object, or undefined\n * let obj = { id: 1, nestedObj: { foo: 1, name: \"blarg\" }, };\n * let getName = prop(\"nestedObj.name\");\n * getName(obj) === \"blarg\"\n * let propNotFound = prop(\"this.property.doesnt.exist\");\n * propNotFound(obj) === undefined\n */\nexports.parse = function (name) { return pipe.apply(null, name.split('.').map(exports.prop)); };\n/**\n * Given a function that returns a truthy or falsey value, returns a\n * function that returns the opposite (falsey or truthy) value given the same inputs\n */\nexports.not = function (fn) { return function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return !fn.apply(null, args);\n}; };\n/**\n * Given two functions that return truthy or falsey values, returns a function that returns truthy\n * if both functions return truthy for the given arguments\n */\nfunction and(fn1, fn2) {\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return fn1.apply(null, args) && fn2.apply(null, args);\n    };\n}\nexports.and = and;\n/**\n * Given two functions that return truthy or falsey values, returns a function that returns truthy\n * if at least one of the functions returns truthy for the given arguments\n */\nfunction or(fn1, fn2) {\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return fn1.apply(null, args) || fn2.apply(null, args);\n    };\n}\nexports.or = or;\n/**\n * Check if all the elements of an array match a predicate function\n *\n * @param fn1 a predicate function `fn1`\n * @returns a function which takes an array and returns true if `fn1` is true for all elements of the array\n */\nexports.all = function (fn1) { return function (arr) { return arr.reduce(function (b, x) { return b && !!fn1(x); }, true); }; };\n// tslint:disable-next-line:variable-name\nexports.any = function (fn1) { return function (arr) { return arr.reduce(function (b, x) { return b || !!fn1(x); }, false); }; };\n/** Given a class, returns a Predicate function that returns true if the object is of that class */\nexports.is = function (ctor) { return function (obj) {\n    return (obj != null && obj.constructor === ctor) || obj instanceof ctor;\n}; };\n/** Given a value, returns a Predicate function that returns true if another value is === equal to the original value */\nexports.eq = function (value) { return function (other) { return value === other; }; };\n/** Given a value, returns a function which returns the value */\nexports.val = function (v) { return function () { return v; }; };\nfunction invoke(fnName, args) {\n    return function (obj) { return obj[fnName].apply(obj, args); };\n}\nexports.invoke = invoke;\n/**\n * Sorta like Pattern Matching (a functional programming conditional construct)\n *\n * See http://c2.com/cgi/wiki?PatternMatching\n *\n * This is a conditional construct which allows a series of predicates and output functions\n * to be checked and then applied.  Each predicate receives the input.  If the predicate\n * returns truthy, then its matching output function (mapping function) is provided with\n * the input and, then the result is returned.\n *\n * Each combination (2-tuple) of predicate + output function should be placed in an array\n * of size 2: [ predicate, mapFn ]\n *\n * These 2-tuples should be put in an outer array.\n *\n * @example\n * ```\n *\n * // Here's a 2-tuple where the first element is the isString predicate\n * // and the second element is a function that returns a description of the input\n * let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];\n *\n * // Second tuple: predicate \"isNumber\", mapfn returns a description\n * let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];\n *\n * let third = [ (input) => input === null,  (input) => `Oh, null...` ];\n *\n * let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];\n *\n * let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);\n *\n * console.log(descriptionOf(undefined)); // 'notdefined'\n * console.log(descriptionOf(55)); // '(55) That's a number!'\n * console.log(descriptionOf(\"foo\")); // 'Here's your string foo'\n * ```\n *\n * @param struct A 2D array.  Each element of the array should be an array, a 2-tuple,\n * with a Predicate and a mapping/output function\n * @returns {function(any): *}\n */\nfunction pattern(struct) {\n    return function (x) {\n        for (var i = 0; i < struct.length; i++) {\n            if (struct[i][0](x))\n                return struct[i][1](x);\n        }\n    };\n}\nexports.pattern = pattern;\n//# sourceMappingURL=hof.js.map","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module common */ /** for typedoc */\n__export(require(\"./common\"));\n__export(require(\"./coreservices\"));\n__export(require(\"./glob\"));\n__export(require(\"./hof\"));\n__export(require(\"./predicates\"));\n__export(require(\"./queue\"));\n__export(require(\"./strings\"));\n__export(require(\"./trace\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** 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/** */\nvar hof_1 = require(\"./hof\");\nvar stateObject_1 = require(\"../state/stateObject\");\nvar toStr = Object.prototype.toString;\nvar tis = function (t) { return function (x) { return typeof x === t; }; };\nexports.isUndefined = tis('undefined');\nexports.isDefined = hof_1.not(exports.isUndefined);\nexports.isNull = function (o) { return o === null; };\nexports.isNullOrUndefined = hof_1.or(exports.isNull, exports.isUndefined);\nexports.isFunction = tis('function');\nexports.isNumber = tis('number');\nexports.isString = tis('string');\nexports.isObject = function (x) { return x !== null && typeof x === 'object'; };\nexports.isArray = Array.isArray;\nexports.isDate = (function (x) { return toStr.call(x) === '[object Date]'; });\nexports.isRegExp = (function (x) { return toStr.call(x) === '[object RegExp]'; });\nexports.isState = stateObject_1.StateObject.isState;\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 */\nfunction isInjectable(val) {\n    if (exports.isArray(val) && val.length) {\n        var head = val.slice(0, -1), tail = val.slice(-1);\n        return !(head.filter(hof_1.not(exports.isString)).length || tail.filter(hof_1.not(exports.isFunction)).length);\n    }\n    return exports.isFunction(val);\n}\nexports.isInjectable = isInjectable;\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 */\nexports.isPromise = hof_1.and(exports.isObject, hof_1.pipe(hof_1.prop('then'), exports.isFunction));\n//# sourceMappingURL=predicates.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module common */\nvar common_1 = require(\"./common\");\nvar Queue = /** @class */ (function () {\n    function Queue(_items, _limit) {\n        if (_items === void 0) { _items = []; }\n        if (_limit === void 0) { _limit = null; }\n        this._items = _items;\n        this._limit = _limit;\n        this._evictListeners = [];\n        this.onEvict = common_1.pushTo(this._evictListeners);\n    }\n    Queue.prototype.enqueue = function (item) {\n        var items = this._items;\n        items.push(item);\n        if (this._limit && items.length > this._limit)\n            this.evict();\n        return item;\n    };\n    Queue.prototype.evict = function () {\n        var item = this._items.shift();\n        this._evictListeners.forEach(function (fn) { return fn(item); });\n        return item;\n    };\n    Queue.prototype.dequeue = function () {\n        if (this.size())\n            return this._items.splice(0, 1)[0];\n    };\n    Queue.prototype.clear = function () {\n        var current = this._items;\n        this._items = [];\n        return current;\n    };\n    Queue.prototype.size = function () {\n        return this._items.length;\n    };\n    Queue.prototype.remove = function (item) {\n        var idx = this._items.indexOf(item);\n        return idx > -1 && this._items.splice(idx, 1)[0];\n    };\n    Queue.prototype.peekTail = function () {\n        return this._items[this._items.length - 1];\n    };\n    Queue.prototype.peekHead = function () {\n        if (this.size())\n            return this._items[0];\n    };\n    return Queue;\n}());\nexports.Queue = Queue;\n//# sourceMappingURL=queue.js.map","\"use strict\";\n/**\n * Functions that manipulate strings\n *\n * Although these functions are exported, they are subject to change without notice.\n *\n * @module common_strings\n */ /** */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar predicates_1 = require(\"./predicates\");\nvar rejectFactory_1 = require(\"../transition/rejectFactory\");\nvar common_1 = require(\"./common\");\nvar hof_1 = require(\"./hof\");\nvar transition_1 = require(\"../transition/transition\");\nvar resolvable_1 = require(\"../resolve/resolvable\");\n/**\n * Returns a string shortened to a maximum length\n *\n * If the string is already less than the `max` length, return the string.\n * Else return the string, shortened to `max - 3` and append three dots (\"...\").\n *\n * @param max the maximum length of the string to return\n * @param str the input string\n */\nfunction maxLength(max, str) {\n    if (str.length <= max)\n        return str;\n    return str.substr(0, max - 3) + '...';\n}\nexports.maxLength = maxLength;\n/**\n * Returns a string, with spaces added to the end, up to a desired str length\n *\n * If the string is already longer than the desired length, return the string.\n * Else returns the string, with extra spaces on the end, such that it reaches `length` characters.\n *\n * @param length the desired length of the string to return\n * @param str the input string\n */\nfunction padString(length, str) {\n    while (str.length < length)\n        str += ' ';\n    return str;\n}\nexports.padString = padString;\nfunction kebobString(camelCase) {\n    return camelCase\n        .replace(/^([A-Z])/, function ($1) { return $1.toLowerCase(); }) // replace first char\n        .replace(/([A-Z])/g, function ($1) { return '-' + $1.toLowerCase(); }); // replace rest\n}\nexports.kebobString = kebobString;\nfunction _toJson(obj) {\n    return JSON.stringify(obj);\n}\nfunction _fromJson(json) {\n    return predicates_1.isString(json) ? JSON.parse(json) : json;\n}\nfunction promiseToString(p) {\n    return \"Promise(\" + JSON.stringify(p) + \")\";\n}\nfunction functionToString(fn) {\n    var fnStr = fnToString(fn);\n    var namedFunctionMatch = fnStr.match(/^(function [^ ]+\\([^)]*\\))/);\n    var toStr = namedFunctionMatch ? namedFunctionMatch[1] : fnStr;\n    var fnName = fn['name'] || '';\n    if (fnName && toStr.match(/function \\(/)) {\n        return 'function ' + fnName + toStr.substr(9);\n    }\n    return toStr;\n}\nexports.functionToString = functionToString;\nfunction fnToString(fn) {\n    var _fn = predicates_1.isArray(fn) ? fn.slice(-1)[0] : fn;\n    return (_fn && _fn.toString()) || 'undefined';\n}\nexports.fnToString = fnToString;\nvar stringifyPatternFn = null;\nvar stringifyPattern = function (value) {\n    var isRejection = rejectFactory_1.Rejection.isRejectionPromise;\n    stringifyPatternFn =\n        stringifyPatternFn ||\n            hof_1.pattern([\n                [hof_1.not(predicates_1.isDefined), hof_1.val('undefined')],\n                [predicates_1.isNull, hof_1.val('null')],\n                [predicates_1.isPromise, hof_1.val('[Promise]')],\n                [isRejection, function (x) { return x._transitionRejection.toString(); }],\n                [hof_1.is(rejectFactory_1.Rejection), hof_1.invoke('toString')],\n                [hof_1.is(transition_1.Transition), hof_1.invoke('toString')],\n                [hof_1.is(resolvable_1.Resolvable), hof_1.invoke('toString')],\n                [predicates_1.isInjectable, functionToString],\n                [hof_1.val(true), common_1.identity],\n            ]);\n    return stringifyPatternFn(value);\n};\nfunction stringify(o) {\n    var seen = [];\n    function format(value) {\n        if (predicates_1.isObject(value)) {\n            if (seen.indexOf(value) !== -1)\n                return '[circular ref]';\n            seen.push(value);\n        }\n        return stringifyPattern(value);\n    }\n    return JSON.stringify(o, function (key, value) { return format(value); }).replace(/\\\\\"/g, '\"');\n}\nexports.stringify = stringify;\n/** Returns a function that splits a string on a character or substring */\nexports.beforeAfterSubstr = function (char) { return function (str) {\n    if (!str)\n        return ['', ''];\n    var idx = str.indexOf(char);\n    if (idx === -1)\n        return [str, ''];\n    return [str.substr(0, idx), str.substr(idx + 1)];\n}; };\nexports.hostRegex = new RegExp('^(?:[a-z]+:)?//[^/]+/');\nexports.stripLastPathElement = function (str) { return str.replace(/\\/[^/]*$/, ''); };\nexports.splitHash = exports.beforeAfterSubstr('#');\nexports.splitQuery = exports.beforeAfterSubstr('?');\nexports.splitEqual = exports.beforeAfterSubstr('=');\nexports.trimHashVal = function (str) { return (str ? str.replace(/^#/, '') : ''); };\n/**\n * Splits on a delimiter, but returns the delimiters in the array\n *\n * #### Example:\n * ```js\n * var splitOnSlashes = splitOnDelim('/');\n * splitOnSlashes(\"/foo\"); // [\"/\", \"foo\"]\n * splitOnSlashes(\"/foo/\"); // [\"/\", \"foo\", \"/\"]\n * ```\n */\nfunction splitOnDelim(delim) {\n    var re = new RegExp('(' + delim + ')', 'g');\n    return function (str) { return str.split(re).filter(common_1.identity); };\n}\nexports.splitOnDelim = splitOnDelim;\n/**\n * Reduce fn that joins neighboring strings\n *\n * Given an array of strings, returns a new array\n * where all neighboring strings have been joined.\n *\n * #### Example:\n * ```js\n * let arr = [\"foo\", \"bar\", 1, \"baz\", \"\", \"qux\" ];\n * arr.reduce(joinNeighborsR, []) // [\"foobar\", 1, \"bazqux\" ]\n * ```\n */\nfunction joinNeighborsR(acc, x) {\n    if (predicates_1.isString(common_1.tail(acc)) && predicates_1.isString(x))\n        return acc.slice(0, -1).concat(common_1.tail(acc) + x);\n    return common_1.pushR(acc, x);\n}\nexports.joinNeighborsR = joinNeighborsR;\n//# sourceMappingURL=strings.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\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 \"@uirouter/core\";\n * trace.enable(1, 5); // TRANSITION and VIEWCONFIG\n * ```\n *\n * ### CJS\n * ```js\n * let trace = require(\"@uirouter/core\").trace;\n * trace.enable(\"TRANSITION\", \"VIEWCONFIG\");\n * ```\n *\n * ### Globals\n * ```js\n * let trace = window[\"@uirouter/core\"].trace;\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 */\nvar hof_1 = require(\"../common/hof\");\nvar predicates_1 = require(\"../common/predicates\");\nvar strings_1 = require(\"./strings\");\n/** @hidden */\nfunction uiViewString(uiview) {\n    if (!uiview)\n        return 'ui-view (defunct)';\n    var state = uiview.creationContext ? uiview.creationContext.name || '(root)' : '(none)';\n    return \"[ui-view#\" + uiview.id + \" \" + uiview.$type + \":\" + uiview.fqn + \" (\" + uiview.name + \"@\" + state + \")]\";\n}\n/** @hidden */\nvar viewConfigString = function (viewConfig) {\n    var view = viewConfig.viewDecl;\n    var state = view.$context.name || '(root)';\n    return \"[View#\" + viewConfig.$id + \" from '\" + state + \"' state]: target ui-view: '\" + view.$uiViewName + \"@\" + view.$uiViewContextAnchor + \"'\";\n};\n/** @hidden */\nfunction normalizedCat(input) {\n    return predicates_1.isNumber(input) ? Category[input] : Category[Category[input]];\n}\n/** @hidden */\nvar consoleLog = Function.prototype.bind.call(console.log, console);\n/** @hidden */\nvar consoletable = predicates_1.isFunction(console.table) ? console.table.bind(console) : consoleLog.bind(console);\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 */\nvar Category;\n(function (Category) {\n    Category[Category[\"RESOLVE\"] = 0] = \"RESOLVE\";\n    Category[Category[\"TRANSITION\"] = 1] = \"TRANSITION\";\n    Category[Category[\"HOOK\"] = 2] = \"HOOK\";\n    Category[Category[\"UIVIEW\"] = 3] = \"UIVIEW\";\n    Category[Category[\"VIEWCONFIG\"] = 4] = \"VIEWCONFIG\";\n})(Category = exports.Category || (exports.Category = {}));\n/** @hidden */\nvar _tid = hof_1.parse('$id');\n/** @hidden */\nvar _rid = hof_1.parse('router.$id');\n/** @hidden */\nvar transLbl = function (trans) { return \"Transition #\" + _tid(trans) + \"-\" + _rid(trans); };\n/**\n * Prints UI-Router Transition trace information to the console.\n */\nvar Trace = /** @class */ (function () {\n    /** @hidden */\n    function Trace() {\n        /** @hidden */\n        this._enabled = {};\n        this.approximateDigests = 0;\n    }\n    /** @hidden */\n    Trace.prototype._set = function (enabled, categories) {\n        var _this = this;\n        if (!categories.length) {\n            categories = Object.keys(Category)\n                .map(function (k) { return parseInt(k, 10); })\n                .filter(function (k) { return !isNaN(k); })\n                .map(function (key) { return Category[key]; });\n        }\n        categories.map(normalizedCat).forEach(function (category) { return (_this._enabled[category] = enabled); });\n    };\n    Trace.prototype.enable = function () {\n        var categories = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            categories[_i] = arguments[_i];\n        }\n        this._set(true, categories);\n    };\n    Trace.prototype.disable = function () {\n        var categories = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            categories[_i] = arguments[_i];\n        }\n        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    Trace.prototype.enabled = function (category) {\n        return !!this._enabled[normalizedCat(category)];\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceTransitionStart = function (trans) {\n        if (!this.enabled(Category.TRANSITION))\n            return;\n        console.log(transLbl(trans) + \": Started  -> \" + strings_1.stringify(trans));\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceTransitionIgnored = function (trans) {\n        if (!this.enabled(Category.TRANSITION))\n            return;\n        console.log(transLbl(trans) + \": Ignored  <> \" + strings_1.stringify(trans));\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceHookInvocation = function (step, trans, options) {\n        if (!this.enabled(Category.HOOK))\n            return;\n        var event = hof_1.parse('traceData.hookType')(options) || 'internal', context = hof_1.parse('traceData.context.state.name')(options) || hof_1.parse('traceData.context')(options) || 'unknown', name = strings_1.functionToString(step.registeredHook.callback);\n        console.log(transLbl(trans) + \":   Hook -> \" + event + \" context: \" + context + \", \" + strings_1.maxLength(200, name));\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceHookResult = function (hookResult, trans, transitionOptions) {\n        if (!this.enabled(Category.HOOK))\n            return;\n        console.log(transLbl(trans) + \":   <- Hook returned: \" + strings_1.maxLength(200, strings_1.stringify(hookResult)));\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceResolvePath = function (path, when, trans) {\n        if (!this.enabled(Category.RESOLVE))\n            return;\n        console.log(transLbl(trans) + \":         Resolving \" + path + \" (\" + when + \")\");\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceResolvableResolved = function (resolvable, trans) {\n        if (!this.enabled(Category.RESOLVE))\n            return;\n        console.log(transLbl(trans) + \":               <- Resolved  \" + resolvable + \" to: \" + strings_1.maxLength(200, strings_1.stringify(resolvable.data)));\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceError = function (reason, trans) {\n        if (!this.enabled(Category.TRANSITION))\n            return;\n        console.log(transLbl(trans) + \": <- Rejected \" + strings_1.stringify(trans) + \", reason: \" + reason);\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceSuccess = function (finalState, trans) {\n        if (!this.enabled(Category.TRANSITION))\n            return;\n        console.log(transLbl(trans) + \": <- Success  \" + strings_1.stringify(trans) + \", final state: \" + finalState.name);\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceUIViewEvent = function (event, viewData, extra) {\n        if (extra === void 0) { extra = ''; }\n        if (!this.enabled(Category.UIVIEW))\n            return;\n        console.log(\"ui-view: \" + strings_1.padString(30, event) + \" \" + uiViewString(viewData) + extra);\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceUIViewConfigUpdated = function (viewData, context) {\n        if (!this.enabled(Category.UIVIEW))\n            return;\n        this.traceUIViewEvent('Updating', viewData, \" with ViewConfig from context='\" + context + \"'\");\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceUIViewFill = function (viewData, html) {\n        if (!this.enabled(Category.UIVIEW))\n            return;\n        this.traceUIViewEvent('Fill', viewData, \" with: \" + strings_1.maxLength(200, html));\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceViewSync = function (pairs) {\n        if (!this.enabled(Category.VIEWCONFIG))\n            return;\n        var uivheader = 'uiview component fqn';\n        var cfgheader = 'view config state (view name)';\n        var mapping = pairs\n            .map(function (_a) {\n            var uiView = _a.uiView, viewConfig = _a.viewConfig;\n            var uiv = uiView && uiView.fqn;\n            var cfg = viewConfig && viewConfig.viewDecl.$context.name + \": (\" + viewConfig.viewDecl.$name + \")\";\n            return _b = {}, _b[uivheader] = uiv, _b[cfgheader] = cfg, _b;\n            var _b;\n        })\n            .sort(function (a, b) { return (a[uivheader] || '').localeCompare(b[uivheader] || ''); });\n        consoletable(mapping);\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceViewServiceEvent = function (event, viewConfig) {\n        if (!this.enabled(Category.VIEWCONFIG))\n            return;\n        console.log(\"VIEWCONFIG: \" + event + \" \" + viewConfigString(viewConfig));\n    };\n    /** @internalapi called by ui-router code */\n    Trace.prototype.traceViewServiceUIViewEvent = function (event, viewData) {\n        if (!this.enabled(Category.VIEWCONFIG))\n            return;\n        console.log(\"VIEWCONFIG: \" + event + \" \" + uiViewString(viewData));\n    };\n    return Trace;\n}());\nexports.Trace = Trace;\n/**\n * The [[Trace]] singleton\n *\n * #### Example:\n * ```js\n * import {trace} from \"@uirouter/core\";\n * trace.enable(1, 5);\n * ```\n */\nvar trace = new Trace();\nexports.trace = trace;\n//# sourceMappingURL=trace.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module core\n */ /** */\nvar stateParams_1 = require(\"./params/stateParams\");\nvar queue_1 = require(\"./common/queue\");\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 */\nvar UIRouterGlobals = /** @class */ (function () {\n    function UIRouterGlobals() {\n        /**\n         * Current parameter values\n         *\n         * The parameter values from the latest successful transition\n         */\n        this.params = new stateParams_1.StateParams();\n        /** @internalapi */\n        this.lastStartedTransitionId = -1;\n        /** @internalapi */\n        this.transitionHistory = new queue_1.Queue([], 1);\n        /** @internalapi */\n        this.successfulTransitions = new queue_1.Queue([], 1);\n    }\n    UIRouterGlobals.prototype.dispose = function () {\n        this.transitionHistory.clear();\n        this.successfulTransitions.clear();\n        this.transition = null;\n    };\n    return UIRouterGlobals;\n}());\nexports.UIRouterGlobals = UIRouterGlobals;\n//# sourceMappingURL=globals.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module hooks */ /** */\nvar transition_1 = require(\"../transition/transition\");\nvar router_1 = require(\"../router\");\nvar resolve_1 = require(\"../resolve\");\nvar common_1 = require(\"../common\");\nfunction addCoreResolvables(trans) {\n    trans.addResolvable(resolve_1.Resolvable.fromData(router_1.UIRouter, trans.router), '');\n    trans.addResolvable(resolve_1.Resolvable.fromData(transition_1.Transition, trans), '');\n    trans.addResolvable(resolve_1.Resolvable.fromData('$transition$', trans), '');\n    trans.addResolvable(resolve_1.Resolvable.fromData('$stateParams', trans.params()), '');\n    trans.entering().forEach(function (state) {\n        trans.addResolvable(resolve_1.Resolvable.fromData('$state$', state), state);\n    });\n}\nexports.registerAddCoreResolvables = function (transitionService) {\n    return transitionService.onCreate({}, addCoreResolvables);\n};\nvar TRANSITION_TOKENS = ['$transition$', transition_1.Transition];\nvar isTransition = common_1.inArray(TRANSITION_TOKENS);\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.\nexports.treeChangesCleanup = function (trans) {\n    var nodes = common_1.values(trans.treeChanges())\n        .reduce(common_1.unnestR, [])\n        .reduce(common_1.uniqR, []);\n    // If the resolvable is a Transition, return a new resolvable with null data\n    var replaceTransitionWithNull = function (r) {\n        return isTransition(r.token) ? resolve_1.Resolvable.fromData(r.token, null) : r;\n    };\n    nodes.forEach(function (node) {\n        node.resolvables = node.resolvables.map(replaceTransitionWithNull);\n    });\n};\n//# sourceMappingURL=coreResolvables.js.map","\"use strict\";\n/** @module hooks */ /** */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar trace_1 = require(\"../common/trace\");\nvar rejectFactory_1 = require(\"../transition/rejectFactory\");\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) {\n    var ignoredReason = trans._ignoredReason();\n    if (!ignoredReason)\n        return;\n    trace_1.trace.traceTransitionIgnored(trans);\n    var pending = trans.router.globals.transition;\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    return rejectFactory_1.Rejection.ignored().toPromise();\n}\nexports.registerIgnoredTransitionHook = function (transitionService) {\n    return transitionService.onBefore({}, ignoredHook, { priority: -9999 });\n};\n//# sourceMappingURL=ignoredTransition.js.map","\"use strict\";\n/** @module hooks */ /** */\nObject.defineProperty(exports, \"__esModule\", { value: true });\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) {\n    if (!trans.valid()) {\n        throw new Error(trans.error().toString());\n    }\n}\nexports.registerInvalidTransitionHook = function (transitionService) {\n    return transitionService.onBefore({}, invalidTransitionHook, { priority: -10000 });\n};\n//# sourceMappingURL=invalidTransition.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar coreservices_1 = require(\"../common/coreservices\");\n/**\n * A [[TransitionHookFn]] that performs lazy loading\n *\n * When entering a state \"abc\" which has a `lazyLoad` function defined:\n * - Invoke the `lazyLoad` function (unless it is already in process)\n *   - Flag the hook function as \"in process\"\n *   - The function should return a promise (that resolves when lazy loading is complete)\n * - Wait for the promise to settle\n *   - If the promise resolves to a [[LazyLoadResult]], then register those states\n *   - Flag the hook function as \"not in process\"\n * - If the hook was successful\n *   - Remove the `lazyLoad` function from the state declaration\n * - If all the hooks were successful\n *   - Retry the transition (by returning a TargetState)\n *\n * ```\n * .state('abc', {\n *   component: 'fooComponent',\n *   lazyLoad: () => System.import('./fooComponent')\n *   });\n * ```\n *\n * See [[StateDeclaration.lazyLoad]]\n */\nvar lazyLoadHook = function (transition) {\n    var router = transition.router;\n    function retryTransition() {\n        if (transition.originalTransition().options().source !== 'url') {\n            // The original transition was not triggered via url sync\n            // The lazy state should be loaded now, so re-try the original transition\n            var orig = transition.targetState();\n            return router.stateService.target(orig.identifier(), orig.params(), orig.options());\n        }\n        // The original transition was triggered via url sync\n        // Run the URL rules and find the best match\n        var $url = router.urlService;\n        var result = $url.match($url.parts());\n        var rule = result && result.rule;\n        // If the best match is a state, redirect the transition (instead\n        // of calling sync() which supersedes the current transition)\n        if (rule && rule.type === 'STATE') {\n            var state = rule.state;\n            var params = result.match;\n            return router.stateService.target(state, params, transition.options());\n        }\n        // No matching state found, so let .sync() choose the best non-state match/otherwise\n        router.urlService.sync();\n    }\n    var promises = transition\n        .entering()\n        .filter(function (state) { return !!state.$$state().lazyLoad; })\n        .map(function (state) { return lazyLoadState(transition, state); });\n    return coreservices_1.services.$q.all(promises).then(retryTransition);\n};\nexports.registerLazyLoadHook = function (transitionService) {\n    return transitionService.onBefore({ entering: function (state) { return !!state.lazyLoad; } }, lazyLoadHook);\n};\n/**\n * Invokes a state's lazy load function\n *\n * @param transition a Transition context\n * @param state the state to lazy load\n * @returns A promise for the lazy load result\n */\nfunction lazyLoadState(transition, state) {\n    var lazyLoadFn = state.$$state().lazyLoad;\n    // Store/get the lazy load promise on/from the hookfn so it doesn't get re-invoked\n    var promise = lazyLoadFn['_promise'];\n    if (!promise) {\n        var success = function (result) {\n            delete state.lazyLoad;\n            delete state.$$state().lazyLoad;\n            delete lazyLoadFn['_promise'];\n            return result;\n        };\n        var error = function (err) {\n            delete lazyLoadFn['_promise'];\n            return coreservices_1.services.$q.reject(err);\n        };\n        promise = lazyLoadFn['_promise'] = coreservices_1.services.$q\n            .when(lazyLoadFn(transition, state))\n            .then(updateStateRegistry)\n            .then(success, error);\n    }\n    /** Register any lazy loaded state definitions */\n    function updateStateRegistry(result) {\n        if (result && Array.isArray(result.states)) {\n            result.states.forEach(function (_state) { return transition.router.stateRegistry.register(_state); });\n        }\n        return result;\n    }\n    return promise;\n}\nexports.lazyLoadState = lazyLoadState;\n//# sourceMappingURL=lazyLoad.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\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) {\n    return function (transition, state) {\n        var _state = state.$$state();\n        var hookFn = _state[hookName];\n        return hookFn(transition, state);\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 */\nvar onExitHook = makeEnterExitRetainHook('onExit');\nexports.registerOnExitHook = function (transitionService) {\n    return transitionService.onExit({ exiting: function (state) { return !!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 */\nvar onRetainHook = makeEnterExitRetainHook('onRetain');\nexports.registerOnRetainHook = function (transitionService) {\n    return transitionService.onRetain({ retained: function (state) { return !!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 */\nvar onEnterHook = makeEnterExitRetainHook('onEnter');\nexports.registerOnEnterHook = function (transitionService) {\n    return transitionService.onEnter({ entering: function (state) { return !!state.onEnter; } }, onEnterHook);\n};\n//# sourceMappingURL=onEnterExitRetain.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module hooks */ /** */\nvar predicates_1 = require(\"../common/predicates\");\nvar coreservices_1 = require(\"../common/coreservices\");\nvar targetState_1 = require(\"../state/targetState\");\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 */\nvar redirectToHook = function (trans) {\n    var redirect = trans.to().redirectTo;\n    if (!redirect)\n        return;\n    var $state = trans.router.stateService;\n    function handleResult(result) {\n        if (!result)\n            return;\n        if (result instanceof targetState_1.TargetState)\n            return result;\n        if (predicates_1.isString(result))\n            return $state.target(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    if (predicates_1.isFunction(redirect)) {\n        return coreservices_1.services.$q.when(redirect(trans)).then(handleResult);\n    }\n    return handleResult(redirect);\n};\nexports.registerRedirectToHook = function (transitionService) {\n    return transitionService.onStart({ to: function (state) { return !!state.redirectTo; } }, redirectToHook);\n};\n//# sourceMappingURL=redirectTo.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module hooks */\n/** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar resolveContext_1 = require(\"../resolve/resolveContext\");\nvar hof_1 = require(\"../common/hof\");\nexports.RESOLVE_HOOK_PRIORITY = 1000;\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 */\nvar eagerResolvePath = function (trans) {\n    return new resolveContext_1.ResolveContext(trans.treeChanges().to).resolvePath('EAGER', trans).then(common_1.noop);\n};\nexports.registerEagerResolvePath = function (transitionService) {\n    return transitionService.onStart({}, eagerResolvePath, { priority: exports.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 */\nvar lazyResolveState = function (trans, state) {\n    return new resolveContext_1.ResolveContext(trans.treeChanges().to)\n        .subContext(state.$$state())\n        .resolvePath('LAZY', trans)\n        .then(common_1.noop);\n};\nexports.registerLazyResolveState = function (transitionService) {\n    return transitionService.onEnter({ entering: hof_1.val(true) }, lazyResolveState, { priority: exports.RESOLVE_HOOK_PRIORITY });\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 */\nvar resolveRemaining = function (trans) {\n    return new resolveContext_1.ResolveContext(trans.treeChanges().to).resolvePath('LAZY', trans).then(common_1.noop);\n};\nexports.registerResolveRemaining = function (transitionService) {\n    return transitionService.onFinish({}, resolveRemaining, { priority: exports.RESOLVE_HOOK_PRIORITY });\n};\n//# sourceMappingURL=resolve.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar common_1 = require(\"../common/common\");\n/**\n * A [[TransitionHookFn]] which updates global UI-Router state\n *\n * Registered using `transitionService.onBefore({}, updateGlobalState);`\n *\n * Before a [[Transition]] starts, updates the global value of \"the current transition\" ([[Globals.transition]]).\n * After a successful [[Transition]], updates the global values of \"the current state\"\n * ([[Globals.current]] and [[Globals.$current]]) and \"the current param values\" ([[Globals.params]]).\n *\n * See also the deprecated properties:\n * [[StateService.transition]], [[StateService.current]], [[StateService.params]]\n */\nvar updateGlobalState = function (trans) {\n    var globals = trans.router.globals;\n    var transitionSuccessful = function () {\n        globals.successfulTransitions.enqueue(trans);\n        globals.$current = trans.$to();\n        globals.current = globals.$current.self;\n        common_1.copy(trans.params(), globals.params);\n    };\n    var clearCurrentTransition = function () {\n        // Do not clear globals.transition if a different transition has started in the meantime\n        if (globals.transition === trans)\n            globals.transition = null;\n    };\n    trans.onSuccess({}, transitionSuccessful, { priority: 10000 });\n    trans.promise.then(clearCurrentTransition, clearCurrentTransition);\n};\nexports.registerUpdateGlobalState = function (transitionService) {\n    return transitionService.onCreate({}, updateGlobalState);\n};\n//# sourceMappingURL=updateGlobals.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * A [[TransitionHookFn]] which updates the URL after a successful transition\n *\n * Registered using `transitionService.onSuccess({}, updateUrl);`\n */\nvar updateUrl = function (transition) {\n    var options = transition.options();\n    var $state = transition.router.stateService;\n    var $urlRouter = transition.router.urlRouter;\n    // Dont update the url in these situations:\n    // The transition was triggered by a URL sync (options.source === 'url')\n    // The user doesn't want the url to update (options.location === false)\n    // The destination state, and all parents have no navigable url\n    if (options.source !== 'url' && options.location && $state.$current.navigable) {\n        var urlOptions = { replace: options.location === 'replace' };\n        $urlRouter.push($state.$current.navigable.url, $state.params, urlOptions);\n    }\n    $urlRouter.update(true);\n};\nexports.registerUpdateUrl = function (transitionService) {\n    return transitionService.onSuccess({}, updateUrl, { priority: 9999 });\n};\n//# sourceMappingURL=url.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module hooks */ /** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar coreservices_1 = require(\"../common/coreservices\");\n/**\n * A [[TransitionHookFn]] which waits for the views to load\n *\n * Registered using `transitionService.onStart({}, loadEnteringViews);`\n *\n * Allows the views to do async work in [[ViewConfig.load]] before the transition continues.\n * In angular 1, this includes loading the templates.\n */\nvar loadEnteringViews = function (transition) {\n    var $q = coreservices_1.services.$q;\n    var enteringViews = transition.views('entering');\n    if (!enteringViews.length)\n        return;\n    return $q.all(enteringViews.map(function (view) { return $q.when(view.load()); })).then(common_1.noop);\n};\nexports.registerLoadEnteringViews = function (transitionService) {\n    return transitionService.onFinish({}, loadEnteringViews);\n};\n/**\n * A [[TransitionHookFn]] which activates the new views when a transition is successful.\n *\n * Registered using `transitionService.onSuccess({}, activateViews);`\n *\n * After a transition is complete, this hook deactivates the old views from the previous state,\n * and activates the new views from the destination state.\n *\n * See [[ViewService]]\n */\nvar activateViews = function (transition) {\n    var enteringViews = transition.views('entering');\n    var exitingViews = transition.views('exiting');\n    if (!enteringViews.length && !exitingViews.length)\n        return;\n    var $view = transition.router.viewService;\n    exitingViews.forEach(function (vc) { return $view.deactivateViewConfig(vc); });\n    enteringViews.forEach(function (vc) { return $view.activateViewConfig(vc); });\n    $view.sync();\n};\nexports.registerActivateViews = function (transitionService) {\n    return transitionService.onSuccess({}, activateViews);\n};\n//# sourceMappingURL=views.js.map","\"use strict\";\n/**\n * @coreapi\n * @module common\n */ /** */\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./common/index\"));\n__export(require(\"./params/index\"));\n__export(require(\"./path/index\"));\n__export(require(\"./resolve/index\"));\n__export(require(\"./state/index\"));\n__export(require(\"./transition/index\"));\n__export(require(\"./url/index\"));\n__export(require(\"./view/index\"));\n__export(require(\"./globals\"));\n__export(require(\"./router\"));\n__export(require(\"./vanilla\"));\n__export(require(\"./interface\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\n/**\n * # Core classes and interfaces\n *\n * The classes and interfaces that are core to ui-router and do not belong\n * to a more specific subsystem (such as resolve).\n *\n * @coreapi\n * @preferred\n * @module core\n */ /** for typedoc */\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @internalapi */\nvar UIRouterPluginBase = /** @class */ (function () {\n    function UIRouterPluginBase() {\n    }\n    UIRouterPluginBase.prototype.dispose = function (router) { };\n    return UIRouterPluginBase;\n}());\nexports.UIRouterPluginBase = UIRouterPluginBase;\n//# sourceMappingURL=interface.js.map","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./param\"));\n__export(require(\"./paramTypes\"));\n__export(require(\"./stateParams\"));\n__export(require(\"./paramType\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module params\n */ /** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar hof_1 = require(\"../common/hof\");\nvar predicates_1 = require(\"../common/predicates\");\nvar coreservices_1 = require(\"../common/coreservices\");\nvar paramType_1 = require(\"./paramType\");\n/** @hidden */\nvar hasOwn = Object.prototype.hasOwnProperty;\n/** @hidden */\nvar isShorthand = function (cfg) {\n    return ['value', 'type', 'squash', 'array', 'dynamic'].filter(hasOwn.bind(cfg || {})).length === 0;\n};\n/** @internalapi */\nvar DefType;\n(function (DefType) {\n    DefType[DefType[\"PATH\"] = 0] = \"PATH\";\n    DefType[DefType[\"SEARCH\"] = 1] = \"SEARCH\";\n    DefType[DefType[\"CONFIG\"] = 2] = \"CONFIG\";\n})(DefType = exports.DefType || (exports.DefType = {}));\n/** @hidden */\nfunction unwrapShorthand(cfg) {\n    cfg = (isShorthand(cfg) && { value: cfg }) || cfg;\n    getStaticDefaultValue['__cacheable'] = true;\n    function getStaticDefaultValue() {\n        return cfg.value;\n    }\n    return common_1.extend(cfg, {\n        $$fn: predicates_1.isInjectable(cfg.value) ? cfg.value : getStaticDefaultValue,\n    });\n}\n/** @hidden */\nfunction getType(cfg, urlType, location, id, paramTypes) {\n    if (cfg.type && urlType && urlType.name !== 'string')\n        throw new Error(\"Param '\" + id + \"' has two type configurations.\");\n    if (cfg.type && urlType && urlType.name === 'string' && paramTypes.type(cfg.type))\n        return paramTypes.type(cfg.type);\n    if (urlType)\n        return urlType;\n    if (!cfg.type) {\n        var type = location === DefType.CONFIG\n            ? 'any'\n            : location === DefType.PATH ? 'path' : location === DefType.SEARCH ? 'query' : 'string';\n        return paramTypes.type(type);\n    }\n    return cfg.type instanceof paramType_1.ParamType ? cfg.type : paramTypes.type(cfg.type);\n}\n/**\n * @internalapi\n * returns false, true, or the squash value to indicate the \"default parameter url squash policy\".\n */\nfunction getSquashPolicy(config, isOptional, defaultPolicy) {\n    var squash = config.squash;\n    if (!isOptional || squash === false)\n        return false;\n    if (!predicates_1.isDefined(squash) || squash == null)\n        return defaultPolicy;\n    if (squash === true || predicates_1.isString(squash))\n        return squash;\n    throw new Error(\"Invalid squash policy: '\" + squash + \"'. Valid policies: false, true, or arbitrary string\");\n}\n/** @internalapi */\nfunction getReplace(config, arrayMode, isOptional, squash) {\n    var defaultPolicy = [\n        { from: '', to: isOptional || arrayMode ? undefined : '' },\n        { from: null, to: isOptional || arrayMode ? undefined : '' },\n    ];\n    var replace = predicates_1.isArray(config.replace) ? config.replace : [];\n    if (predicates_1.isString(squash))\n        replace.push({ from: squash, to: undefined });\n    var configuredKeys = common_1.map(replace, hof_1.prop('from'));\n    return common_1.filter(defaultPolicy, function (item) { return configuredKeys.indexOf(item.from) === -1; }).concat(replace);\n}\n/** @internalapi */\nvar Param = /** @class */ (function () {\n    function Param(id, type, config, location, urlMatcherFactory) {\n        config = unwrapShorthand(config);\n        type = getType(config, type, location, id, urlMatcherFactory.paramTypes);\n        var arrayMode = getArrayMode();\n        type = arrayMode ? type.$asArray(arrayMode, location === DefType.SEARCH) : type;\n        var isOptional = config.value !== undefined || location === DefType.SEARCH;\n        var dynamic = predicates_1.isDefined(config.dynamic) ? !!config.dynamic : !!type.dynamic;\n        var raw = predicates_1.isDefined(config.raw) ? !!config.raw : !!type.raw;\n        var squash = getSquashPolicy(config, isOptional, urlMatcherFactory.defaultSquashPolicy());\n        var replace = getReplace(config, arrayMode, isOptional, squash);\n        var inherit = predicates_1.isDefined(config.inherit) ? !!config.inherit : !!type.inherit;\n        // array config: param name (param[]) overrides default settings.  explicit config overrides param name.\n        function getArrayMode() {\n            var arrayDefaults = { array: location === DefType.SEARCH ? 'auto' : false };\n            var arrayParamNomenclature = id.match(/\\[\\]$/) ? { array: true } : {};\n            return common_1.extend(arrayDefaults, arrayParamNomenclature, config).array;\n        }\n        common_1.extend(this, { id: id, type: type, location: location, isOptional: isOptional, dynamic: dynamic, raw: raw, squash: squash, replace: replace, inherit: inherit, array: arrayMode, config: config });\n    }\n    Param.values = function (params, values) {\n        if (values === void 0) { values = {}; }\n        var paramValues = {};\n        for (var _i = 0, params_1 = params; _i < params_1.length; _i++) {\n            var param = params_1[_i];\n            paramValues[param.id] = param.value(values[param.id]);\n        }\n        return paramValues;\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    Param.changed = function (params, values1, values2) {\n        if (values1 === void 0) { values1 = {}; }\n        if (values2 === void 0) { values2 = {}; }\n        return params.filter(function (param) { return !param.type.equals(values1[param.id], values2[param.id]); });\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    Param.equals = function (params, values1, values2) {\n        if (values1 === void 0) { values1 = {}; }\n        if (values2 === void 0) { values2 = {}; }\n        return Param.changed(params, values1, values2).length === 0;\n    };\n    /** Returns true if a the parameter values are valid, according to the Param definitions */\n    Param.validates = function (params, values) {\n        if (values === void 0) { values = {}; }\n        return params.map(function (param) { return param.validates(values[param.id]); }).reduce(common_1.allTrueR, true);\n    };\n    Param.prototype.isDefaultValue = function (value) {\n        return this.isOptional && this.type.equals(this.value(), value);\n    };\n    /**\n     * [Internal] Gets the decoded representation of a value if the value is defined, otherwise, returns the\n     * default value, which may be the result of an injectable function.\n     */\n    Param.prototype.value = function (value) {\n        var _this = this;\n        /**\n         * [Internal] Get the default value of a parameter, which may be an injectable function.\n         */\n        var getDefaultValue = function () {\n            if (_this._defaultValueCache)\n                return _this._defaultValueCache.defaultValue;\n            if (!coreservices_1.services.$injector)\n                throw new Error('Injectable functions cannot be called at configuration time');\n            var defaultValue = coreservices_1.services.$injector.invoke(_this.config.$$fn);\n            if (defaultValue !== null && defaultValue !== undefined && !_this.type.is(defaultValue))\n                throw new Error(\"Default value (\" + defaultValue + \") for parameter '\" + _this.id + \"' is not an instance of ParamType (\" + _this.type.name + \")\");\n            if (_this.config.$$fn['__cacheable']) {\n                _this._defaultValueCache = { defaultValue: defaultValue };\n            }\n            return defaultValue;\n        };\n        var replaceSpecialValues = function (val) {\n            for (var _i = 0, _a = _this.replace; _i < _a.length; _i++) {\n                var tuple = _a[_i];\n                if (tuple.from === val)\n                    return tuple.to;\n            }\n            return val;\n        };\n        value = replaceSpecialValues(value);\n        return predicates_1.isUndefined(value) ? getDefaultValue() : this.type.$normalize(value);\n    };\n    Param.prototype.isSearch = function () {\n        return this.location === DefType.SEARCH;\n    };\n    Param.prototype.validates = function (value) {\n        // There was no parameter value, but the param is optional\n        if ((predicates_1.isUndefined(value) || value === null) && this.isOptional)\n            return true;\n        // The value was not of the correct ParamType, and could not be decoded to the correct ParamType\n        var normalized = this.type.$normalize(value);\n        if (!this.type.is(normalized))\n            return false;\n        // The value was of the correct type, but when encoded, did not match the ParamType's regexp\n        var encoded = this.type.encode(normalized);\n        return !(predicates_1.isString(encoded) && !this.type.pattern.exec(encoded));\n    };\n    Param.prototype.toString = function () {\n        return \"{Param:\" + this.id + \" \" + this.type + \" squash: '\" + this.squash + \"' optional: \" + this.isOptional + \"}\";\n    };\n    return Param;\n}());\nexports.Param = Param;\n//# sourceMappingURL=param.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module params\n */\n/** */\nvar common_1 = require(\"../common/common\");\nvar predicates_1 = require(\"../common/predicates\");\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 */\nvar ParamType = /** @class */ (function () {\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    function ParamType(def) {\n        /** @inheritdoc */\n        this.pattern = /.*/;\n        /** @inheritdoc */\n        this.inherit = true;\n        common_1.extend(this, def);\n    }\n    // consider these four methods to be \"abstract methods\" that should be overridden\n    /** @inheritdoc */\n    ParamType.prototype.is = function (val, key) {\n        return true;\n    };\n    /** @inheritdoc */\n    ParamType.prototype.encode = function (val, key) {\n        return val;\n    };\n    /** @inheritdoc */\n    ParamType.prototype.decode = function (val, key) {\n        return val;\n    };\n    /** @inheritdoc */\n    ParamType.prototype.equals = function (a, b) {\n        // tslint:disable-next-line:triple-equals\n        return a == b;\n    };\n    ParamType.prototype.$subPattern = function () {\n        var sub = this.pattern.toString();\n        return sub.substr(1, sub.length - 2);\n    };\n    ParamType.prototype.toString = function () {\n        return \"{ParamType:\" + this.name + \"}\";\n    };\n    /** Given an encoded string, or a decoded object, returns a decoded object */\n    ParamType.prototype.$normalize = function (val) {\n        return this.is(val) ? val : this.decode(val);\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    ParamType.prototype.$asArray = function (mode, isSearch) {\n        if (!mode)\n            return this;\n        if (mode === 'auto' && !isSearch)\n            throw new Error(\"'auto' array mode is for query parameters only\");\n        return new ArrayType(this, mode);\n    };\n    return ParamType;\n}());\nexports.ParamType = ParamType;\n/**\n * Wraps up a `ParamType` object to handle array values.\n * @internalapi\n */\nfunction ArrayType(type, mode) {\n    var _this = this;\n    // Wrap non-array value as array\n    function arrayWrap(val) {\n        return predicates_1.isArray(val) ? val : predicates_1.isDefined(val) ? [val] : [];\n    }\n    // Unwrap array value for \"auto\" mode. Return undefined for empty array.\n    function arrayUnwrap(val) {\n        switch (val.length) {\n            case 0:\n                return undefined;\n            case 1:\n                return mode === 'auto' ? val[0] : val;\n            default:\n                return val;\n        }\n    }\n    // Wraps type (.is/.encode/.decode) functions to operate on each value of an array\n    function arrayHandler(callback, allTruthyMode) {\n        return function handleArray(val) {\n            if (predicates_1.isArray(val) && val.length === 0)\n                return val;\n            var arr = arrayWrap(val);\n            var result = common_1.map(arr, callback);\n            return allTruthyMode === true ? common_1.filter(result, function (x) { return !x; }).length === 0 : arrayUnwrap(result);\n        };\n    }\n    // Wraps type (.equals) functions to operate on each value of an array\n    function arrayEqualsHandler(callback) {\n        return function handleArray(val1, val2) {\n            var left = arrayWrap(val1), right = arrayWrap(val2);\n            if (left.length !== right.length)\n                return false;\n            for (var i = 0; i < left.length; i++) {\n                if (!callback(left[i], right[i]))\n                    return false;\n            }\n            return true;\n        };\n    }\n    ['encode', 'decode', 'equals', '$normalize'].forEach(function (name) {\n        var paramTypeFn = type[name].bind(type);\n        var wrapperFn = name === 'equals' ? arrayEqualsHandler : arrayHandler;\n        _this[name] = wrapperFn(paramTypeFn);\n    });\n    common_1.extend(this, {\n        dynamic: type.dynamic,\n        name: type.name,\n        pattern: type.pattern,\n        inherit: type.inherit,\n        is: arrayHandler(type.is.bind(type), true),\n        $arrayMode: mode,\n    });\n}\n//# sourceMappingURL=paramType.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module params\n */\n/** */\nvar common_1 = require(\"../common/common\");\nvar predicates_1 = require(\"../common/predicates\");\nvar hof_1 = require(\"../common/hof\");\nvar coreservices_1 = require(\"../common/coreservices\");\nvar paramType_1 = require(\"./paramType\");\n/**\n * A registry for parameter types.\n *\n * This registry manages the built-in (and custom) parameter types.\n *\n * The built-in parameter types are:\n *\n * - [[string]]\n * - [[path]]\n * - [[query]]\n * - [[hash]]\n * - [[int]]\n * - [[bool]]\n * - [[date]]\n * - [[json]]\n * - [[any]]\n */\nvar ParamTypes = /** @class */ (function () {\n    /** @internalapi */\n    function ParamTypes() {\n        /** @hidden */\n        this.enqueue = true;\n        /** @hidden */\n        this.typeQueue = [];\n        /** @internalapi */\n        this.defaultTypes = common_1.pick(ParamTypes.prototype, [\n            'hash',\n            'string',\n            'query',\n            'path',\n            'int',\n            'bool',\n            'date',\n            'json',\n            'any',\n        ]);\n        // Register default types. Store them in the prototype of this.types.\n        var makeType = function (definition, name) { return new paramType_1.ParamType(common_1.extend({ name: name }, definition)); };\n        this.types = common_1.inherit(common_1.map(this.defaultTypes, makeType), {});\n    }\n    /** @internalapi */\n    ParamTypes.prototype.dispose = function () {\n        this.types = {};\n    };\n    /**\n     * Registers a parameter type\n     *\n     * End users should call [[UrlMatcherFactory.type]], which delegates to this method.\n     */\n    ParamTypes.prototype.type = function (name, definition, definitionFn) {\n        if (!predicates_1.isDefined(definition))\n            return this.types[name];\n        if (this.types.hasOwnProperty(name))\n            throw new Error(\"A type named '\" + name + \"' has already been defined.\");\n        this.types[name] = new paramType_1.ParamType(common_1.extend({ name: name }, definition));\n        if (definitionFn) {\n            this.typeQueue.push({ name: name, def: definitionFn });\n            if (!this.enqueue)\n                this._flushTypeQueue();\n        }\n        return this;\n    };\n    /** @internalapi */\n    ParamTypes.prototype._flushTypeQueue = function () {\n        while (this.typeQueue.length) {\n            var type = this.typeQueue.shift();\n            if (type.pattern)\n                throw new Error(\"You cannot override a type's .pattern at runtime.\");\n            common_1.extend(this.types[type.name], coreservices_1.services.$injector.invoke(type.def));\n        }\n    };\n    return ParamTypes;\n}());\nexports.ParamTypes = ParamTypes;\n/** @hidden */\nfunction initDefaultTypes() {\n    var makeDefaultType = function (def) {\n        var valToString = function (val) { return (val != null ? val.toString() : val); };\n        var defaultTypeBase = {\n            encode: valToString,\n            decode: valToString,\n            is: hof_1.is(String),\n            pattern: /.*/,\n            // tslint:disable-next-line:triple-equals\n            equals: function (a, b) { return a == b; },\n        };\n        return common_1.extend({}, defaultTypeBase, def);\n    };\n    // Default Parameter Type Definitions\n    common_1.extend(ParamTypes.prototype, {\n        string: makeDefaultType({}),\n        path: makeDefaultType({\n            pattern: /[^/]*/,\n        }),\n        query: makeDefaultType({}),\n        hash: makeDefaultType({\n            inherit: false,\n        }),\n        int: makeDefaultType({\n            decode: function (val) { return parseInt(val, 10); },\n            is: function (val) {\n                return !predicates_1.isNullOrUndefined(val) && this.decode(val.toString()) === val;\n            },\n            pattern: /-?\\d+/,\n        }),\n        bool: makeDefaultType({\n            encode: function (val) { return (val && 1) || 0; },\n            decode: function (val) { return parseInt(val, 10) !== 0; },\n            is: hof_1.is(Boolean),\n            pattern: /0|1/,\n        }),\n        date: makeDefaultType({\n            encode: function (val) {\n                return !this.is(val)\n                    ? undefined\n                    : [val.getFullYear(), ('0' + (val.getMonth() + 1)).slice(-2), ('0' + val.getDate()).slice(-2)].join('-');\n            },\n            decode: function (val) {\n                if (this.is(val))\n                    return val;\n                var match = this.capture.exec(val);\n                return match ? new Date(match[1], match[2] - 1, match[3]) : undefined;\n            },\n            is: function (val) { return val instanceof Date && !isNaN(val.valueOf()); },\n            equals: function (l, r) {\n                return ['getFullYear', 'getMonth', 'getDate'].reduce(function (acc, fn) { return acc && l[fn]() === r[fn](); }, true);\n            },\n            pattern: /[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[1-2][0-9]|3[0-1])/,\n            capture: /([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])/,\n        }),\n        json: makeDefaultType({\n            encode: common_1.toJson,\n            decode: common_1.fromJson,\n            is: hof_1.is(Object),\n            equals: common_1.equals,\n            pattern: /[^/]*/,\n        }),\n        // does not encode/decode\n        any: makeDefaultType({\n            encode: common_1.identity,\n            decode: common_1.identity,\n            is: function () { return true; },\n            equals: common_1.equals,\n        }),\n    });\n}\ninitDefaultTypes();\n//# sourceMappingURL=paramTypes.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module params\n */\n/** */\nvar common_1 = require(\"../common/common\");\n/** @internalapi */\nvar StateParams = /** @class */ (function () {\n    function StateParams(params) {\n        if (params === void 0) { params = {}; }\n        common_1.extend(this, params);\n    }\n    /**\n     * Merges a set of parameters with all parameters inherited between the common parents of the\n     * current state and a given destination state.\n     *\n     * @param {Object} newParams The set of parameters which will be composited with inherited params.\n     * @param {Object} $current Internal definition of object representing the current state.\n     * @param {Object} $to Internal definition of object representing state to transition to.\n     */\n    StateParams.prototype.$inherit = function (newParams, $current, $to) {\n        var parentParams;\n        var parents = common_1.ancestors($current, $to), inherited = {}, inheritList = [];\n        for (var i in parents) {\n            if (!parents[i] || !parents[i].params)\n                continue;\n            parentParams = Object.keys(parents[i].params);\n            if (!parentParams.length)\n                continue;\n            for (var j in parentParams) {\n                if (inheritList.indexOf(parentParams[j]) >= 0)\n                    continue;\n                inheritList.push(parentParams[j]);\n                inherited[parentParams[j]] = this[parentParams[j]];\n            }\n        }\n        return common_1.extend({}, inherited, newParams);\n    };\n    return StateParams;\n}());\nexports.StateParams = StateParams;\n//# sourceMappingURL=stateParams.js.map","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module path */ /** for typedoc */\n__export(require(\"./pathNode\"));\n__export(require(\"./pathUtils\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module path */ /** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar hof_1 = require(\"../common/hof\");\nvar param_1 = require(\"../params/param\");\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 */\nvar PathNode = /** @class */ (function () {\n    function PathNode(stateOrNode) {\n        if (stateOrNode instanceof PathNode) {\n            var node = stateOrNode;\n            this.state = node.state;\n            this.paramSchema = node.paramSchema.slice();\n            this.paramValues = common_1.extend({}, node.paramValues);\n            this.resolvables = node.resolvables.slice();\n            this.views = node.views && node.views.slice();\n        }\n        else {\n            var state = stateOrNode;\n            this.state = state;\n            this.paramSchema = state.parameters({ inherit: false });\n            this.paramValues = {};\n            this.resolvables = state.resolvables.map(function (res) { return res.clone(); });\n        }\n    }\n    PathNode.prototype.clone = function () {\n        return new PathNode(this);\n    };\n    /** Sets [[paramValues]] for the node, from the values of an object hash */\n    PathNode.prototype.applyRawParams = function (params) {\n        var getParamVal = function (paramDef) { return [paramDef.id, paramDef.value(params[paramDef.id])]; };\n        this.paramValues = this.paramSchema.reduce(function (memo, pDef) { return common_1.applyPairs(memo, getParamVal(pDef)); }, {});\n        return this;\n    };\n    /** Gets a specific [[Param]] metadata that belongs to the node */\n    PathNode.prototype.parameter = function (name) {\n        return common_1.find(this.paramSchema, hof_1.propEq('id', name));\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    PathNode.prototype.equals = function (node, paramsFn) {\n        var diff = this.diff(node, paramsFn);\n        return diff && diff.length === 0;\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    PathNode.prototype.diff = function (node, paramsFn) {\n        if (this.state !== node.state)\n            return false;\n        var params = paramsFn ? paramsFn(this) : this.paramSchema;\n        return param_1.Param.changed(params, this.paramValues, node.paramValues);\n    };\n    /**\n     * Returns a clone of the PathNode\n     * @deprecated use instance method `node.clone()`\n     */\n    PathNode.clone = function (node) { return node.clone(); };\n    return PathNode;\n}());\nexports.PathNode = PathNode;\n//# sourceMappingURL=pathNode.js.map","\"use strict\";\n/** @module path */ /** for typedoc */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar common_1 = require(\"../common/common\");\nvar hof_1 = require(\"../common/hof\");\nvar targetState_1 = require(\"../state/targetState\");\nvar pathNode_1 = require(\"./pathNode\");\n/**\n * This class contains functions which convert TargetStates, Nodes and paths from one type to another.\n */\nvar PathUtils = /** @class */ (function () {\n    function PathUtils() {\n    }\n    /** Given a PathNode[], create an TargetState */\n    PathUtils.makeTargetState = function (registry, path) {\n        var state = common_1.tail(path).state;\n        return new targetState_1.TargetState(registry, state, path.map(hof_1.prop('paramValues')).reduce(common_1.mergeR, {}), {});\n    };\n    PathUtils.buildPath = function (targetState) {\n        var toParams = targetState.params();\n        return targetState.$state().path.map(function (state) { return new pathNode_1.PathNode(state).applyRawParams(toParams); });\n    };\n    /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */\n    PathUtils.buildToPath = function (fromPath, targetState) {\n        var toPath = 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     * 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    PathUtils.applyViewConfigs = function ($view, path, states) {\n        // Only apply the viewConfigs to the nodes for the given states\n        path.filter(function (node) { return common_1.inArray(states, node.state); }).forEach(function (node) {\n            var viewDecls = common_1.values(node.state.views || {});\n            var subPath = PathUtils.subPath(path, function (n) { return n === node; });\n            var viewConfigs = viewDecls.map(function (view) { return $view.createViewConfig(subPath, view); });\n            node.views = viewConfigs.reduce(common_1.unnestR, []);\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    PathUtils.inheritParams = function (fromPath, toPath, toKeys) {\n        if (toKeys === void 0) { toKeys = []; }\n        function nodeParamVals(path, state) {\n            var node = common_1.find(path, hof_1.propEq('state', state));\n            return common_1.extend({}, node && node.paramValues);\n        }\n        var noInherit = fromPath\n            .map(function (node) { return node.paramSchema; })\n            .reduce(common_1.unnestR, [])\n            .filter(function (param) { return !param.inherit; })\n            .map(hof_1.prop('id'));\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) {\n            // All param values for the node (may include default key/vals, when key was not found in toParams)\n            var toParamVals = common_1.extend({}, toNode && toNode.paramValues);\n            // limited to only those keys found in toParams\n            var incomingParamVals = common_1.pick(toParamVals, toKeys);\n            toParamVals = common_1.omit(toParamVals, toKeys);\n            var fromParamVals = common_1.omit(nodeParamVals(fromPath, toNode.state) || {}, noInherit);\n            // extend toParamVals with any fromParamVals, then override any of those those with incomingParamVals\n            var ownParamVals = common_1.extend(toParamVals, fromParamVals, incomingParamVals);\n            return new pathNode_1.PathNode(toNode.state).applyRawParams(ownParamVals);\n        }\n        // The param keys specified by the incoming toParams\n        return toPath.map(makeInheritedParamsNode);\n    };\n    /**\n     * Computes the tree changes (entering, exiting) between a fromPath and toPath.\n     */\n    PathUtils.treeChanges = function (fromPath, toPath, reloadState) {\n        var max = Math.min(fromPath.length, toPath.length);\n        var keep = 0;\n        var nodesMatch = function (node1, node2) { return node1.equals(node2, PathUtils.nonDynamicParams); };\n        while (keep < max && fromPath[keep].state !== reloadState && nodesMatch(fromPath[keep], toPath[keep])) {\n            keep++;\n        }\n        /** Given a retained node, return a new node which uses the to node's param values */\n        function applyToParams(retainedNode, idx) {\n            var cloned = retainedNode.clone();\n            cloned.paramValues = toPath[idx].paramValues;\n            return cloned;\n        }\n        var from, retained, exiting, entering, to;\n        from = fromPath;\n        retained = from.slice(0, keep);\n        exiting = from.slice(keep);\n        // Create a new retained path (with shallow copies of nodes) which have the params of the toPath mapped\n        var retainedWithToParams = retained.map(applyToParams);\n        entering = toPath.slice(keep);\n        to = retainedWithToParams.concat(entering);\n        return { from: from, to: to, retained: retained, retainedWithToParams: retainedWithToParams, exiting: exiting, entering: entering };\n    };\n    /**\n     * Returns a new path which is: the subpath of the first path which matches the second path.\n     *\n     * The new path starts from root and contains any nodes that match the nodes in the second path.\n     * It stops before the first non-matching node.\n     *\n     * Nodes are compared using their state property and their parameter values.\n     * If a `paramsFn` is provided, only the [[Param]] returned by the function will be considered when comparing nodes.\n     *\n     * @param pathA the first path\n     * @param pathB the second path\n     * @param paramsFn a function which returns the parameters to consider when comparing\n     *\n     * @returns an array of PathNodes from the first path which match the nodes in the second path\n     */\n    PathUtils.matching = function (pathA, pathB, paramsFn) {\n        var done = false;\n        var tuples = common_1.arrayTuples(pathA, pathB);\n        return tuples.reduce(function (matching, _a) {\n            var nodeA = _a[0], nodeB = _a[1];\n            done = done || !nodeA.equals(nodeB, paramsFn);\n            return done ? matching : matching.concat(nodeA);\n        }, []);\n    };\n    /**\n     * Returns true if two paths are identical.\n     *\n     * @param pathA\n     * @param pathB\n     * @param paramsFn a function which returns the parameters to consider when comparing\n     * @returns true if the the states and parameter values for both paths are identical\n     */\n    PathUtils.equals = function (pathA, pathB, paramsFn) {\n        return pathA.length === pathB.length && PathUtils.matching(pathA, pathB, paramsFn).length === pathA.length;\n    };\n    /**\n     * Return a subpath of a path, which stops at the first matching node\n     *\n     * Given an array of nodes, returns a subset of the array starting from the first node,\n     * stopping when the first node matches the predicate.\n     *\n     * @param path a path of [[PathNode]]s\n     * @param predicate a [[Predicate]] fn that matches [[PathNode]]s\n     * @returns a subpath up to the matching node, or undefined if no match is found\n     */\n    PathUtils.subPath = function (path, predicate) {\n        var node = common_1.find(path, predicate);\n        var elementIdx = path.indexOf(node);\n        return elementIdx === -1 ? undefined : path.slice(0, elementIdx + 1);\n    };\n    PathUtils.nonDynamicParams = function (node) {\n        return node.state.parameters({ inherit: false }).filter(function (param) { return !param.dynamic; });\n    };\n    /** Gets the raw parameter values from a path */\n    PathUtils.paramValues = function (path) { return path.reduce(function (acc, node) { return common_1.extend(acc, node.paramValues); }, {}); };\n    return PathUtils;\n}());\nexports.PathUtils = PathUtils;\n//# sourceMappingURL=pathUtils.js.map","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module resolve */ /** for typedoc */\n__export(require(\"./interface\"));\n__export(require(\"./resolvable\"));\n__export(require(\"./resolveContext\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @internalapi */\nexports.resolvePolicies = {\n    when: {\n        LAZY: 'LAZY',\n        EAGER: 'EAGER',\n    },\n    async: {\n        WAIT: 'WAIT',\n        NOWAIT: 'NOWAIT',\n        RXWAIT: 'RXWAIT',\n    },\n};\n//# sourceMappingURL=interface.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module resolve\n */ /** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar coreservices_1 = require(\"../common/coreservices\");\nvar trace_1 = require(\"../common/trace\");\nvar strings_1 = require(\"../common/strings\");\nvar predicates_1 = require(\"../common/predicates\");\nvar predicates_2 = require(\"../common/predicates\");\n// TODO: explicitly make this user configurable\nexports.defaultResolvePolicy = {\n    when: 'LAZY',\n    async: 'WAIT',\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 */\nvar Resolvable = /** @class */ (function () {\n    function Resolvable(arg1, resolveFn, deps, policy, data) {\n        this.resolved = false;\n        this.promise = undefined;\n        if (arg1 instanceof Resolvable) {\n            common_1.extend(this, arg1);\n        }\n        else if (predicates_1.isFunction(resolveFn)) {\n            if (predicates_2.isNullOrUndefined(arg1))\n                throw new Error('new Resolvable(): token argument is required');\n            if (!predicates_1.isFunction(resolveFn))\n                throw new Error('new Resolvable(): resolveFn argument must be a function');\n            this.token = arg1;\n            this.policy = policy;\n            this.resolveFn = resolveFn;\n            this.deps = deps || [];\n            this.data = data;\n            this.resolved = data !== undefined;\n            this.promise = this.resolved ? coreservices_1.services.$q.when(this.data) : undefined;\n        }\n        else if (predicates_1.isObject(arg1) && arg1.token && (arg1.hasOwnProperty('resolveFn') || arg1.hasOwnProperty('data'))) {\n            var literal = arg1;\n            return new Resolvable(literal.token, literal.resolveFn, literal.deps, literal.policy, literal.data);\n        }\n    }\n    Resolvable.prototype.getPolicy = function (state) {\n        var thisPolicy = this.policy || {};\n        var statePolicy = (state && state.resolvePolicy) || {};\n        return {\n            when: thisPolicy.when || statePolicy.when || exports.defaultResolvePolicy.when,\n            async: thisPolicy.async || statePolicy.async || exports.defaultResolvePolicy.async,\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    Resolvable.prototype.resolve = function (resolveContext, trans) {\n        var _this = this;\n        var $q = coreservices_1.services.$q;\n        // Gets all dependencies from ResolveContext and wait for them to be resolved\n        var getResolvableDependencies = function () {\n            return $q.all(resolveContext.getDependencies(_this).map(function (resolvable) { return resolvable.get(resolveContext, trans); }));\n        };\n        // Invokes the resolve function passing the resolved dependencies as arguments\n        var invokeResolveFn = function (resolvedDeps) { return _this.resolveFn.apply(null, resolvedDeps); };\n        /**\n         * For RXWAIT policy:\n         *\n         * Given an observable returned from a resolve function:\n         * - enables .cache() mode (this allows multicast subscribers)\n         * - then calls toPromise() (this triggers subscribe() and thus fetches)\n         * - Waits for the promise, then return the cached observable (not the first emitted value).\n         */\n        var waitForRx = function (observable$) {\n            var cached = observable$.cache(1);\n            return cached\n                .take(1)\n                .toPromise()\n                .then(function () { return cached; });\n        };\n        // If the resolve policy is RXWAIT, wait for the observable to emit something. otherwise pass through.\n        var node = resolveContext.findNode(this);\n        var state = node && node.state;\n        var maybeWaitForRx = this.getPolicy(state).async === 'RXWAIT' ? waitForRx : common_1.identity;\n        // After the final value has been resolved, update the state of the Resolvable\n        var applyResolvedValue = function (resolvedValue) {\n            _this.data = resolvedValue;\n            _this.resolved = true;\n            _this.resolveFn = null;\n            trace_1.trace.traceResolvableResolved(_this, trans);\n            return _this.data;\n        };\n        // Sets the promise property first, then getsResolvableDependencies in the context of the promise chain. Always waits one tick.\n        return (this.promise = $q\n            .when()\n            .then(getResolvableDependencies)\n            .then(invokeResolveFn)\n            .then(maybeWaitForRx)\n            .then(applyResolvedValue));\n    };\n    /**\n     * Gets a promise for this Resolvable's data.\n     *\n     * Fetches the data and returns a promise.\n     * Returns the existing promise if it has already been fetched once.\n     */\n    Resolvable.prototype.get = function (resolveContext, trans) {\n        return this.promise || this.resolve(resolveContext, trans);\n    };\n    Resolvable.prototype.toString = function () {\n        return \"Resolvable(token: \" + strings_1.stringify(this.token) + \", requires: [\" + this.deps.map(strings_1.stringify) + \"])\";\n    };\n    Resolvable.prototype.clone = function () {\n        return new Resolvable(this);\n    };\n    Resolvable.fromData = function (token, data) { return new Resolvable(token, function () { return data; }, null, null, data); };\n    return Resolvable;\n}());\nexports.Resolvable = Resolvable;\n//# sourceMappingURL=resolvable.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module resolve */\n/** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar hof_1 = require(\"../common/hof\");\nvar trace_1 = require(\"../common/trace\");\nvar coreservices_1 = require(\"../common/coreservices\");\nvar interface_1 = require(\"./interface\");\nvar resolvable_1 = require(\"./resolvable\");\nvar pathUtils_1 = require(\"../path/pathUtils\");\nvar strings_1 = require(\"../common/strings\");\nvar common_2 = require(\"../common\");\nvar whens = interface_1.resolvePolicies.when;\nvar ALL_WHENS = [whens.EAGER, whens.LAZY];\nvar EAGER_WHENS = [whens.EAGER];\n// tslint:disable-next-line:no-inferrable-types\nexports.NATIVE_INJECTOR_TOKEN = 'Native Injector';\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 */\nvar ResolveContext = /** @class */ (function () {\n    function ResolveContext(_path) {\n        this._path = _path;\n    }\n    /** Gets all the tokens found in the resolve context, de-duplicated */\n    ResolveContext.prototype.getTokens = function () {\n        return this._path.reduce(function (acc, node) { return acc.concat(node.resolvables.map(function (r) { return r.token; })); }, []).reduce(common_1.uniqR, []);\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    ResolveContext.prototype.getResolvable = function (token) {\n        var matching = this._path\n            .map(function (node) { return node.resolvables; })\n            .reduce(common_1.unnestR, [])\n            .filter(function (r) { return r.token === token; });\n        return common_1.tail(matching);\n    };\n    /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */\n    ResolveContext.prototype.getPolicy = function (resolvable) {\n        var node = this.findNode(resolvable);\n        return resolvable.getPolicy(node.state);\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    ResolveContext.prototype.subContext = function (state) {\n        return new ResolveContext(pathUtils_1.PathUtils.subPath(this._path, function (node) { return node.state === state; }));\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    ResolveContext.prototype.addResolvables = function (newResolvables, state) {\n        var node = common_1.find(this._path, hof_1.propEq('state', state));\n        var keys = newResolvables.map(function (r) { return r.token; });\n        node.resolvables = node.resolvables.filter(function (r) { return keys.indexOf(r.token) === -1; }).concat(newResolvables);\n    };\n    /**\n     * Returns a promise for an array of resolved path Element promises\n     *\n     * @param when\n     * @param trans\n     * @returns {Promise<any>|any}\n     */\n    ResolveContext.prototype.resolvePath = function (when, trans) {\n        var _this = this;\n        if (when === void 0) { when = 'LAZY'; }\n        // This option determines which 'when' policy Resolvables we are about to fetch.\n        var whenOption = common_1.inArray(ALL_WHENS, when) ? when : 'LAZY';\n        // If the caller specified EAGER, only the EAGER Resolvables are fetched.\n        // if the caller specified LAZY, both EAGER and LAZY Resolvables are fetched.`\n        var matchedWhens = whenOption === interface_1.resolvePolicies.when.EAGER ? EAGER_WHENS : ALL_WHENS;\n        // get the subpath to the state argument, if provided\n        trace_1.trace.traceResolvePath(this._path, when, trans);\n        var matchesPolicy = function (acceptedVals, whenOrAsync) { return function (resolvable) {\n            return common_1.inArray(acceptedVals, _this.getPolicy(resolvable)[whenOrAsync]);\n        }; };\n        // Trigger all the (matching) Resolvables in the path\n        // Reduce all the \"WAIT\" Resolvables into an array\n        var promises = this._path.reduce(function (acc, node) {\n            var nodeResolvables = node.resolvables.filter(matchesPolicy(matchedWhens, 'when'));\n            var nowait = nodeResolvables.filter(matchesPolicy(['NOWAIT'], 'async'));\n            var wait = nodeResolvables.filter(hof_1.not(matchesPolicy(['NOWAIT'], 'async')));\n            // For the matching Resolvables, start their async fetch process.\n            var subContext = _this.subContext(node.state);\n            var getResult = function (r) {\n                return r\n                    .get(subContext, trans)\n                    // Return a tuple that includes the Resolvable's token\n                    .then(function (value) { return ({ token: r.token, value: value }); });\n            };\n            nowait.forEach(getResult);\n            return acc.concat(wait.map(getResult));\n        }, []);\n        // Wait for all the \"WAIT\" resolvables\n        return coreservices_1.services.$q.all(promises);\n    };\n    ResolveContext.prototype.injector = function () {\n        return this._injector || (this._injector = new UIInjectorImpl(this));\n    };\n    ResolveContext.prototype.findNode = function (resolvable) {\n        return common_1.find(this._path, function (node) { return common_1.inArray(node.resolvables, resolvable); });\n    };\n    /**\n     * Gets the async dependencies of a Resolvable\n     *\n     * Given a Resolvable, returns its dependencies as a Resolvable[]\n     */\n    ResolveContext.prototype.getDependencies = function (resolvable) {\n        var _this = this;\n        var node = this.findNode(resolvable);\n        // Find which other resolvables are \"visible\" to the `resolvable` argument\n        // subpath stopping at resolvable's node, or the whole path (if the resolvable isn't in the path)\n        var subPath = pathUtils_1.PathUtils.subPath(this._path, function (x) { return x === node; }) || this._path;\n        var availableResolvables = subPath\n            .reduce(function (acc, _node) { return acc.concat(_node.resolvables); }, []) // all of subpath's resolvables\n            .filter(function (res) { return res !== resolvable; }); // filter out the `resolvable` argument\n        var getDependency = function (token) {\n            var matching = availableResolvables.filter(function (r) { return r.token === token; });\n            if (matching.length)\n                return common_1.tail(matching);\n            var fromInjector = _this.injector().getNative(token);\n            if (common_2.isUndefined(fromInjector)) {\n                throw new Error('Could not find Dependency Injection token: ' + strings_1.stringify(token));\n            }\n            return new resolvable_1.Resolvable(token, function () { return fromInjector; }, [], fromInjector);\n        };\n        return resolvable.deps.map(getDependency);\n    };\n    return ResolveContext;\n}());\nexports.ResolveContext = ResolveContext;\nvar UIInjectorImpl = /** @class */ (function () {\n    function UIInjectorImpl(context) {\n        this.context = context;\n        this.native = this.get(exports.NATIVE_INJECTOR_TOKEN) || coreservices_1.services.$injector;\n    }\n    UIInjectorImpl.prototype.get = function (token) {\n        var resolvable = this.context.getResolvable(token);\n        if (resolvable) {\n            if (this.context.getPolicy(resolvable).async === 'NOWAIT') {\n                return resolvable.get(this.context);\n            }\n            if (!resolvable.resolved) {\n                throw new Error('Resolvable async .get() not complete:' + strings_1.stringify(resolvable.token));\n            }\n            return resolvable.data;\n        }\n        return this.getNative(token);\n    };\n    UIInjectorImpl.prototype.getAsync = function (token) {\n        var resolvable = this.context.getResolvable(token);\n        if (resolvable)\n            return resolvable.get(this.context);\n        return coreservices_1.services.$q.when(this.native.get(token));\n    };\n    UIInjectorImpl.prototype.getNative = function (token) {\n        return this.native && this.native.get(token);\n    };\n    return UIInjectorImpl;\n}());\n//# sourceMappingURL=resolveContext.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module core\n */ /** */\nvar urlMatcherFactory_1 = require(\"./url/urlMatcherFactory\");\nvar urlRouter_1 = require(\"./url/urlRouter\");\nvar transitionService_1 = require(\"./transition/transitionService\");\nvar view_1 = require(\"./view/view\");\nvar stateRegistry_1 = require(\"./state/stateRegistry\");\nvar stateService_1 = require(\"./state/stateService\");\nvar globals_1 = require(\"./globals\");\nvar common_1 = require(\"./common/common\");\nvar predicates_1 = require(\"./common/predicates\");\nvar urlService_1 = require(\"./url/urlService\");\nvar trace_1 = require(\"./common/trace\");\n/** @hidden */\nvar _routerInstance = 0;\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 */\nvar UIRouter = /** @class */ (function () {\n    /**\n     * Creates a new `UIRouter` object\n     *\n     * @param locationService a [[LocationServices]] implementation\n     * @param locationConfig a [[LocationConfig]] implementation\n     * @internalapi\n     */\n    function UIRouter(locationService, locationConfig) {\n        if (locationService === void 0) { locationService = urlService_1.UrlService.locationServiceStub; }\n        if (locationConfig === void 0) { locationConfig = urlService_1.UrlService.locationConfigStub; }\n        this.locationService = locationService;\n        this.locationConfig = locationConfig;\n        /** @hidden */ this.$id = _routerInstance++;\n        /** @hidden */ this._disposed = false;\n        /** @hidden */ this._disposables = [];\n        /** Provides trace information to the console */\n        this.trace = trace_1.trace;\n        /** Provides services related to ui-view synchronization */\n        this.viewService = new view_1.ViewService();\n        /** Global router state */\n        this.globals = new globals_1.UIRouterGlobals();\n        /** Provides services related to Transitions */\n        this.transitionService = new transitionService_1.TransitionService(this);\n        /**\n         * Deprecated for public use. Use [[urlService]] instead.\n         * @deprecated Use [[urlService]] instead\n         */\n        this.urlMatcherFactory = new urlMatcherFactory_1.UrlMatcherFactory();\n        /**\n         * Deprecated for public use. Use [[urlService]] instead.\n         * @deprecated Use [[urlService]] instead\n         */\n        this.urlRouter = new urlRouter_1.UrlRouter(this);\n        /** Provides a registry for states, and related registration services */\n        this.stateRegistry = new stateRegistry_1.StateRegistry(this);\n        /** Provides services related to states */\n        this.stateService = new stateService_1.StateService(this);\n        /** Provides services related to the URL */\n        this.urlService = new urlService_1.UrlService(this);\n        /** @hidden plugin instances are registered here */\n        this._plugins = {};\n        this.viewService._pluginapi._rootViewContext(this.stateRegistry.root());\n        this.globals.$current = this.stateRegistry.root();\n        this.globals.current = this.globals.$current.self;\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    /** Registers an object to be notified when the router is disposed */\n    UIRouter.prototype.disposable = function (disposable) {\n        this._disposables.push(disposable);\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    UIRouter.prototype.dispose = function (disposable) {\n        var _this = this;\n        if (disposable && predicates_1.isFunction(disposable.dispose)) {\n            disposable.dispose(this);\n            return undefined;\n        }\n        this._disposed = true;\n        this._disposables.slice().forEach(function (d) {\n            try {\n                typeof d.dispose === 'function' && d.dispose(_this);\n                common_1.removeFrom(_this._disposables, d);\n            }\n            catch (ignored) { }\n        });\n    };\n    /**\n     * Adds a plugin to UI-Router\n     *\n     * This method adds a UI-Router Plugin.\n     * A plugin can enhance or change UI-Router behavior using any public API.\n     *\n     * #### Example:\n     * ```js\n     * import { MyCoolPlugin } from \"ui-router-cool-plugin\";\n     *\n     * var plugin = router.addPlugin(MyCoolPlugin);\n     * ```\n     *\n     * ### Plugin authoring\n     *\n     * A plugin is simply a class (or constructor function) which accepts a [[UIRouter]] instance and (optionally) an options object.\n     *\n     * The plugin can implement its functionality using any of the public APIs of [[UIRouter]].\n     * For example, it may configure router options or add a Transition Hook.\n     *\n     * The plugin can then be published as a separate module.\n     *\n     * #### Example:\n     * ```js\n     * export class MyAuthPlugin implements UIRouterPlugin {\n     *   constructor(router: UIRouter, options: any) {\n     *     this.name = \"MyAuthPlugin\";\n     *     let $transitions = router.transitionService;\n     *     let $state = router.stateService;\n     *\n     *     let authCriteria = {\n     *       to: (state) => state.data && state.data.requiresAuth\n     *     };\n     *\n     *     function authHook(transition: Transition) {\n     *       let authService = transition.injector().get('AuthService');\n     *       if (!authService.isAuthenticated()) {\n     *         return $state.target('login');\n     *       }\n     *     }\n     *\n     *     $transitions.onStart(authCriteria, authHook);\n     *   }\n     * }\n     * ```\n     *\n     * @param plugin one of:\n     *        - a plugin class which implements [[UIRouterPlugin]]\n     *        - a constructor function for a [[UIRouterPlugin]] which accepts a [[UIRouter]] instance\n     *        - a factory function which accepts a [[UIRouter]] instance and returns a [[UIRouterPlugin]] instance\n     * @param options options to pass to the plugin class/factory\n     * @returns the registered plugin instance\n     */\n    UIRouter.prototype.plugin = function (plugin, options) {\n        if (options === void 0) { options = {}; }\n        var pluginInstance = new plugin(this, options);\n        if (!pluginInstance.name)\n            throw new Error('Required property `name` missing on plugin: ' + pluginInstance);\n        this._disposables.push(pluginInstance);\n        return (this._plugins[pluginInstance.name] = pluginInstance);\n    };\n    UIRouter.prototype.getPlugin = function (pluginName) {\n        return pluginName ? this._plugins[pluginName] : common_1.values(this._plugins);\n    };\n    return UIRouter;\n}());\nexports.UIRouter = UIRouter;\n//# sourceMappingURL=router.js.map","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./stateBuilder\"));\n__export(require(\"./stateObject\"));\n__export(require(\"./stateMatcher\"));\n__export(require(\"./stateQueueManager\"));\n__export(require(\"./stateRegistry\"));\n__export(require(\"./stateService\"));\n__export(require(\"./targetState\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module state */ /** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar predicates_1 = require(\"../common/predicates\");\nvar strings_1 = require(\"../common/strings\");\nvar hof_1 = require(\"../common/hof\");\nvar resolvable_1 = require(\"../resolve/resolvable\");\nvar coreservices_1 = require(\"../common/coreservices\");\nvar parseUrl = function (url) {\n    if (!predicates_1.isString(url))\n        return false;\n    var root = url.charAt(0) === '^';\n    return { val: root ? url.substring(1) : url, root: root };\n};\nfunction nameBuilder(state) {\n    return state.name;\n}\nfunction selfBuilder(state) {\n    state.self.$$state = function () { return state; };\n    return state.self;\n}\nfunction dataBuilder(state) {\n    if (state.parent && state.parent.data) {\n        state.data = state.self.data = common_1.inherit(state.parent.data, state.data);\n    }\n    return state.data;\n}\nvar getUrlBuilder = function ($urlMatcherFactoryProvider, root) {\n    return function urlBuilder(state) {\n        var stateDec = state;\n        // For future states, i.e., states whose name ends with `.**`,\n        // match anything that starts with the url prefix\n        if (stateDec && stateDec.url && stateDec.name && stateDec.name.match(/\\.\\*\\*$/)) {\n            stateDec.url += '{remainder:any}'; // match any path (.*)\n        }\n        var parsed = parseUrl(stateDec.url), parent = state.parent;\n        var url = !parsed\n            ? stateDec.url\n            : $urlMatcherFactoryProvider.compile(parsed.val, {\n                params: state.params || {},\n                paramMap: function (paramConfig, isSearch) {\n                    if (stateDec.reloadOnSearch === false && isSearch)\n                        paramConfig = common_1.extend(paramConfig || {}, { dynamic: true });\n                    return paramConfig;\n                },\n            });\n        if (!url)\n            return null;\n        if (!$urlMatcherFactoryProvider.isMatcher(url))\n            throw new Error(\"Invalid url '\" + url + \"' in state '\" + state + \"'\");\n        return parsed && parsed.root ? url : ((parent && parent.navigable) || root()).url.append(url);\n    };\n};\nvar getNavigableBuilder = function (isRoot) {\n    return function navigableBuilder(state) {\n        return !isRoot(state) && state.url ? state : state.parent ? state.parent.navigable : null;\n    };\n};\nvar getParamsBuilder = function (paramFactory) {\n    return function paramsBuilder(state) {\n        var makeConfigParam = function (config, id) { return paramFactory.fromConfig(id, null, config); };\n        var urlParams = (state.url && state.url.parameters({ inherit: false })) || [];\n        var nonUrlParams = common_1.values(common_1.mapObj(common_1.omit(state.params || {}, urlParams.map(hof_1.prop('id'))), makeConfigParam));\n        return urlParams\n            .concat(nonUrlParams)\n            .map(function (p) { return [p.id, p]; })\n            .reduce(common_1.applyPairs, {});\n    };\n};\nfunction pathBuilder(state) {\n    return state.parent ? state.parent.path.concat(state) : /*root*/ [state];\n}\nfunction includesBuilder(state) {\n    var includes = state.parent ? common_1.extend({}, state.parent.includes) : {};\n    includes[state.name] = true;\n    return includes;\n}\n/**\n * This is a [[StateBuilder.builder]] function for the `resolve:` block on a [[StateDeclaration]].\n *\n * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder\n * validates the `resolve` property and converts it to a [[Resolvable]] array.\n *\n * resolve: input value can be:\n *\n * {\n *   // analyzed but not injected\n *   myFooResolve: function() { return \"myFooData\"; },\n *\n *   // function.toString() parsed, \"DependencyName\" dep as string (not min-safe)\n *   myBarResolve: function(DependencyName) { return DependencyName.fetchSomethingAsPromise() },\n *\n *   // Array split; \"DependencyName\" dep as string\n *   myBazResolve: [ \"DependencyName\", function(dep) { return dep.fetchSomethingAsPromise() },\n *\n *   // Array split; DependencyType dep as token (compared using ===)\n *   myQuxResolve: [ DependencyType, function(dep) { return dep.fetchSometingAsPromise() },\n *\n *   // val.$inject used as deps\n *   // where:\n *   //     corgeResolve.$inject = [\"DependencyName\"];\n *   //     function corgeResolve(dep) { dep.fetchSometingAsPromise() }\n *   // then \"DependencyName\" dep as string\n *   myCorgeResolve: corgeResolve,\n *\n *  // inject service by name\n *  // When a string is found, desugar creating a resolve that injects the named service\n *   myGraultResolve: \"SomeService\"\n * }\n *\n * or:\n *\n * [\n *   new Resolvable(\"myFooResolve\", function() { return \"myFooData\" }),\n *   new Resolvable(\"myBarResolve\", function(dep) { return dep.fetchSomethingAsPromise() }, [ \"DependencyName\" ]),\n *   { provide: \"myBazResolve\", useFactory: function(dep) { dep.fetchSomethingAsPromise() }, deps: [ \"DependencyName\" ] }\n * ]\n */\nfunction resolvablesBuilder(state) {\n    /** convert resolve: {} and resolvePolicy: {} objects to an array of tuples */\n    var objects2Tuples = function (resolveObj, resolvePolicies) {\n        return Object.keys(resolveObj || {}).map(function (token) { return ({\n            token: token,\n            val: resolveObj[token],\n            deps: undefined,\n            policy: resolvePolicies[token],\n        }); });\n    };\n    /** fetch DI annotations from a function or ng1-style array */\n    var annotate = function (fn) {\n        var $injector = coreservices_1.services.$injector;\n        // ng1 doesn't have an $injector until runtime.\n        // If the $injector doesn't exist, use \"deferred\" literal as a\n        // marker indicating they should be annotated when runtime starts\n        return fn['$inject'] || ($injector && $injector.annotate(fn, $injector.strictDi)) || 'deferred';\n    };\n    /** true if the object has both `token` and `resolveFn`, and is probably a [[ResolveLiteral]] */\n    var isResolveLiteral = function (obj) { return !!(obj.token && obj.resolveFn); };\n    /** true if the object looks like a provide literal, or a ng2 Provider */\n    var isLikeNg2Provider = function (obj) {\n        return !!((obj.provide || obj.token) && (obj.useValue || obj.useFactory || obj.useExisting || obj.useClass));\n    };\n    /** true if the object looks like a tuple from obj2Tuples */\n    var isTupleFromObj = function (obj) {\n        return !!(obj && obj.val && (predicates_1.isString(obj.val) || predicates_1.isArray(obj.val) || predicates_1.isFunction(obj.val)));\n    };\n    /** extracts the token from a Provider or provide literal */\n    var getToken = function (p) { return p.provide || p.token; };\n    /** Given a literal resolve or provider object, returns a Resolvable */\n    var literal2Resolvable = hof_1.pattern([\n        [hof_1.prop('resolveFn'), function (p) { return new resolvable_1.Resolvable(getToken(p), p.resolveFn, p.deps, p.policy); }],\n        [hof_1.prop('useFactory'), function (p) { return new resolvable_1.Resolvable(getToken(p), p.useFactory, p.deps || p.dependencies, p.policy); }],\n        [hof_1.prop('useClass'), function (p) { return new resolvable_1.Resolvable(getToken(p), function () { return new p.useClass(); }, [], p.policy); }],\n        [hof_1.prop('useValue'), function (p) { return new resolvable_1.Resolvable(getToken(p), function () { return p.useValue; }, [], p.policy, p.useValue); }],\n        [hof_1.prop('useExisting'), function (p) { return new resolvable_1.Resolvable(getToken(p), common_1.identity, [p.useExisting], p.policy); }],\n    ]);\n    var tuple2Resolvable = hof_1.pattern([\n        [hof_1.pipe(hof_1.prop('val'), predicates_1.isString), function (tuple) { return new resolvable_1.Resolvable(tuple.token, common_1.identity, [tuple.val], tuple.policy); }],\n        [\n            hof_1.pipe(hof_1.prop('val'), predicates_1.isArray),\n            function (tuple) { return new resolvable_1.Resolvable(tuple.token, common_1.tail(tuple.val), tuple.val.slice(0, -1), tuple.policy); },\n        ],\n        [\n            hof_1.pipe(hof_1.prop('val'), predicates_1.isFunction),\n            function (tuple) { return new resolvable_1.Resolvable(tuple.token, tuple.val, annotate(tuple.val), tuple.policy); },\n        ],\n    ]);\n    var item2Resolvable = hof_1.pattern([\n        [hof_1.is(resolvable_1.Resolvable), function (r) { return r; }],\n        [isResolveLiteral, literal2Resolvable],\n        [isLikeNg2Provider, literal2Resolvable],\n        [isTupleFromObj, tuple2Resolvable],\n        [\n            hof_1.val(true),\n            function (obj) {\n                throw new Error('Invalid resolve value: ' + strings_1.stringify(obj));\n            },\n        ],\n    ]);\n    // If resolveBlock is already an array, use it as-is.\n    // Otherwise, assume it's an object and convert to an Array of tuples\n    var decl = state.resolve;\n    var items = predicates_1.isArray(decl) ? decl : objects2Tuples(decl, state.resolvePolicy || {});\n    return items.map(item2Resolvable);\n}\nexports.resolvablesBuilder = resolvablesBuilder;\n/**\n * @internalapi A internal global service\n *\n * StateBuilder is a factory for the internal [[StateObject]] objects.\n *\n * When you register a state with the [[StateRegistry]], you register a plain old javascript object which\n * conforms to the [[StateDeclaration]] interface.  This factory takes that object and builds the corresponding\n * [[StateObject]] object, which has an API and is used internally.\n *\n * Custom properties or API may be added to the internal [[StateObject]] object by registering a decorator function\n * using the [[builder]] method.\n */\nvar StateBuilder = /** @class */ (function () {\n    function StateBuilder(matcher, urlMatcherFactory) {\n        this.matcher = matcher;\n        var self = this;\n        var root = function () { return matcher.find(''); };\n        var isRoot = function (state) { return state.name === ''; };\n        function parentBuilder(state) {\n            if (isRoot(state))\n                return null;\n            return matcher.find(self.parentName(state)) || root();\n        }\n        this.builders = {\n            name: [nameBuilder],\n            self: [selfBuilder],\n            parent: [parentBuilder],\n            data: [dataBuilder],\n            // Build a URLMatcher if necessary, either via a relative or absolute URL\n            url: [getUrlBuilder(urlMatcherFactory, root)],\n            // Keep track of the closest ancestor state that has a URL (i.e. is navigable)\n            navigable: [getNavigableBuilder(isRoot)],\n            params: [getParamsBuilder(urlMatcherFactory.paramFactory)],\n            // Each framework-specific ui-router implementation should define its own `views` builder\n            // e.g., src/ng1/statebuilders/views.ts\n            views: [],\n            // Keep a full path from the root down to this state as this is needed for state activation.\n            path: [pathBuilder],\n            // Speed up $state.includes() as it's used a lot\n            includes: [includesBuilder],\n            resolvables: [resolvablesBuilder],\n        };\n    }\n    /**\n     * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).\n     * More than one BuilderFunction can be registered for a given property.\n     *\n     * The BuilderFunction(s) will be used to define the property on any subsequently built [[StateObject]] objects.\n     *\n     * @param name The name of the State property being registered for.\n     * @param fn The BuilderFunction which will be used to build the State property\n     * @returns a function which deregisters the BuilderFunction\n     */\n    StateBuilder.prototype.builder = function (name, fn) {\n        var builders = this.builders;\n        var array = builders[name] || [];\n        // Backwards compat: if only one builder exists, return it, else return whole arary.\n        if (predicates_1.isString(name) && !predicates_1.isDefined(fn))\n            return array.length > 1 ? array : array[0];\n        if (!predicates_1.isString(name) || !predicates_1.isFunction(fn))\n            return;\n        builders[name] = array;\n        builders[name].push(fn);\n        return function () { return builders[name].splice(builders[name].indexOf(fn, 1)) && null; };\n    };\n    /**\n     * Builds all of the properties on an essentially blank State object, returning a State object which has all its\n     * properties and API built.\n     *\n     * @param state an uninitialized State object\n     * @returns the built State object\n     */\n    StateBuilder.prototype.build = function (state) {\n        var _a = this, matcher = _a.matcher, builders = _a.builders;\n        var parent = this.parentName(state);\n        if (parent && !matcher.find(parent, undefined, false)) {\n            return null;\n        }\n        for (var key in builders) {\n            if (!builders.hasOwnProperty(key))\n                continue;\n            var chain = builders[key].reduce(function (parentFn, step) { return function (_state) { return step(_state, parentFn); }; }, common_1.noop);\n            state[key] = chain(state);\n        }\n        return state;\n    };\n    StateBuilder.prototype.parentName = function (state) {\n        // name = 'foo.bar.baz.**'\n        var name = state.name || '';\n        // segments = ['foo', 'bar', 'baz', '.**']\n        var segments = name.split('.');\n        // segments = ['foo', 'bar', 'baz']\n        var lastSegment = segments.pop();\n        // segments = ['foo', 'bar'] (ignore .** segment for future states)\n        if (lastSegment === '**')\n            segments.pop();\n        if (segments.length) {\n            if (state.parent) {\n                throw new Error(\"States that specify the 'parent:' property should not have a '.' in their name (\" + name + \")\");\n            }\n            // 'foo.bar'\n            return segments.join('.');\n        }\n        if (!state.parent)\n            return '';\n        return predicates_1.isString(state.parent) ? state.parent : state.parent.name;\n    };\n    StateBuilder.prototype.name = function (state) {\n        var name = state.name;\n        if (name.indexOf('.') !== -1 || !state.parent)\n            return name;\n        var parentName = predicates_1.isString(state.parent) ? state.parent : state.parent.name;\n        return parentName ? parentName + '.' + name : name;\n    };\n    return StateBuilder;\n}());\nexports.StateBuilder = StateBuilder;\n//# sourceMappingURL=stateBuilder.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module state */ /** for typedoc */\nvar predicates_1 = require(\"../common/predicates\");\nvar common_1 = require(\"../common/common\");\nvar StateMatcher = /** @class */ (function () {\n    function StateMatcher(_states) {\n        this._states = _states;\n    }\n    StateMatcher.prototype.isRelative = function (stateName) {\n        stateName = stateName || '';\n        return stateName.indexOf('.') === 0 || stateName.indexOf('^') === 0;\n    };\n    StateMatcher.prototype.find = function (stateOrName, base, matchGlob) {\n        if (matchGlob === void 0) { matchGlob = true; }\n        if (!stateOrName && stateOrName !== '')\n            return undefined;\n        var isStr = predicates_1.isString(stateOrName);\n        var name = isStr ? stateOrName : stateOrName.name;\n        if (this.isRelative(name))\n            name = this.resolvePath(name, base);\n        var state = this._states[name];\n        if (state && (isStr || (!isStr && (state === stateOrName || state.self === stateOrName)))) {\n            return state;\n        }\n        else if (isStr && matchGlob) {\n            var _states = common_1.values(this._states);\n            var matches = _states.filter(function (_state) { return _state.__stateObjectCache.nameGlob && _state.__stateObjectCache.nameGlob.matches(name); });\n            if (matches.length > 1) {\n                // tslint:disable-next-line:no-console\n                console.log(\"stateMatcher.find: Found multiple matches for \" + name + \" using glob: \", matches.map(function (match) { return match.name; }));\n            }\n            return matches[0];\n        }\n        return undefined;\n    };\n    StateMatcher.prototype.resolvePath = function (name, base) {\n        if (!base)\n            throw new Error(\"No reference point given for path '\" + name + \"'\");\n        var baseState = this.find(base);\n        var splitName = name.split('.');\n        var pathLength = splitName.length;\n        var i = 0, current = baseState;\n        for (; i < pathLength; i++) {\n            if (splitName[i] === '' && i === 0) {\n                current = baseState;\n                continue;\n            }\n            if (splitName[i] === '^') {\n                if (!current.parent)\n                    throw new Error(\"Path '\" + name + \"' not valid for state '\" + baseState.name + \"'\");\n                current = current.parent;\n                continue;\n            }\n            break;\n        }\n        var relName = splitName.slice(i).join('.');\n        return current.name + (current.name && relName ? '.' : '') + relName;\n    };\n    return StateMatcher;\n}());\nexports.StateMatcher = StateMatcher;\n//# sourceMappingURL=stateMatcher.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar common_1 = require(\"../common/common\");\nvar hof_1 = require(\"../common/hof\");\nvar glob_1 = require(\"../common/glob\");\nvar predicates_1 = require(\"../common/predicates\");\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 */\nvar StateObject = /** @class */ (function () {\n    /** @deprecated use State.create() */\n    function StateObject(config) {\n        return StateObject.create(config || {});\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    StateObject.create = function (stateDecl) {\n        stateDecl = StateObject.isStateClass(stateDecl) ? new stateDecl() : stateDecl;\n        var state = common_1.inherit(common_1.inherit(stateDecl, StateObject.prototype));\n        stateDecl.$$state = function () { return state; };\n        state.self = stateDecl;\n        state.__stateObjectCache = {\n            nameGlob: glob_1.Glob.fromString(state.name),\n        };\n        return state;\n    };\n    /**\n     * Returns true if the provided parameter is the same state.\n     *\n     * Compares the identity of the state against the passed value, which is either an object\n     * reference to the actual `State` instance, the original definition object passed to\n     * `$stateProvider.state()`, or the fully-qualified name.\n     *\n     * @param ref Can be one of (a) a `State` instance, (b) an object that was passed\n     *        into `$stateProvider.state()`, (c) the fully-qualified name of a state as a string.\n     * @returns Returns `true` if `ref` matches the current `State` instance.\n     */\n    StateObject.prototype.is = function (ref) {\n        return this === ref || this.self === ref || this.fqn() === ref;\n    };\n    /**\n     * @deprecated this does not properly handle dot notation\n     * @returns Returns a dot-separated name of the state.\n     */\n    StateObject.prototype.fqn = function () {\n        if (!this.parent || !(this.parent instanceof this.constructor))\n            return this.name;\n        var name = this.parent.fqn();\n        return name ? name + '.' + this.name : this.name;\n    };\n    /**\n     * Returns the root node of this state's tree.\n     *\n     * @returns The root of this state's tree.\n     */\n    StateObject.prototype.root = function () {\n        return (this.parent && this.parent.root()) || this;\n    };\n    /**\n     * Gets the state's `Param` objects\n     *\n     * Gets the list of [[Param]] objects owned by the state.\n     * If `opts.inherit` is true, it also includes the ancestor states' [[Param]] objects.\n     * If `opts.matchingKeys` exists, returns only `Param`s whose `id` is a key on the `matchingKeys` object\n     *\n     * @param opts options\n     */\n    StateObject.prototype.parameters = function (opts) {\n        opts = common_1.defaults(opts, { inherit: true, matchingKeys: null });\n        var inherited = (opts.inherit && this.parent && this.parent.parameters()) || [];\n        return inherited\n            .concat(common_1.values(this.params))\n            .filter(function (param) { return !opts.matchingKeys || opts.matchingKeys.hasOwnProperty(param.id); });\n    };\n    /**\n     * Returns a single [[Param]] that is owned by the state\n     *\n     * If `opts.inherit` is true, it also searches the ancestor states` [[Param]]s.\n     * @param id the name of the [[Param]] to return\n     * @param opts options\n     */\n    StateObject.prototype.parameter = function (id, opts) {\n        if (opts === void 0) { opts = {}; }\n        return ((this.url && this.url.parameter(id, opts)) ||\n            common_1.find(common_1.values(this.params), hof_1.propEq('id', id)) ||\n            (opts.inherit && this.parent && this.parent.parameter(id)));\n    };\n    StateObject.prototype.toString = function () {\n        return this.fqn();\n    };\n    /** Predicate which returns true if the object is an class with @State() decorator */\n    StateObject.isStateClass = function (stateDecl) {\n        return predicates_1.isFunction(stateDecl) && stateDecl['__uiRouterState'] === true;\n    };\n    /** Predicate which returns true if the object is an internal [[StateObject]] object */\n    StateObject.isState = function (obj) { return predicates_1.isObject(obj['__stateObjectCache']); };\n    return StateObject;\n}());\nexports.StateObject = StateObject;\n//# sourceMappingURL=stateObject.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @module state */ /** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar predicates_1 = require(\"../common/predicates\");\nvar stateObject_1 = require(\"./stateObject\");\nvar hof_1 = require(\"../common/hof\");\n/** @internalapi */\nvar StateQueueManager = /** @class */ (function () {\n    function StateQueueManager($registry, $urlRouter, states, builder, listeners) {\n        this.$registry = $registry;\n        this.$urlRouter = $urlRouter;\n        this.states = states;\n        this.builder = builder;\n        this.listeners = listeners;\n        this.queue = [];\n        this.matcher = $registry.matcher;\n    }\n    /** @internalapi */\n    StateQueueManager.prototype.dispose = function () {\n        this.queue = [];\n    };\n    StateQueueManager.prototype.register = function (stateDecl) {\n        var queue = this.queue;\n        var state = stateObject_1.StateObject.create(stateDecl);\n        var name = state.name;\n        if (!predicates_1.isString(name))\n            throw new Error('State must have a valid name');\n        if (this.states.hasOwnProperty(name) || common_1.inArray(queue.map(hof_1.prop('name')), name))\n            throw new Error(\"State '\" + name + \"' is already defined\");\n        queue.push(state);\n        this.flush();\n        return state;\n    };\n    StateQueueManager.prototype.flush = function () {\n        var _this = this;\n        var _a = this, queue = _a.queue, states = _a.states, builder = _a.builder;\n        var registered = [], // states that got registered\n        orphans = [], // states that don't yet have a parent registered\n        previousQueueLength = {}; // keep track of how long the queue when an orphan was first encountered\n        var getState = function (name) { return _this.states.hasOwnProperty(name) && _this.states[name]; };\n        var notifyListeners = function () {\n            if (registered.length) {\n                _this.listeners.forEach(function (listener) { return listener('registered', registered.map(function (s) { return s.self; })); });\n            }\n        };\n        while (queue.length > 0) {\n            var state = queue.shift();\n            var name_1 = state.name;\n            var result = builder.build(state);\n            var orphanIdx = orphans.indexOf(state);\n            if (result) {\n                var existingState = getState(name_1);\n                if (existingState && existingState.name === name_1) {\n                    throw new Error(\"State '\" + name_1 + \"' is already defined\");\n                }\n                var existingFutureState = getState(name_1 + '.**');\n                if (existingFutureState) {\n                    // Remove future state of the same name\n                    this.$registry.deregister(existingFutureState);\n                }\n                states[name_1] = state;\n                this.attachRoute(state);\n                if (orphanIdx >= 0)\n                    orphans.splice(orphanIdx, 1);\n                registered.push(state);\n                continue;\n            }\n            var prev = previousQueueLength[name_1];\n            previousQueueLength[name_1] = queue.length;\n            if (orphanIdx >= 0 && prev === queue.length) {\n                // Wait until two consecutive iterations where no additional states were dequeued successfully.\n                // throw new Error(`Cannot register orphaned state '${name}'`);\n                queue.push(state);\n                notifyListeners();\n                return states;\n            }\n            else if (orphanIdx < 0) {\n                orphans.push(state);\n            }\n            queue.push(state);\n        }\n        notifyListeners();\n        return states;\n    };\n    StateQueueManager.prototype.attachRoute = function (state) {\n        if (state.abstract || !state.url)\n            return;\n        this.$urlRouter.rule(this.$urlRouter.urlRuleFactory.create(state));\n    };\n    return StateQueueManager;\n}());\nexports.StateQueueManager = StateQueueManager;\n//# sourceMappingURL=stateQueueManager.js.map","\"use strict\";\n/**\n * @coreapi\n * @module state\n */ /** for typedoc */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar stateMatcher_1 = require(\"./stateMatcher\");\nvar stateBuilder_1 = require(\"./stateBuilder\");\nvar stateQueueManager_1 = require(\"./stateQueueManager\");\nvar common_1 = require(\"../common/common\");\nvar hof_1 = require(\"../common/hof\");\nvar StateRegistry = /** @class */ (function () {\n    /** @internalapi */\n    function StateRegistry(_router) {\n        this._router = _router;\n        this.states = {};\n        this.listeners = [];\n        this.matcher = new stateMatcher_1.StateMatcher(this.states);\n        this.builder = new stateBuilder_1.StateBuilder(this.matcher, _router.urlMatcherFactory);\n        this.stateQueue = new stateQueueManager_1.StateQueueManager(this, _router.urlRouter, this.states, this.builder, this.listeners);\n        this._registerRoot();\n    }\n    /** @internalapi */\n    StateRegistry.prototype._registerRoot = function () {\n        var rootStateDef = {\n            name: '',\n            url: '^',\n            views: null,\n            params: {\n                '#': { value: null, type: 'hash', dynamic: true },\n            },\n            abstract: true,\n        };\n        var _root = (this._root = this.stateQueue.register(rootStateDef));\n        _root.navigable = null;\n    };\n    /** @internalapi */\n    StateRegistry.prototype.dispose = function () {\n        var _this = this;\n        this.stateQueue.dispose();\n        this.listeners = [];\n        this.get().forEach(function (state) { return _this.get(state) && _this.deregister(state); });\n    };\n    /**\n     * Listen for a State Registry events\n     *\n     * Adds a callback that is invoked when states are registered or deregistered with the StateRegistry.\n     *\n     * #### Example:\n     * ```js\n     * let allStates = registry.get();\n     *\n     * // Later, invoke deregisterFn() to remove the listener\n     * let deregisterFn = registry.onStatesChanged((event, states) => {\n     *   switch(event) {\n     *     case: 'registered':\n     *       states.forEach(state => allStates.push(state));\n     *       break;\n     *     case: 'deregistered':\n     *       states.forEach(state => {\n     *         let idx = allStates.indexOf(state);\n     *         if (idx !== -1) allStates.splice(idx, 1);\n     *       });\n     *       break;\n     *   }\n     * });\n     * ```\n     *\n     * @param listener a callback function invoked when the registered states changes.\n     *        The function receives two parameters, `event` and `state`.\n     *        See [[StateRegistryListener]]\n     * @return a function that deregisters the listener\n     */\n    StateRegistry.prototype.onStatesChanged = function (listener) {\n        this.listeners.push(listener);\n        return function deregisterListener() {\n            common_1.removeFrom(this.listeners)(listener);\n        }.bind(this);\n    };\n    /**\n     * Gets the implicit root state\n     *\n     * Gets the root of the state tree.\n     * The root state is implicitly created by UI-Router.\n     * Note: this returns the internal [[StateObject]] representation, not a [[StateDeclaration]]\n     *\n     * @return the root [[StateObject]]\n     */\n    StateRegistry.prototype.root = function () {\n        return this._root;\n    };\n    /**\n     * Adds a state to the registry\n     *\n     * Registers a [[StateDeclaration]] or queues it for registration.\n     *\n     * Note: a state will be queued if the state's parent isn't yet registered.\n     *\n     * @param stateDefinition the definition of the state to register.\n     * @returns the internal [[StateObject]] object.\n     *          If the state was successfully registered, then the object is fully built (See: [[StateBuilder]]).\n     *          If the state was only queued, then the object is not fully built.\n     */\n    StateRegistry.prototype.register = function (stateDefinition) {\n        return this.stateQueue.register(stateDefinition);\n    };\n    /** @hidden */\n    StateRegistry.prototype._deregisterTree = function (state) {\n        var _this = this;\n        var all = this.get().map(function (s) { return s.$$state(); });\n        var getChildren = function (states) {\n            var _children = all.filter(function (s) { return states.indexOf(s.parent) !== -1; });\n            return _children.length === 0 ? _children : _children.concat(getChildren(_children));\n        };\n        var children = getChildren([state]);\n        var deregistered = [state].concat(children).reverse();\n        deregistered.forEach(function (_state) {\n            var $ur = _this._router.urlRouter;\n            // Remove URL rule\n            $ur\n                .rules()\n                .filter(hof_1.propEq('state', _state))\n                .forEach($ur.removeRule.bind($ur));\n            // Remove state from registry\n            delete _this.states[_state.name];\n        });\n        return deregistered;\n    };\n    /**\n     * Removes a state from the registry\n     *\n     * This removes a state from the registry.\n     * If the state has children, they are are also removed from the registry.\n     *\n     * @param stateOrName the state's name or object representation\n     * @returns {StateObject[]} a list of removed states\n     */\n    StateRegistry.prototype.deregister = function (stateOrName) {\n        var _state = this.get(stateOrName);\n        if (!_state)\n            throw new Error(\"Can't deregister state; not found: \" + stateOrName);\n        var deregisteredStates = this._deregisterTree(_state.$$state());\n        this.listeners.forEach(function (listener) { return listener('deregistered', deregisteredStates.map(function (s) { return s.self; })); });\n        return deregisteredStates;\n    };\n    StateRegistry.prototype.get = function (stateOrName, base) {\n        var _this = this;\n        if (arguments.length === 0)\n            return Object.keys(this.states).map(function (name) { return _this.states[name].self; });\n        var found = this.matcher.find(stateOrName, base);\n        return (found && found.self) || null;\n    };\n    StateRegistry.prototype.decorator = function (name, func) {\n        return this.builder.builder(name, func);\n    };\n    return StateRegistry;\n}());\nexports.StateRegistry = StateRegistry;\n//# sourceMappingURL=stateRegistry.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module state\n */\n/** */\nvar common_1 = require(\"../common/common\");\nvar predicates_1 = require(\"../common/predicates\");\nvar queue_1 = require(\"../common/queue\");\nvar coreservices_1 = require(\"../common/coreservices\");\nvar pathUtils_1 = require(\"../path/pathUtils\");\nvar pathNode_1 = require(\"../path/pathNode\");\nvar transitionService_1 = require(\"../transition/transitionService\");\nvar rejectFactory_1 = require(\"../transition/rejectFactory\");\nvar targetState_1 = require(\"./targetState\");\nvar param_1 = require(\"../params/param\");\nvar glob_1 = require(\"../common/glob\");\nvar resolveContext_1 = require(\"../resolve/resolveContext\");\nvar lazyLoad_1 = require(\"../hooks/lazyLoad\");\nvar hof_1 = require(\"../common/hof\");\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 */\nvar StateService = /** @class */ (function () {\n    /** @internalapi */\n    function StateService(router) {\n        this.router = router;\n        /** @internalapi */\n        this.invalidCallbacks = [];\n        /** @hidden */\n        this._defaultErrorHandler = function $defaultErrorHandler($error$) {\n            if ($error$ instanceof Error && $error$.stack) {\n                console.error($error$);\n                console.error($error$.stack);\n            }\n            else if ($error$ instanceof rejectFactory_1.Rejection) {\n                console.error($error$.toString());\n                if ($error$.detail && $error$.detail.stack)\n                    console.error($error$.detail.stack);\n            }\n            else {\n                console.error($error$);\n            }\n        };\n        var getters = ['current', '$current', 'params', 'transition'];\n        var boundFns = Object.keys(StateService.prototype).filter(hof_1.not(common_1.inArray(getters)));\n        common_1.createProxyFunctions(hof_1.val(StateService.prototype), this, hof_1.val(this), boundFns);\n    }\n    Object.defineProperty(StateService.prototype, \"transition\", {\n        /**\n         * The [[Transition]] currently in progress (or null)\n         *\n         * This is a passthrough through to [[UIRouterGlobals.transition]]\n         */\n        get: function () {\n            return this.router.globals.transition;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(StateService.prototype, \"params\", {\n        /**\n         * The latest successful state parameters\n         *\n         * This is a passthrough through to [[UIRouterGlobals.params]]\n         */\n        get: function () {\n            return this.router.globals.params;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(StateService.prototype, \"current\", {\n        /**\n         * The current [[StateDeclaration]]\n         *\n         * This is a passthrough through to [[UIRouterGlobals.current]]\n         */\n        get: function () {\n            return this.router.globals.current;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(StateService.prototype, \"$current\", {\n        /**\n         * The current [[StateObject]]\n         *\n         * This is a passthrough through to [[UIRouterGlobals.$current]]\n         */\n        get: function () {\n            return this.router.globals.$current;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /** @internalapi */\n    StateService.prototype.dispose = function () {\n        this.defaultErrorHandler(common_1.noop);\n        this.invalidCallbacks = [];\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    StateService.prototype._handleInvalidTargetState = function (fromPath, toState) {\n        var _this = this;\n        var fromState = pathUtils_1.PathUtils.makeTargetState(this.router.stateRegistry, fromPath);\n        var globals = this.router.globals;\n        var latestThing = function () { return globals.transitionHistory.peekTail(); };\n        var latest = latestThing();\n        var callbackQueue = new queue_1.Queue(this.invalidCallbacks.slice());\n        var injector = new resolveContext_1.ResolveContext(fromPath).injector();\n        var checkForRedirect = function (result) {\n            if (!(result instanceof targetState_1.TargetState)) {\n                return;\n            }\n            var target = result;\n            // Recreate the TargetState, in case the state is now defined.\n            target = _this.target(target.identifier(), target.params(), target.options());\n            if (!target.valid()) {\n                return rejectFactory_1.Rejection.invalid(target.error()).toPromise();\n            }\n            if (latestThing() !== latest) {\n                return rejectFactory_1.Rejection.superseded().toPromise();\n            }\n            return _this.transitionTo(target.identifier(), target.params(), target.options());\n        };\n        function invokeNextCallback() {\n            var nextCallback = callbackQueue.dequeue();\n            if (nextCallback === undefined)\n                return rejectFactory_1.Rejection.invalid(toState.error()).toPromise();\n            var callbackResult = coreservices_1.services.$q.when(nextCallback(toState, fromState, injector));\n            return callbackResult.then(checkForRedirect).then(function (result) { return result || invokeNextCallback(); });\n        }\n        return invokeNextCallback();\n    };\n    /**\n     * Registers an Invalid State handler\n     *\n     * Registers a [[OnInvalidCallback]] function to be invoked when [[StateService.transitionTo]]\n     * has been called with an invalid state reference parameter\n     *\n     * Example:\n     * ```js\n     * stateService.onInvalid(function(to, from, injector) {\n     *   if (to.name() === 'foo') {\n     *     let lazyLoader = injector.get('LazyLoadService');\n     *     return lazyLoader.load('foo')\n     *         .then(() => stateService.target('foo'));\n     *   }\n     * });\n     * ```\n     *\n     * @param {function} callback invoked when the toState is invalid\n     *   This function receives the (invalid) toState, the fromState, and an injector.\n     *   The function may optionally return a [[TargetState]] or a Promise for a TargetState.\n     *   If one is returned, it is treated as a redirect.\n     *\n     * @returns a function which deregisters the callback\n     */\n    StateService.prototype.onInvalid = function (callback) {\n        this.invalidCallbacks.push(callback);\n        return function deregisterListener() {\n            common_1.removeFrom(this.invalidCallbacks)(callback);\n        }.bind(this);\n    };\n    /**\n     * Reloads the current state\n     *\n     * A method that force reloads the current state, or a partial state hierarchy.\n     * All resolves are re-resolved, and components reinstantiated.\n     *\n     * #### Example:\n     * ```js\n     * let app angular.module('app', ['ui.router']);\n     *\n     * app.controller('ctrl', function ($scope, $state) {\n     *   $scope.reload = function(){\n     *     $state.reload();\n     *   }\n     * });\n     * ```\n     *\n     * Note: `reload()` is just an alias for:\n     *\n     * ```js\n     * $state.transitionTo($state.current, $state.params, {\n     *   reload: true, inherit: false\n     * });\n     * ```\n     *\n     * @param reloadState A state name or a state object.\n     *    If present, this state and all its children will be reloaded, but ancestors will not reload.\n     *\n     * #### Example:\n     * ```js\n     * //assuming app application consists of 3 states: 'contacts', 'contacts.detail', 'contacts.detail.item'\n     * //and current state is 'contacts.detail.item'\n     * let app angular.module('app', ['ui.router']);\n     *\n     * app.controller('ctrl', function ($scope, $state) {\n     *   $scope.reload = function(){\n     *     //will reload 'contact.detail' and nested 'contact.detail.item' states\n     *     $state.reload('contact.detail');\n     *   }\n     * });\n     * ```\n     *\n     * @returns A promise representing the state of the new transition. See [[StateService.go]]\n     */\n    StateService.prototype.reload = function (reloadState) {\n        return this.transitionTo(this.current, this.params, {\n            reload: predicates_1.isDefined(reloadState) ? reloadState : true,\n            inherit: false,\n            notify: false,\n        });\n    };\n    /**\n     * Transition to a different state and/or parameters\n     *\n     * Convenience method for transitioning to a new state.\n     *\n     * `$state.go` calls `$state.transitionTo` internally but automatically sets options to\n     * `{ location: true, inherit: true, relative: router.globals.$current, notify: true }`.\n     * This allows you to use either an absolute or relative `to` argument (because of `relative: router.globals.$current`).\n     * It also allows you to specify * only the parameters you'd like to update, while letting unspecified parameters\n     * inherit from the current parameter values (because of `inherit: true`).\n     *\n     * #### Example:\n     * ```js\n     * let app = angular.module('app', ['ui.router']);\n     *\n     * app.controller('ctrl', function ($scope, $state) {\n     *   $scope.changeState = function () {\n     *     $state.go('contact.detail');\n     *   };\n     * });\n     * ```\n     *\n     * @param to Absolute state name, state object, or relative state path (relative to current state).\n     *\n     * Some examples:\n     *\n     * - `$state.go('contact.detail')` - will go to the `contact.detail` state\n     * - `$state.go('^')` - will go to the parent state\n     * - `$state.go('^.sibling')` - if current state is `home.child`, will go to the `home.sibling` state\n     * - `$state.go('.child.grandchild')` - if current state is home, will go to the `home.child.grandchild` state\n     *\n     * @param params A map of the parameters that will be sent to the state, will populate $stateParams.\n     *\n     *    Any parameters that are not specified will be inherited from current parameter values (because of `inherit: true`).\n     *    This allows, for example, going to a sibling state that shares parameters defined by a parent state.\n     *\n     * @param options Transition options\n     *\n     * @returns {promise} A promise representing the state of the new transition.\n     */\n    StateService.prototype.go = function (to, params, options) {\n        var defautGoOpts = { relative: this.$current, inherit: true };\n        var transOpts = common_1.defaults(options, defautGoOpts, transitionService_1.defaultTransOpts);\n        return this.transitionTo(to, params, transOpts);\n    };\n    /**\n     * Creates a [[TargetState]]\n     *\n     * This is a factory method for creating a TargetState\n     *\n     * This may be returned from a Transition Hook to redirect a transition, for example.\n     */\n    StateService.prototype.target = function (identifier, params, options) {\n        if (options === void 0) { options = {}; }\n        // If we're reloading, find the state object to reload from\n        if (predicates_1.isObject(options.reload) && !options.reload.name)\n            throw new Error('Invalid reload state object');\n        var reg = this.router.stateRegistry;\n        options.reloadState =\n            options.reload === true ? reg.root() : reg.matcher.find(options.reload, options.relative);\n        if (options.reload && !options.reloadState)\n            throw new Error(\"No such reload state '\" + (predicates_1.isString(options.reload) ? options.reload : options.reload.name) + \"'\");\n        return new targetState_1.TargetState(this.router.stateRegistry, identifier, params, options);\n    };\n    StateService.prototype.getCurrentPath = function () {\n        var _this = this;\n        var globals = this.router.globals;\n        var latestSuccess = globals.successfulTransitions.peekTail();\n        var rootPath = function () { return [new pathNode_1.PathNode(_this.router.stateRegistry.root())]; };\n        return latestSuccess ? latestSuccess.treeChanges().to : rootPath();\n    };\n    /**\n     * Low-level method for transitioning to a new state.\n     *\n     * The [[go]] method (which uses `transitionTo` internally) is recommended in most situations.\n     *\n     * #### Example:\n     * ```js\n     * let app = angular.module('app', ['ui.router']);\n     *\n     * app.controller('ctrl', function ($scope, $state) {\n     *   $scope.changeState = function () {\n     *     $state.transitionTo('contact.detail');\n     *   };\n     * });\n     * ```\n     *\n     * @param to State name or state object.\n     * @param toParams A map of the parameters that will be sent to the state,\n     *      will populate $stateParams.\n     * @param options Transition options\n     *\n     * @returns A promise representing the state of the new transition. See [[go]]\n     */\n    StateService.prototype.transitionTo = function (to, toParams, options) {\n        var _this = this;\n        if (toParams === void 0) { toParams = {}; }\n        if (options === void 0) { options = {}; }\n        var router = this.router;\n        var globals = router.globals;\n        options = common_1.defaults(options, transitionService_1.defaultTransOpts);\n        var getCurrent = function () { return globals.transition; };\n        options = common_1.extend(options, { current: getCurrent });\n        var ref = this.target(to, toParams, options);\n        var currentPath = this.getCurrentPath();\n        if (!ref.exists())\n            return this._handleInvalidTargetState(currentPath, ref);\n        if (!ref.valid())\n            return common_1.silentRejection(ref.error());\n        /**\n         * Special handling for Ignored, Aborted, and Redirected transitions\n         *\n         * The semantics for the transition.run() promise and the StateService.transitionTo()\n         * promise differ. For instance, the run() promise may be rejected because it was\n         * IGNORED, but the transitionTo() promise is resolved because from the user perspective\n         * no error occurred.  Likewise, the transition.run() promise may be rejected because of\n         * a Redirect, but the transitionTo() promise is chained to the new Transition's promise.\n         */\n        var rejectedTransitionHandler = function (trans) { return function (error) {\n            if (error instanceof rejectFactory_1.Rejection) {\n                var isLatest = router.globals.lastStartedTransitionId === trans.$id;\n                if (error.type === rejectFactory_1.RejectType.IGNORED) {\n                    isLatest && router.urlRouter.update();\n                    // Consider ignored `Transition.run()` as a successful `transitionTo`\n                    return coreservices_1.services.$q.when(globals.current);\n                }\n                var detail = error.detail;\n                if (error.type === rejectFactory_1.RejectType.SUPERSEDED && error.redirected && detail instanceof targetState_1.TargetState) {\n                    // If `Transition.run()` was redirected, allow the `transitionTo()` promise to resolve successfully\n                    // by returning the promise for the new (redirect) `Transition.run()`.\n                    var redirect = trans.redirect(detail);\n                    return redirect.run().catch(rejectedTransitionHandler(redirect));\n                }\n                if (error.type === rejectFactory_1.RejectType.ABORTED) {\n                    isLatest && router.urlRouter.update();\n                    return coreservices_1.services.$q.reject(error);\n                }\n            }\n            var errorHandler = _this.defaultErrorHandler();\n            errorHandler(error);\n            return coreservices_1.services.$q.reject(error);\n        }; };\n        var transition = this.router.transitionService.create(currentPath, ref);\n        var transitionToPromise = transition.run().catch(rejectedTransitionHandler(transition));\n        common_1.silenceUncaughtInPromise(transitionToPromise); // issue #2676\n        // Return a promise for the transition, which also has the transition object on it.\n        return common_1.extend(transitionToPromise, { transition: transition });\n    };\n    /**\n     * Checks if the current state *is* the provided state\n     *\n     * Similar to [[includes]] but only checks for the full state name.\n     * If params is supplied then it will be tested for strict equality against the current\n     * active params object, so all params must match with none missing and no extras.\n     *\n     * #### Example:\n     * ```js\n     * $state.$current.name = 'contacts.details.item';\n     *\n     * // absolute name\n     * $state.is('contact.details.item'); // returns true\n     * $state.is(contactDetailItemStateObject); // returns true\n     * ```\n     *\n     * // relative name (. and ^), typically from a template\n     * // E.g. from the 'contacts.details' template\n     * ```html\n     * <div ng-class=\"{highlighted: $state.is('.item')}\">Item</div>\n     * ```\n     *\n     * @param stateOrName The state name (absolute or relative) or state object you'd like to check.\n     * @param params A param object, e.g. `{sectionId: section.id}`, that you'd like\n     * to test against the current active state.\n     * @param options An options object. The options are:\n     *   - `relative`: If `stateOrName` is a relative state name and `options.relative` is set, .is will\n     *     test relative to `options.relative` state (or name).\n     *\n     * @returns Returns true if it is the state.\n     */\n    StateService.prototype.is = function (stateOrName, params, options) {\n        options = common_1.defaults(options, { relative: this.$current });\n        var state = this.router.stateRegistry.matcher.find(stateOrName, options.relative);\n        if (!predicates_1.isDefined(state))\n            return undefined;\n        if (this.$current !== state)\n            return false;\n        if (!params)\n            return true;\n        var schema = state.parameters({ inherit: true, matchingKeys: params });\n        return param_1.Param.equals(schema, param_1.Param.values(schema, params), this.params);\n    };\n    /**\n     * Checks if the current state *includes* the provided state\n     *\n     * A method to determine if the current active state is equal to or is the child of the\n     * state stateName. If any params are passed then they will be tested for a match as well.\n     * Not all the parameters need to be passed, just the ones you'd like to test for equality.\n     *\n     * #### Example when `$state.$current.name === 'contacts.details.item'`\n     * ```js\n     * // Using partial names\n     * $state.includes(\"contacts\"); // returns true\n     * $state.includes(\"contacts.details\"); // returns true\n     * $state.includes(\"contacts.details.item\"); // returns true\n     * $state.includes(\"contacts.list\"); // returns false\n     * $state.includes(\"about\"); // returns false\n     * ```\n     *\n     * #### Glob Examples when `* $state.$current.name === 'contacts.details.item.url'`:\n     * ```js\n     * $state.includes(\"*.details.*.*\"); // returns true\n     * $state.includes(\"*.details.**\"); // returns true\n     * $state.includes(\"**.item.**\"); // returns true\n     * $state.includes(\"*.details.item.url\"); // returns true\n     * $state.includes(\"*.details.*.url\"); // returns true\n     * $state.includes(\"*.details.*\"); // returns false\n     * $state.includes(\"item.**\"); // returns false\n     * ```\n     *\n     * @param stateOrName A partial name, relative name, glob pattern,\n     *   or state object to be searched for within the current state name.\n     * @param params A param object, e.g. `{sectionId: section.id}`,\n     *   that you'd like to test against the current active state.\n     * @param options An options object. The options are:\n     *   - `relative`: If `stateOrName` is a relative state name and `options.relative` is set, .is will\n     *     test relative to `options.relative` state (or name).\n     *\n     * @returns {boolean} Returns true if it does include the state\n     */\n    StateService.prototype.includes = function (stateOrName, params, options) {\n        options = common_1.defaults(options, { relative: this.$current });\n        var glob = predicates_1.isString(stateOrName) && glob_1.Glob.fromString(stateOrName);\n        if (glob) {\n            if (!glob.matches(this.$current.name))\n                return false;\n            stateOrName = this.$current.name;\n        }\n        var state = this.router.stateRegistry.matcher.find(stateOrName, options.relative), include = this.$current.includes;\n        if (!predicates_1.isDefined(state))\n            return undefined;\n        if (!predicates_1.isDefined(include[state.name]))\n            return false;\n        if (!params)\n            return true;\n        var schema = state.parameters({ inherit: true, matchingKeys: params });\n        return param_1.Param.equals(schema, param_1.Param.values(schema, params), this.params);\n    };\n    /**\n     * Generates a URL for a state and parameters\n     *\n     * Returns the url for the given state populated with the given params.\n     *\n     * #### Example:\n     * ```js\n     * expect($state.href(\"about.person\", { person: \"bob\" })).toEqual(\"/about/bob\");\n     * ```\n     *\n     * @param stateOrName The state name or state object you'd like to generate a url from.\n     * @param params An object of parameter values to fill the state's required parameters.\n     * @param options Options object. The options are:\n     *\n     * @returns {string} compiled state url\n     */\n    StateService.prototype.href = function (stateOrName, params, options) {\n        var defaultHrefOpts = {\n            lossy: true,\n            inherit: true,\n            absolute: false,\n            relative: this.$current,\n        };\n        options = common_1.defaults(options, defaultHrefOpts);\n        params = params || {};\n        var state = this.router.stateRegistry.matcher.find(stateOrName, options.relative);\n        if (!predicates_1.isDefined(state))\n            return null;\n        if (options.inherit)\n            params = this.params.$inherit(params, this.$current, state);\n        var nav = state && options.lossy ? state.navigable : state;\n        if (!nav || nav.url === undefined || nav.url === null) {\n            return null;\n        }\n        return this.router.urlRouter.href(nav.url, params, {\n            absolute: options.absolute,\n        });\n    };\n    /**\n     * Sets or gets the default [[transitionTo]] error handler.\n     *\n     * The error handler is called when a [[Transition]] is rejected or when any error occurred during the Transition.\n     * This includes errors caused by resolves and transition hooks.\n     *\n     * Note:\n     * This handler does not receive certain Transition rejections.\n     * Redirected and Ignored Transitions are not considered to be errors by [[StateService.transitionTo]].\n     *\n     * The built-in default error handler logs the error to the console.\n     *\n     * You can provide your own custom handler.\n     *\n     * #### Example:\n     * ```js\n     * stateService.defaultErrorHandler(function() {\n     *   // Do not log transitionTo errors\n     * });\n     * ```\n     *\n     * @param handler a global error handler function\n     * @returns the current global error handler\n     */\n    StateService.prototype.defaultErrorHandler = function (handler) {\n        return (this._defaultErrorHandler = handler || this._defaultErrorHandler);\n    };\n    StateService.prototype.get = function (stateOrName, base) {\n        var reg = this.router.stateRegistry;\n        if (arguments.length === 0)\n            return reg.get();\n        return reg.get(stateOrName, base || this.$current);\n    };\n    /**\n     * Lazy loads a state\n     *\n     * Explicitly runs a state's [[StateDeclaration.lazyLoad]] function.\n     *\n     * @param stateOrName the state that should be lazy loaded\n     * @param transition the optional Transition context to use (if the lazyLoad function requires an injector, etc)\n     * Note: If no transition is provided, a noop transition is created using the from the current state to the current state.\n     * This noop transition is not actually run.\n     *\n     * @returns a promise to lazy load\n     */\n    StateService.prototype.lazyLoad = function (stateOrName, transition) {\n        var state = this.get(stateOrName);\n        if (!state || !state.lazyLoad)\n            throw new Error('Can not lazy load ' + stateOrName);\n        var currentPath = this.getCurrentPath();\n        var target = pathUtils_1.PathUtils.makeTargetState(this.router.stateRegistry, currentPath);\n        transition = transition || this.router.transitionService.create(currentPath, target);\n        return lazyLoad_1.lazyLoadState(transition, state);\n    };\n    return StateService;\n}());\nexports.StateService = StateService;\n//# sourceMappingURL=stateService.js.map","\"use strict\";\n/**\n * @coreapi\n * @module state\n */ /** for typedoc */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar predicates_1 = require(\"../common/predicates\");\nvar strings_1 = require(\"../common/strings\");\nvar common_1 = require(\"../common\");\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 */\nvar TargetState = /** @class */ (function () {\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    function TargetState(_stateRegistry, _identifier, _params, _options) {\n        this._stateRegistry = _stateRegistry;\n        this._identifier = _identifier;\n        this._identifier = _identifier;\n        this._params = common_1.extend({}, _params || {});\n        this._options = common_1.extend({}, _options || {});\n        this._definition = _stateRegistry.matcher.find(_identifier, this._options.relative);\n    }\n    /** The name of the state this object targets */\n    TargetState.prototype.name = function () {\n        return (this._definition && this._definition.name) || this._identifier;\n    };\n    /** The identifier used when creating this TargetState */\n    TargetState.prototype.identifier = function () {\n        return this._identifier;\n    };\n    /** The target parameter values */\n    TargetState.prototype.params = function () {\n        return this._params;\n    };\n    /** The internal state object (if it was found) */\n    TargetState.prototype.$state = function () {\n        return this._definition;\n    };\n    /** The internal state declaration (if it was found) */\n    TargetState.prototype.state = function () {\n        return this._definition && this._definition.self;\n    };\n    /** The target options */\n    TargetState.prototype.options = function () {\n        return this._options;\n    };\n    /** True if the target state was found */\n    TargetState.prototype.exists = function () {\n        return !!(this._definition && this._definition.self);\n    };\n    /** True if the object is valid */\n    TargetState.prototype.valid = function () {\n        return !this.error();\n    };\n    /** If the object is invalid, returns the reason why */\n    TargetState.prototype.error = function () {\n        var base = this.options().relative;\n        if (!this._definition && !!base) {\n            var 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    TargetState.prototype.toString = function () {\n        return \"'\" + this.name() + \"'\" + strings_1.stringify(this.params());\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    TargetState.prototype.withState = function (state) {\n        return new TargetState(this._stateRegistry, state, this._params, this._options);\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    TargetState.prototype.withParams = function (params, replace) {\n        if (replace === void 0) { replace = false; }\n        var newParams = replace ? params : common_1.extend({}, this._params, params);\n        return new TargetState(this._stateRegistry, this._identifier, newParams, this._options);\n    };\n    /**\n     * Returns a copy of this TargetState, using the specified Transition Options.\n     *\n     * @param options the new options to use\n     * @param replace When false (default) the new options will be merged with the current options.\n     *                When true the options will be used instead of the current options.\n     */\n    TargetState.prototype.withOptions = function (options, replace) {\n        if (replace === void 0) { replace = false; }\n        var newOpts = replace ? options : common_1.extend({}, this._options, options);\n        return new TargetState(this._stateRegistry, this._identifier, this._params, newOpts);\n    };\n    /** Returns true if the object has a state property that might be a state or state name */\n    TargetState.isDef = function (obj) { return obj && obj.state && (predicates_1.isString(obj.state) || predicates_1.isString(obj.state.name)); };\n    return TargetState;\n}());\nexports.TargetState = TargetState;\n//# sourceMappingURL=targetState.js.map","\"use strict\";\n/**\n * @coreapi\n * @module transition\n */ /** for typedoc */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar common_1 = require(\"../common/common\");\nvar predicates_1 = require(\"../common/predicates\");\nvar interface_1 = require(\"./interface\");\nvar transitionHook_1 = require(\"./transitionHook\");\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 */\nvar HookBuilder = /** @class */ (function () {\n    function HookBuilder(transition) {\n        this.transition = transition;\n    }\n    HookBuilder.prototype.buildHooksForPhase = function (phase) {\n        var _this = this;\n        var $transitions = this.transition.router.transitionService;\n        return $transitions._pluginapi\n            ._getEvents(phase)\n            .map(function (type) { return _this.buildHooks(type); })\n            .reduce(common_1.unnestR, [])\n            .filter(common_1.identity);\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    HookBuilder.prototype.buildHooks = function (hookType) {\n        var transition = this.transition;\n        var treeChanges = transition.treeChanges();\n        // Find all the matching registered hooks for a given hook type\n        var matchingHooks = this.getMatchingHooks(hookType, treeChanges);\n        if (!matchingHooks)\n            return [];\n        var baseHookOptions = {\n            transition: transition,\n            current: transition.options().current,\n        };\n        var makeTransitionHooks = function (hook) {\n            // Fetch the Nodes that caused this hook to match.\n            var matches = hook.matches(treeChanges);\n            // Select the PathNode[] that will be used as TransitionHook context objects\n            var matchingNodes = matches[hookType.criteriaMatchPath.name];\n            // Return an array of HookTuples\n            return matchingNodes.map(function (node) {\n                var _options = common_1.extend({\n                    bind: hook.bind,\n                    traceData: { hookType: hookType.name, context: node },\n                }, baseHookOptions);\n                var state = hookType.criteriaMatchPath.scope === interface_1.TransitionHookScope.STATE ? node.state.self : null;\n                var transitionHook = new transitionHook_1.TransitionHook(transition, state, hook, _options);\n                return { hook: hook, node: node, transitionHook: transitionHook };\n            });\n        };\n        return matchingHooks\n            .map(makeTransitionHooks)\n            .reduce(common_1.unnestR, [])\n            .sort(tupleSort(hookType.reverseSort))\n            .map(function (tuple) { return tuple.transitionHook; });\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    HookBuilder.prototype.getMatchingHooks = function (hookType, treeChanges) {\n        var isCreate = hookType.hookPhase === interface_1.TransitionHookPhase.CREATE;\n        // Instance and Global hook registries\n        var $transitions = this.transition.router.transitionService;\n        var registries = isCreate ? [$transitions] : [this.transition, $transitions];\n        return registries\n            .map(function (reg) { return reg.getHooks(hookType.name); }) // Get named hooks from registries\n            .filter(common_1.assertPredicate(predicates_1.isArray, \"broken event named: \" + hookType.name)) // Sanity check\n            .reduce(common_1.unnestR, []) // Un-nest RegisteredHook[][] to RegisteredHook[] array\n            .filter(function (hook) { return hook.matches(treeChanges); }); // Only those satisfying matchCriteria\n    };\n    return HookBuilder;\n}());\nexports.HookBuilder = HookBuilder;\n/**\n * A factory for a sort function for HookTuples.\n *\n * The sort function first compares the PathNode depth (how deep in the state tree a node is), then compares\n * the EventHook priority.\n *\n * @param reverseDepthSort a boolean, when true, reverses the sort order for the node depth\n * @returns a tuple sort function\n */\nfunction tupleSort(reverseDepthSort) {\n    if (reverseDepthSort === void 0) { reverseDepthSort = false; }\n    return function nodeDepthThenPriority(l, r) {\n        var factor = reverseDepthSort ? -1 : 1;\n        var depthDelta = (l.node.state.path.length - r.node.state.path.length) * factor;\n        return depthDelta !== 0 ? depthDelta : r.hook.priority - l.hook.priority;\n    };\n}\n//# sourceMappingURL=hookBuilder.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module transition\n */ /** for typedoc */\nvar common_1 = require(\"../common\");\nvar interface_1 = require(\"./interface\");\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 */\nfunction matchState(state, criterion) {\n    var toMatch = common_1.isString(criterion) ? [criterion] : criterion;\n    function matchGlobs(_state) {\n        var globStrings = toMatch;\n        for (var i = 0; i < globStrings.length; i++) {\n            var glob = new common_1.Glob(globStrings[i]);\n            if ((glob && glob.matches(_state.name)) || (!glob && globStrings[i] === _state.name)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    var matchFn = (common_1.isFunction(toMatch) ? toMatch : matchGlobs);\n    return !!matchFn(state);\n}\nexports.matchState = matchState;\n/**\n * @internalapi\n * The registration data for a registered transition hook\n */\nvar RegisteredHook = /** @class */ (function () {\n    function RegisteredHook(tranSvc, eventType, callback, matchCriteria, removeHookFromRegistry, options) {\n        if (options === void 0) { options = {}; }\n        this.tranSvc = tranSvc;\n        this.eventType = eventType;\n        this.callback = callback;\n        this.matchCriteria = matchCriteria;\n        this.removeHookFromRegistry = removeHookFromRegistry;\n        this.invokeCount = 0;\n        this._deregistered = false;\n        this.priority = options.priority || 0;\n        this.bind = options.bind || null;\n        this.invokeLimit = options.invokeLimit;\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    RegisteredHook.prototype._matchingNodes = function (nodes, criterion) {\n        if (criterion === true)\n            return nodes;\n        var matching = nodes.filter(function (node) { return matchState(node.state, criterion); });\n        return matching.length ? matching : null;\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    RegisteredHook.prototype._getDefaultMatchCriteria = function () {\n        return common_1.mapObj(this.tranSvc._pluginapi._getPathTypes(), function () { return true; });\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    RegisteredHook.prototype._getMatchingNodes = function (treeChanges) {\n        var _this = this;\n        var criteria = common_1.extend(this._getDefaultMatchCriteria(), this.matchCriteria);\n        var paths = common_1.values(this.tranSvc._pluginapi._getPathTypes());\n        return paths.reduce(function (mn, pathtype) {\n            // STATE scope criteria matches against every node in the path.\n            // TRANSITION scope criteria matches against only the last node in the path\n            var isStateHook = pathtype.scope === interface_1.TransitionHookScope.STATE;\n            var path = treeChanges[pathtype.name] || [];\n            var nodes = isStateHook ? path : [common_1.tail(path)];\n            mn[pathtype.name] = _this._matchingNodes(nodes, criteria[pathtype.name]);\n            return mn;\n        }, {});\n    };\n    /**\n     * Determines if this hook's [[matchCriteria]] match the given [[TreeChanges]]\n     *\n     * @returns an IMatchingNodes object, or null. If an IMatchingNodes object is returned, its values\n     * are the matching [[PathNode]]s for each [[HookMatchCriterion]] (to, from, exiting, retained, entering)\n     */\n    RegisteredHook.prototype.matches = function (treeChanges) {\n        var matches = this._getMatchingNodes(treeChanges);\n        // Check if all the criteria matched the TreeChanges object\n        var allMatched = common_1.values(matches).every(common_1.identity);\n        return allMatched ? matches : null;\n    };\n    RegisteredHook.prototype.deregister = function () {\n        this.removeHookFromRegistry(this);\n        this._deregistered = true;\n    };\n    return RegisteredHook;\n}());\nexports.RegisteredHook = RegisteredHook;\n/** @hidden Return a registration function of the requested type. */\nfunction makeEvent(registry, transitionService, eventType) {\n    // Create the object which holds the registered transition hooks.\n    var _registeredHooks = (registry._registeredHooks = registry._registeredHooks || {});\n    var hooks = (_registeredHooks[eventType.name] = []);\n    var removeHookFn = common_1.removeFrom(hooks);\n    // Create hook registration function on the IHookRegistry for the event\n    registry[eventType.name] = hookRegistrationFn;\n    function hookRegistrationFn(matchObject, callback, options) {\n        if (options === void 0) { options = {}; }\n        var registeredHook = new RegisteredHook(transitionService, eventType, callback, matchObject, removeHookFn, options);\n        hooks.push(registeredHook);\n        return registeredHook.deregister.bind(registeredHook);\n    }\n    return hookRegistrationFn;\n}\nexports.makeEvent = makeEvent;\n//# sourceMappingURL=hookRegistry.js.map","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\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 */\n__export(require(\"./interface\"));\n__export(require(\"./hookBuilder\"));\n__export(require(\"./hookRegistry\"));\n__export(require(\"./rejectFactory\"));\n__export(require(\"./transition\"));\n__export(require(\"./transitionHook\"));\n__export(require(\"./transitionEventType\"));\n__export(require(\"./transitionService\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar TransitionHookPhase;\n(function (TransitionHookPhase) {\n    TransitionHookPhase[TransitionHookPhase[\"CREATE\"] = 0] = \"CREATE\";\n    TransitionHookPhase[TransitionHookPhase[\"BEFORE\"] = 1] = \"BEFORE\";\n    TransitionHookPhase[TransitionHookPhase[\"RUN\"] = 2] = \"RUN\";\n    TransitionHookPhase[TransitionHookPhase[\"SUCCESS\"] = 3] = \"SUCCESS\";\n    TransitionHookPhase[TransitionHookPhase[\"ERROR\"] = 4] = \"ERROR\";\n})(TransitionHookPhase = exports.TransitionHookPhase || (exports.TransitionHookPhase = {}));\nvar TransitionHookScope;\n(function (TransitionHookScope) {\n    TransitionHookScope[TransitionHookScope[\"TRANSITION\"] = 0] = \"TRANSITION\";\n    TransitionHookScope[TransitionHookScope[\"STATE\"] = 1] = \"STATE\";\n})(TransitionHookScope = exports.TransitionHookScope || (exports.TransitionHookScope = {}));\n//# sourceMappingURL=interface.js.map","/**\n * @coreapi\n * @module transition\n */ /** for typedoc */\n'use strict';\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar common_1 = require(\"../common/common\");\nvar strings_1 = require(\"../common/strings\");\nvar hof_1 = require(\"../common/hof\");\nvar RejectType;\n(function (RejectType) {\n    /**\n     * A new transition superseded this one.\n     *\n     * While this transition was running, a new transition started.\n     * This transition is cancelled because it was superseded by new transition.\n     */\n    RejectType[RejectType[\"SUPERSEDED\"] = 2] = \"SUPERSEDED\";\n    /**\n     * The transition was aborted\n     *\n     * The transition was aborted by a hook which returned `false`\n     */\n    RejectType[RejectType[\"ABORTED\"] = 3] = \"ABORTED\";\n    /**\n     * The transition was invalid\n     *\n     * The transition was never started because it was invalid\n     */\n    RejectType[RejectType[\"INVALID\"] = 4] = \"INVALID\";\n    /**\n     * The transition was ignored\n     *\n     * The transition was ignored because it would have no effect.\n     *\n     * Either:\n     *\n     * - The transition is targeting the current state and parameter values\n     * - The transition is targeting the same state and parameter values as the currently running transition.\n     */\n    RejectType[RejectType[\"IGNORED\"] = 5] = \"IGNORED\";\n    /**\n     * The transition errored.\n     *\n     * This generally means a hook threw an error or returned a rejected promise\n     */\n    RejectType[RejectType[\"ERROR\"] = 6] = \"ERROR\";\n})(RejectType = exports.RejectType || (exports.RejectType = {}));\n/** @hidden */\nvar id = 0;\nvar Rejection = /** @class */ (function () {\n    function Rejection(type, message, detail) {\n        /** @hidden */\n        this.$id = id++;\n        this.type = type;\n        this.message = message;\n        this.detail = detail;\n    }\n    /** Returns true if the obj is a rejected promise created from the `asPromise` factory */\n    Rejection.isRejectionPromise = function (obj) {\n        return obj && typeof obj.then === 'function' && hof_1.is(Rejection)(obj._transitionRejection);\n    };\n    /** Returns a Rejection due to transition superseded */\n    Rejection.superseded = function (detail, options) {\n        var message = 'The transition has been superseded by a different transition';\n        var rejection = new Rejection(RejectType.SUPERSEDED, message, detail);\n        if (options && options.redirected) {\n            rejection.redirected = true;\n        }\n        return rejection;\n    };\n    /** Returns a Rejection due to redirected transition */\n    Rejection.redirected = function (detail) {\n        return Rejection.superseded(detail, { redirected: true });\n    };\n    /** Returns a Rejection due to invalid transition */\n    Rejection.invalid = function (detail) {\n        var message = 'This transition is invalid';\n        return new Rejection(RejectType.INVALID, message, detail);\n    };\n    /** Returns a Rejection due to ignored transition */\n    Rejection.ignored = function (detail) {\n        var message = 'The transition was ignored';\n        return new Rejection(RejectType.IGNORED, message, detail);\n    };\n    /** Returns a Rejection due to aborted transition */\n    Rejection.aborted = function (detail) {\n        var message = 'The transition has been aborted';\n        return new Rejection(RejectType.ABORTED, message, detail);\n    };\n    /** Returns a Rejection due to aborted transition */\n    Rejection.errored = function (detail) {\n        var message = 'The transition errored';\n        return new Rejection(RejectType.ERROR, message, detail);\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    Rejection.normalize = function (detail) {\n        return hof_1.is(Rejection)(detail) ? detail : Rejection.errored(detail);\n    };\n    Rejection.prototype.toString = function () {\n        var detailString = function (d) { return (d && d.toString !== Object.prototype.toString ? d.toString() : strings_1.stringify(d)); };\n        var detail = detailString(this.detail);\n        var _a = this, $id = _a.$id, type = _a.type, message = _a.message;\n        return \"Transition Rejection($id: \" + $id + \" type: \" + type + \", message: \" + message + \", detail: \" + detail + \")\";\n    };\n    Rejection.prototype.toPromise = function () {\n        return common_1.extend(common_1.silentRejection(this), { _transitionRejection: this });\n    };\n    return Rejection;\n}());\nexports.Rejection = Rejection;\n//# sourceMappingURL=rejectFactory.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module transition\n */\n/** for typedoc */\nvar trace_1 = require(\"../common/trace\");\nvar coreservices_1 = require(\"../common/coreservices\");\nvar strings_1 = require(\"../common/strings\");\nvar common_1 = require(\"../common/common\");\nvar predicates_1 = require(\"../common/predicates\");\nvar hof_1 = require(\"../common/hof\");\nvar interface_1 = require(\"./interface\"); // has or is using\nvar transitionHook_1 = require(\"./transitionHook\");\nvar hookRegistry_1 = require(\"./hookRegistry\");\nvar hookBuilder_1 = require(\"./hookBuilder\");\nvar pathUtils_1 = require(\"../path/pathUtils\");\nvar param_1 = require(\"../params/param\");\nvar resolvable_1 = require(\"../resolve/resolvable\");\nvar resolveContext_1 = require(\"../resolve/resolveContext\");\nvar rejectFactory_1 = require(\"./rejectFactory\");\n/** @hidden */\nvar stateSelf = hof_1.prop('self');\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 */\nvar Transition = /** @class */ (function () {\n    /**\n     * Creates a new Transition object.\n     *\n     * If the target state is not valid, an error is thrown.\n     *\n     * @internalapi\n     *\n     * @param fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`\n     *        encapsulates the \"from state\".\n     * @param targetState The target state and parameters being transitioned to (also, the transition options)\n     * @param router The [[UIRouter]] instance\n     */\n    function Transition(fromPath, targetState, router) {\n        var _this = this;\n        /** @hidden */\n        this._deferred = coreservices_1.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        this.promise = this._deferred.promise;\n        /** @hidden Holds the hook registration functions such as those passed to Transition.onStart() */\n        this._registeredHooks = {};\n        /** @hidden */\n        this._hookBuilder = new hookBuilder_1.HookBuilder(this);\n        /** Checks if this transition is currently active/running. */\n        this.isActive = function () { return _this.router.globals.transition === _this; };\n        this.router = router;\n        this._targetState = targetState;\n        if (!targetState.valid()) {\n            throw new Error(targetState.error());\n        }\n        // current() is assumed to come from targetState.options, but provide a naive implementation otherwise.\n        this._options = common_1.extend({ current: hof_1.val(this) }, targetState.options());\n        this.$id = router.transitionService._transitionCount++;\n        var toPath = pathUtils_1.PathUtils.buildToPath(fromPath, targetState);\n        this._treeChanges = pathUtils_1.PathUtils.treeChanges(fromPath, toPath, this._options.reloadState);\n        this.createTransitionHookRegFns();\n        var onCreateHooks = this._hookBuilder.buildHooksForPhase(interface_1.TransitionHookPhase.CREATE);\n        transitionHook_1.TransitionHook.invokeHooks(onCreateHooks, function () { return null; });\n        this.applyViewConfigs(router);\n    }\n    /** @hidden */\n    Transition.prototype.onBefore = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    Transition.prototype.onStart = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    Transition.prototype.onExit = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    Transition.prototype.onRetain = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    Transition.prototype.onEnter = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    Transition.prototype.onFinish = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    Transition.prototype.onSuccess = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    Transition.prototype.onError = function (criteria, callback, options) {\n        return;\n    };\n    /** @hidden\n     * Creates the transition-level hook registration functions\n     * (which can then be used to register hooks)\n     */\n    Transition.prototype.createTransitionHookRegFns = function () {\n        var _this = this;\n        this.router.transitionService._pluginapi\n            ._getEvents()\n            .filter(function (type) { return type.hookPhase !== interface_1.TransitionHookPhase.CREATE; })\n            .forEach(function (type) { return hookRegistry_1.makeEvent(_this, _this.router.transitionService, type); });\n    };\n    /** @internalapi */\n    Transition.prototype.getHooks = function (hookName) {\n        return this._registeredHooks[hookName];\n    };\n    Transition.prototype.applyViewConfigs = function (router) {\n        var enteringStates = this._treeChanges.entering.map(function (node) { return node.state; });\n        pathUtils_1.PathUtils.applyViewConfigs(router.transitionService.$view, this._treeChanges.to, enteringStates);\n    };\n    /**\n     * @internalapi\n     *\n     * @returns the internal from [State] object\n     */\n    Transition.prototype.$from = function () {\n        return common_1.tail(this._treeChanges.from).state;\n    };\n    /**\n     * @internalapi\n     *\n     * @returns the internal to [State] object\n     */\n    Transition.prototype.$to = function () {\n        return common_1.tail(this._treeChanges.to).state;\n    };\n    /**\n     * Returns the \"from state\"\n     *\n     * Returns the state that the transition is coming *from*.\n     *\n     * @returns The state declaration object for the Transition's (\"from state\").\n     */\n    Transition.prototype.from = function () {\n        return this.$from().self;\n    };\n    /**\n     * Returns the \"to state\"\n     *\n     * Returns the state that the transition is going *to*.\n     *\n     * @returns The state declaration object for the Transition's target state (\"to state\").\n     */\n    Transition.prototype.to = function () {\n        return this.$to().self;\n    };\n    /**\n     * Gets the Target State\n     *\n     * A transition's [[TargetState]] encapsulates the [[to]] state, the [[params]], and the [[options]] as a single object.\n     *\n     * @returns the [[TargetState]] of this Transition\n     */\n    Transition.prototype.targetState = function () {\n        return this._targetState;\n    };\n    /**\n     * Determines whether two transitions are equivalent.\n     * @deprecated\n     */\n    Transition.prototype.is = function (compare) {\n        if (compare instanceof Transition) {\n            // TODO: Also compare parameters\n            return this.is({ to: compare.$to().name, from: compare.$from().name });\n        }\n        return !((compare.to && !hookRegistry_1.matchState(this.$to(), compare.to)) ||\n            (compare.from && !hookRegistry_1.matchState(this.$from(), compare.from)));\n    };\n    Transition.prototype.params = function (pathname) {\n        if (pathname === void 0) { pathname = 'to'; }\n        return Object.freeze(this._treeChanges[pathname].map(hof_1.prop('paramValues')).reduce(common_1.mergeR, {}));\n    };\n    /**\n     * Creates a [[UIInjector]] Dependency Injector\n     *\n     * Returns a Dependency Injector for the Transition's target state (to state).\n     * The injector provides resolve values which the target state has access to.\n     *\n     * The `UIInjector` can also provide values from the native root/global injector (ng1/ng2).\n     *\n     * #### Example:\n     * ```js\n     * .onEnter({ entering: 'myState' }, trans => {\n     *   var myResolveValue = trans.injector().get('myResolve');\n     *   // Inject a global service from the global/native injector (if it exists)\n     *   var MyService = trans.injector().get('MyService');\n     * })\n     * ```\n     *\n     * In some cases (such as `onBefore`), you may need access to some resolve data but it has not yet been fetched.\n     * You can use [[UIInjector.getAsync]] to get a promise for the data.\n     * #### Example:\n     * ```js\n     * .onBefore({}, trans => {\n     *   return trans.injector().getAsync('myResolve').then(myResolveValue =>\n     *     return myResolveValue !== 'ABORT';\n     *   });\n     * });\n     * ```\n     *\n     * If a `state` is provided, the injector that is returned will be limited to resolve values that the provided state has access to.\n     * This can be useful if both a parent state `foo` and a child state `foo.bar` have both defined a resolve such as `data`.\n     * #### Example:\n     * ```js\n     * .onEnter({ to: 'foo.bar' }, trans => {\n     *   // returns result of `foo` state's `myResolve` resolve\n     *   // even though `foo.bar` also has a `myResolve` resolve\n     *   var fooData = trans.injector('foo').get('myResolve');\n     * });\n     * ```\n     *\n     * If you need resolve data from the exiting states, pass `'from'` as `pathName`.\n     * The resolve data from the `from` path will be returned.\n     * #### Example:\n     * ```js\n     * .onExit({ exiting: 'foo.bar' }, trans => {\n     *   // Gets the resolve value of `myResolve` from the state being exited\n     *   var fooData = trans.injector(null, 'from').get('myResolve');\n     * });\n     * ```\n     *\n     *\n     * @param state Limits the resolves provided to only the resolves the provided state has access to.\n     * @param pathName Default: `'to'`: Chooses the path for which to create the injector. Use this to access resolves for `exiting` states.\n     *\n     * @returns a [[UIInjector]]\n     */\n    Transition.prototype.injector = function (state, pathName) {\n        if (pathName === void 0) { pathName = 'to'; }\n        var path = this._treeChanges[pathName];\n        if (state)\n            path = pathUtils_1.PathUtils.subPath(path, function (node) { return node.state === state || node.state.name === state; });\n        return new resolveContext_1.ResolveContext(path).injector();\n    };\n    /**\n     * Gets all available resolve tokens (keys)\n     *\n     * This method can be used in conjunction with [[injector]] to inspect the resolve values\n     * available to the Transition.\n     *\n     * This returns all the tokens defined on [[StateDeclaration.resolve]] blocks, for the states\n     * in the Transition's [[TreeChanges.to]] path.\n     *\n     * #### Example:\n     * This example logs all resolve values\n     * ```js\n     * let tokens = trans.getResolveTokens();\n     * tokens.forEach(token => console.log(token + \" = \" + trans.injector().get(token)));\n     * ```\n     *\n     * #### Example:\n     * This example creates promises for each resolve value.\n     * This triggers fetches of resolves (if any have not yet been fetched).\n     * When all promises have all settled, it logs the resolve values.\n     * ```js\n     * let tokens = trans.getResolveTokens();\n     * let promise = tokens.map(token => trans.injector().getAsync(token));\n     * Promise.all(promises).then(values => console.log(\"Resolved values: \" + values));\n     * ```\n     *\n     * Note: Angular 1 users whould use `$q.all()`\n     *\n     * @param pathname resolve context's path name (e.g., `to` or `from`)\n     *\n     * @returns an array of resolve tokens (keys)\n     */\n    Transition.prototype.getResolveTokens = function (pathname) {\n        if (pathname === void 0) { pathname = 'to'; }\n        return new resolveContext_1.ResolveContext(this._treeChanges[pathname]).getTokens();\n    };\n    /**\n     * Dynamically adds a new [[Resolvable]] (i.e., [[StateDeclaration.resolve]]) to this transition.\n     *\n     * Allows a transition hook to dynamically add a Resolvable to this Transition.\n     *\n     * Use the [[Transition.injector]] to retrieve the resolved data in subsequent hooks ([[UIInjector.get]]).\n     *\n     * If a `state` argument is provided, the Resolvable is processed when that state is being entered.\n     * If no `state` is provided then the root state is used.\n     * If the given `state` has already been entered, the Resolvable is processed when any child state is entered.\n     * If no child states will be entered, the Resolvable is processed during the `onFinish` phase of the Transition.\n     *\n     * The `state` argument also scopes the resolved data.\n     * The resolved data is available from the injector for that `state` and any children states.\n     *\n     * #### Example:\n     * ```js\n     * transitionService.onBefore({}, transition => {\n     *   transition.addResolvable({\n     *     token: 'myResolve',\n     *     deps: ['MyService'],\n     *     resolveFn: myService => myService.getData()\n     *   });\n     * });\n     * ```\n     *\n     * @param resolvable a [[ResolvableLiteral]] object (or a [[Resolvable]])\n     * @param state the state in the \"to path\" which should receive the new resolve (otherwise, the root state)\n     */\n    Transition.prototype.addResolvable = function (resolvable, state) {\n        if (state === void 0) { state = ''; }\n        resolvable = hof_1.is(resolvable_1.Resolvable)(resolvable) ? resolvable : new resolvable_1.Resolvable(resolvable);\n        var stateName = typeof state === 'string' ? state : state.name;\n        var topath = this._treeChanges.to;\n        var targetNode = common_1.find(topath, function (node) { return node.state.name === stateName; });\n        var resolveContext = new resolveContext_1.ResolveContext(topath);\n        resolveContext.addResolvables([resolvable], targetNode.state);\n    };\n    /**\n     * Gets the transition from which this transition was redirected.\n     *\n     * If the current transition is a redirect, this method returns the transition that was redirected.\n     *\n     * #### Example:\n     * ```js\n     * let transitionA = $state.go('A').transition\n     * transitionA.onStart({}, () => $state.target('B'));\n     * $transitions.onSuccess({ to: 'B' }, (trans) => {\n     *   trans.to().name === 'B'; // true\n     *   trans.redirectedFrom() === transitionA; // true\n     * });\n     * ```\n     *\n     * @returns The previous Transition, or null if this Transition is not the result of a redirection\n     */\n    Transition.prototype.redirectedFrom = function () {\n        return this._options.redirectedFrom || null;\n    };\n    /**\n     * Gets the original transition in a redirect chain\n     *\n     * A transition might belong to a long chain of multiple redirects.\n     * This method walks the [[redirectedFrom]] chain back to the original (first) transition in the chain.\n     *\n     * #### Example:\n     * ```js\n     * // states\n     * registry.register({ name: 'A', redirectTo: 'B' });\n     * registry.register({ name: 'B', redirectTo: 'C' });\n     * registry.register({ name: 'C', redirectTo: 'D' });\n     * registry.register({ name: 'D' });\n     *\n     * let transitionA = $state.go('A').transition\n     *\n     * $transitions.onSuccess({ to: 'D' }, (trans) => {\n     *   trans.to().name === 'D'; // true\n     *   trans.redirectedFrom().to().name === 'C'; // true\n     *   trans.originalTransition() === transitionA; // true\n     *   trans.originalTransition().to().name === 'A'; // true\n     * });\n     * ```\n     *\n     * @returns The original Transition that started a redirect chain\n     */\n    Transition.prototype.originalTransition = function () {\n        var rf = this.redirectedFrom();\n        return (rf && rf.originalTransition()) || this;\n    };\n    /**\n     * Get the transition options\n     *\n     * @returns the options for this Transition.\n     */\n    Transition.prototype.options = function () {\n        return this._options;\n    };\n    /**\n     * Gets the states being entered.\n     *\n     * @returns an array of states that will be entered during this transition.\n     */\n    Transition.prototype.entering = function () {\n        return common_1.map(this._treeChanges.entering, hof_1.prop('state')).map(stateSelf);\n    };\n    /**\n     * Gets the states being exited.\n     *\n     * @returns an array of states that will be exited during this transition.\n     */\n    Transition.prototype.exiting = function () {\n        return common_1.map(this._treeChanges.exiting, hof_1.prop('state'))\n            .map(stateSelf)\n            .reverse();\n    };\n    /**\n     * Gets the states being retained.\n     *\n     * @returns an array of states that are already entered from a previous Transition, that will not be\n     *    exited during this Transition\n     */\n    Transition.prototype.retained = function () {\n        return common_1.map(this._treeChanges.retained, hof_1.prop('state')).map(stateSelf);\n    };\n    /**\n     * Get the [[ViewConfig]]s associated with this Transition\n     *\n     * Each state can define one or more views (template/controller), which are encapsulated as `ViewConfig` objects.\n     * This method fetches the `ViewConfigs` for a given path in the Transition (e.g., \"to\" or \"entering\").\n     *\n     * @param pathname the name of the path to fetch views for:\n     *   (`'to'`, `'from'`, `'entering'`, `'exiting'`, `'retained'`)\n     * @param state If provided, only returns the `ViewConfig`s for a single state in the path\n     *\n     * @returns a list of ViewConfig objects for the given path.\n     */\n    Transition.prototype.views = function (pathname, state) {\n        if (pathname === void 0) { pathname = 'entering'; }\n        var path = this._treeChanges[pathname];\n        path = !state ? path : path.filter(hof_1.propEq('state', state));\n        return path\n            .map(hof_1.prop('views'))\n            .filter(common_1.identity)\n            .reduce(common_1.unnestR, []);\n    };\n    Transition.prototype.treeChanges = function (pathname) {\n        return pathname ? this._treeChanges[pathname] : this._treeChanges;\n    };\n    /**\n     * Creates a new transition that is a redirection of the current one.\n     *\n     * This transition can be returned from a [[TransitionService]] hook to\n     * redirect a transition to a new state and/or set of parameters.\n     *\n     * @internalapi\n     *\n     * @returns Returns a new [[Transition]] instance.\n     */\n    Transition.prototype.redirect = function (targetState) {\n        var redirects = 1, trans = this;\n        // tslint:disable-next-line:no-conditional-assignment\n        while ((trans = trans.redirectedFrom()) != null) {\n            if (++redirects > 20)\n                throw new Error(\"Too many consecutive Transition redirects (20+)\");\n        }\n        var redirectOpts = { redirectedFrom: this, source: 'redirect' };\n        // If the original transition was caused by URL sync, then use { location: 'replace' }\n        // on the new transition (unless the target state explicitly specifies location: false).\n        // This causes the original url to be replaced with the url for the redirect target\n        // so the original url disappears from the browser history.\n        if (this.options().source === 'url' && targetState.options().location !== false) {\n            redirectOpts.location = 'replace';\n        }\n        var newOptions = common_1.extend({}, this.options(), targetState.options(), redirectOpts);\n        targetState = targetState.withOptions(newOptions, true);\n        var newTransition = this.router.transitionService.create(this._treeChanges.from, targetState);\n        var originalEnteringNodes = this._treeChanges.entering;\n        var redirectEnteringNodes = newTransition._treeChanges.entering;\n        // --- Re-use resolve data from original transition ---\n        // When redirecting from a parent state to a child state where the parent parameter values haven't changed\n        // (because of the redirect), the resolves fetched by the original transition are still valid in the\n        // redirected transition.\n        //\n        // This allows you to define a redirect on a parent state which depends on an async resolve value.\n        // You can wait for the resolve, then redirect to a child state based on the result.\n        // The redirected transition does not have to re-fetch the resolve.\n        // ---------------------------------------------------------\n        var nodeIsReloading = function (reloadState) { return function (node) {\n            return reloadState && node.state.includes[reloadState.name];\n        }; };\n        // Find any \"entering\" nodes in the redirect path that match the original path and aren't being reloaded\n        var matchingEnteringNodes = pathUtils_1.PathUtils.matching(redirectEnteringNodes, originalEnteringNodes, pathUtils_1.PathUtils.nonDynamicParams).filter(hof_1.not(nodeIsReloading(targetState.options().reloadState)));\n        // Use the existing (possibly pre-resolved) resolvables for the matching entering nodes.\n        matchingEnteringNodes.forEach(function (node, idx) {\n            node.resolvables = originalEnteringNodes[idx].resolvables;\n        });\n        return newTransition;\n    };\n    /** @hidden If a transition doesn't exit/enter any states, returns any [[Param]] whose value changed */\n    Transition.prototype._changedParams = function () {\n        var tc = this._treeChanges;\n        /** Return undefined if it's not a \"dynamic\" transition, for the following reasons */\n        // If user explicitly wants a reload\n        if (this._options.reload)\n            return undefined;\n        // If any states are exiting or entering\n        if (tc.exiting.length || tc.entering.length)\n            return undefined;\n        // If to/from path lengths differ\n        if (tc.to.length !== tc.from.length)\n            return undefined;\n        // If the to/from paths are different\n        var pathsDiffer = common_1.arrayTuples(tc.to, tc.from)\n            .map(function (tuple) { return tuple[0].state !== tuple[1].state; })\n            .reduce(common_1.anyTrueR, false);\n        if (pathsDiffer)\n            return undefined;\n        // Find any parameter values that differ\n        var nodeSchemas = tc.to.map(function (node) { return node.paramSchema; });\n        var _a = [tc.to, tc.from].map(function (path) { return path.map(function (x) { return x.paramValues; }); }), toValues = _a[0], fromValues = _a[1];\n        var tuples = common_1.arrayTuples(nodeSchemas, toValues, fromValues);\n        return tuples.map(function (_a) {\n            var schema = _a[0], toVals = _a[1], fromVals = _a[2];\n            return param_1.Param.changed(schema, toVals, fromVals);\n        }).reduce(common_1.unnestR, []);\n    };\n    /**\n     * Returns true if the transition is dynamic.\n     *\n     * A transition is dynamic if no states are entered nor exited, but at least one dynamic parameter has changed.\n     *\n     * @returns true if the Transition is dynamic\n     */\n    Transition.prototype.dynamic = function () {\n        var changes = this._changedParams();\n        return !changes ? false : changes.map(function (x) { return x.dynamic; }).reduce(common_1.anyTrueR, false);\n    };\n    /**\n     * Returns true if the transition is ignored.\n     *\n     * A transition is ignored if no states are entered nor exited, and no parameter values have changed.\n     *\n     * @returns true if the Transition is ignored.\n     */\n    Transition.prototype.ignored = function () {\n        return !!this._ignoredReason();\n    };\n    /** @hidden */\n    Transition.prototype._ignoredReason = function () {\n        var pending = this.router.globals.transition;\n        var reloadState = this._options.reloadState;\n        var same = function (pathA, pathB) {\n            if (pathA.length !== pathB.length)\n                return false;\n            var matching = pathUtils_1.PathUtils.matching(pathA, pathB);\n            return pathA.length === matching.filter(function (node) { return !reloadState || !node.state.includes[reloadState.name]; }).length;\n        };\n        var newTC = this.treeChanges();\n        var pendTC = pending && pending.treeChanges();\n        if (pendTC && same(pendTC.to, newTC.to) && same(pendTC.exiting, newTC.exiting))\n            return 'SameAsPending';\n        if (newTC.exiting.length === 0 && newTC.entering.length === 0 && same(newTC.from, newTC.to))\n            return 'SameAsCurrent';\n    };\n    /**\n     * Runs the transition\n     *\n     * This method is generally called from the [[StateService.transitionTo]]\n     *\n     * @internalapi\n     *\n     * @returns a promise for a successful transition.\n     */\n    Transition.prototype.run = function () {\n        var _this = this;\n        var runAllHooks = transitionHook_1.TransitionHook.runAllHooks;\n        // Gets transition hooks array for the given phase\n        var getHooksFor = function (phase) { return _this._hookBuilder.buildHooksForPhase(phase); };\n        // When the chain is complete, then resolve or reject the deferred\n        var transitionSuccess = function () {\n            trace_1.trace.traceSuccess(_this.$to(), _this);\n            _this.success = true;\n            _this._deferred.resolve(_this.to());\n            runAllHooks(getHooksFor(interface_1.TransitionHookPhase.SUCCESS));\n        };\n        var transitionError = function (reason) {\n            trace_1.trace.traceError(reason, _this);\n            _this.success = false;\n            _this._deferred.reject(reason);\n            _this._error = reason;\n            runAllHooks(getHooksFor(interface_1.TransitionHookPhase.ERROR));\n        };\n        var runTransition = function () {\n            // Wait to build the RUN hook chain until the BEFORE hooks are done\n            // This allows a BEFORE hook to dynamically add additional RUN hooks via the Transition object.\n            var allRunHooks = getHooksFor(interface_1.TransitionHookPhase.RUN);\n            var done = function () { return coreservices_1.services.$q.when(undefined); };\n            return transitionHook_1.TransitionHook.invokeHooks(allRunHooks, done);\n        };\n        var startTransition = function () {\n            var globals = _this.router.globals;\n            globals.lastStartedTransitionId = _this.$id;\n            globals.transition = _this;\n            globals.transitionHistory.enqueue(_this);\n            trace_1.trace.traceTransitionStart(_this);\n            return coreservices_1.services.$q.when(undefined);\n        };\n        var allBeforeHooks = getHooksFor(interface_1.TransitionHookPhase.BEFORE);\n        transitionHook_1.TransitionHook.invokeHooks(allBeforeHooks, startTransition)\n            .then(runTransition)\n            .then(transitionSuccess, transitionError);\n        return this.promise;\n    };\n    /**\n     * Checks if the Transition is valid\n     *\n     * @returns true if the Transition is valid\n     */\n    Transition.prototype.valid = function () {\n        return !this.error() || this.success !== undefined;\n    };\n    /**\n     * Aborts this transition\n     *\n     * Imperative API to abort a Transition.\n     * This only applies to Transitions that are not yet complete.\n     */\n    Transition.prototype.abort = function () {\n        // Do not set flag if the transition is already complete\n        if (predicates_1.isUndefined(this.success)) {\n            this._aborted = true;\n        }\n    };\n    /**\n     * The Transition error reason.\n     *\n     * If the transition is invalid (and could not be run), returns the reason the transition is invalid.\n     * If the transition was valid and ran, but was not successful, returns the reason the transition failed.\n     *\n     * @returns a transition rejection explaining why the transition is invalid, or the reason the transition failed.\n     */\n    Transition.prototype.error = function () {\n        var state = this.$to();\n        if (state.self.abstract) {\n            return rejectFactory_1.Rejection.invalid(\"Cannot transition to abstract state '\" + state.name + \"'\");\n        }\n        var paramDefs = state.parameters();\n        var values = this.params();\n        var invalidParams = paramDefs.filter(function (param) { return !param.validates(values[param.id]); });\n        if (invalidParams.length) {\n            var invalidValues = invalidParams.map(function (param) { return \"[\" + param.id + \":\" + strings_1.stringify(values[param.id]) + \"]\"; }).join(', ');\n            var detail = \"The following parameter values are not valid for state '\" + state.name + \"': \" + invalidValues;\n            return rejectFactory_1.Rejection.invalid(detail);\n        }\n        if (this.success === false)\n            return this._error;\n    };\n    /**\n     * A string representation of the Transition\n     *\n     * @returns A string representation of the Transition\n     */\n    Transition.prototype.toString = function () {\n        var fromStateOrName = this.from();\n        var toStateOrName = this.to();\n        var avoidEmptyHash = function (params) {\n            return params['#'] !== null && params['#'] !== undefined ? params : common_1.omit(params, ['#']);\n        };\n        // (X) means the to state is invalid.\n        var id = this.$id, from = predicates_1.isObject(fromStateOrName) ? fromStateOrName.name : fromStateOrName, fromParams = strings_1.stringify(avoidEmptyHash(this._treeChanges.from.map(hof_1.prop('paramValues')).reduce(common_1.mergeR, {}))), toValid = this.valid() ? '' : '(X) ', to = predicates_1.isObject(toStateOrName) ? toStateOrName.name : toStateOrName, toParams = strings_1.stringify(avoidEmptyHash(this.params()));\n        return \"Transition#\" + id + \"( '\" + from + \"'\" + fromParams + \" -> \" + toValid + \"'\" + to + \"'\" + toParams + \" )\";\n    };\n    /** @hidden */\n    Transition.diToken = Transition;\n    return Transition;\n}());\nexports.Transition = Transition;\n//# sourceMappingURL=transition.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar transitionHook_1 = require(\"./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 */\nvar TransitionEventType = /** @class */ (function () {\n    /* tslint:disable:no-inferrable-types */\n    function TransitionEventType(name, hookPhase, hookOrder, criteriaMatchPath, reverseSort, getResultHandler, getErrorHandler, synchronous) {\n        if (reverseSort === void 0) { reverseSort = false; }\n        if (getResultHandler === void 0) { getResultHandler = transitionHook_1.TransitionHook.HANDLE_RESULT; }\n        if (getErrorHandler === void 0) { getErrorHandler = transitionHook_1.TransitionHook.REJECT_ERROR; }\n        if (synchronous === void 0) { synchronous = false; }\n        this.name = name;\n        this.hookPhase = hookPhase;\n        this.hookOrder = hookOrder;\n        this.criteriaMatchPath = criteriaMatchPath;\n        this.reverseSort = reverseSort;\n        this.getResultHandler = getResultHandler;\n        this.getErrorHandler = getErrorHandler;\n        this.synchronous = synchronous;\n    }\n    return TransitionEventType;\n}());\nexports.TransitionEventType = TransitionEventType;\n//# sourceMappingURL=transitionEventType.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module transition\n */\n/** for typedoc */\nvar interface_1 = require(\"./interface\");\nvar common_1 = require(\"../common/common\");\nvar strings_1 = require(\"../common/strings\");\nvar predicates_1 = require(\"../common/predicates\");\nvar hof_1 = require(\"../common/hof\");\nvar trace_1 = require(\"../common/trace\");\nvar coreservices_1 = require(\"../common/coreservices\");\nvar rejectFactory_1 = require(\"./rejectFactory\");\nvar targetState_1 = require(\"../state/targetState\");\nvar defaultOptions = {\n    current: common_1.noop,\n    transition: null,\n    traceData: {},\n    bind: null,\n};\n/** @hidden */\nvar TransitionHook = /** @class */ (function () {\n    function TransitionHook(transition, stateContext, registeredHook, options) {\n        var _this = this;\n        this.transition = transition;\n        this.stateContext = stateContext;\n        this.registeredHook = registeredHook;\n        this.options = options;\n        this.isSuperseded = function () { return _this.type.hookPhase === interface_1.TransitionHookPhase.RUN && !_this.options.transition.isActive(); };\n        this.options = common_1.defaults(options, defaultOptions);\n        this.type = registeredHook.eventType;\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    TransitionHook.chain = function (hooks, waitFor) {\n        // Chain the next hook off the previous\n        var createHookChainR = function (prev, nextHook) { return prev.then(function () { return nextHook.invokeHook(); }); };\n        return hooks.reduce(createHookChainR, waitFor || coreservices_1.services.$q.when());\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    TransitionHook.invokeHooks = function (hooks, doneCallback) {\n        for (var idx = 0; idx < hooks.length; idx++) {\n            var hookResult = hooks[idx].invokeHook();\n            if (predicates_1.isPromise(hookResult)) {\n                var remainingHooks = hooks.slice(idx + 1);\n                return TransitionHook.chain(remainingHooks, hookResult).then(doneCallback);\n            }\n        }\n        return doneCallback();\n    };\n    /**\n     * Run all TransitionHooks, ignoring their return value.\n     */\n    TransitionHook.runAllHooks = function (hooks) {\n        hooks.forEach(function (hook) { return hook.invokeHook(); });\n    };\n    TransitionHook.prototype.logError = function (err) {\n        this.transition.router.stateService.defaultErrorHandler()(err);\n    };\n    TransitionHook.prototype.invokeHook = function () {\n        var _this = this;\n        var hook = this.registeredHook;\n        if (hook._deregistered)\n            return;\n        var notCurrent = this.getNotCurrentRejection();\n        if (notCurrent)\n            return notCurrent;\n        var options = this.options;\n        trace_1.trace.traceHookInvocation(this, this.transition, options);\n        var invokeCallback = function () { return hook.callback.call(options.bind, _this.transition, _this.stateContext); };\n        var normalizeErr = function (err) { return rejectFactory_1.Rejection.normalize(err).toPromise(); };\n        var handleError = function (err) { return hook.eventType.getErrorHandler(_this)(err); };\n        var handleResult = function (result) { return hook.eventType.getResultHandler(_this)(result); };\n        try {\n            var result = invokeCallback();\n            if (!this.type.synchronous && predicates_1.isPromise(result)) {\n                return result.catch(normalizeErr).then(handleResult, handleError);\n            }\n            else {\n                return handleResult(result);\n            }\n        }\n        catch (err) {\n            // If callback throws (synchronously)\n            return handleError(rejectFactory_1.Rejection.normalize(err));\n        }\n        finally {\n            if (hook.invokeLimit && ++hook.invokeCount >= hook.invokeLimit) {\n                hook.deregister();\n            }\n        }\n    };\n    /**\n     * This method handles the return value of a Transition Hook.\n     *\n     * A hook can return false (cancel), a TargetState (redirect),\n     * or a promise (which may later resolve to false or a redirect)\n     *\n     * This also handles \"transition superseded\" -- when a new transition\n     * was started while the hook was still running\n     */\n    TransitionHook.prototype.handleHookResult = function (result) {\n        var _this = this;\n        var notCurrent = this.getNotCurrentRejection();\n        if (notCurrent)\n            return notCurrent;\n        // Hook returned a promise\n        if (predicates_1.isPromise(result)) {\n            // Wait for the promise, then reprocess with the resulting value\n            return result.then(function (val) { return _this.handleHookResult(val); });\n        }\n        trace_1.trace.traceHookResult(result, this.transition, this.options);\n        // Hook returned false\n        if (result === false) {\n            // Abort this Transition\n            return rejectFactory_1.Rejection.aborted('Hook aborted transition').toPromise();\n        }\n        var isTargetState = hof_1.is(targetState_1.TargetState);\n        // hook returned a TargetState\n        if (isTargetState(result)) {\n            // Halt the current Transition and redirect (a new Transition) to the TargetState.\n            return rejectFactory_1.Rejection.redirected(result).toPromise();\n        }\n    };\n    /**\n     * Return a Rejection promise if the transition is no longer current due\n     * to a stopped router (disposed), or a new transition has started and superseded this one.\n     */\n    TransitionHook.prototype.getNotCurrentRejection = function () {\n        var router = this.transition.router;\n        // The router is stopped\n        if (router._disposed) {\n            return rejectFactory_1.Rejection.aborted(\"UIRouter instance #\" + router.$id + \" has been stopped (disposed)\").toPromise();\n        }\n        if (this.transition._aborted) {\n            return rejectFactory_1.Rejection.aborted().toPromise();\n        }\n        // This transition is no longer current.\n        // Another transition started while this hook was still running.\n        if (this.isSuperseded()) {\n            // Abort this transition\n            return rejectFactory_1.Rejection.superseded(this.options.current()).toPromise();\n        }\n    };\n    TransitionHook.prototype.toString = function () {\n        var _a = this, options = _a.options, registeredHook = _a.registeredHook;\n        var event = hof_1.parse('traceData.hookType')(options) || 'internal', context = hof_1.parse('traceData.context.state.name')(options) || hof_1.parse('traceData.context')(options) || 'unknown', name = strings_1.fnToString(registeredHook.callback);\n        return event + \" context: \" + context + \", \" + strings_1.maxLength(200, name);\n    };\n    /**\n     * These GetResultHandler(s) are used by [[invokeHook]] below\n     * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])\n     */\n    TransitionHook.HANDLE_RESULT = function (hook) { return function (result) {\n        return hook.handleHookResult(result);\n    }; };\n    /**\n     * If the result is a promise rejection, log it.\n     * Otherwise, ignore the result.\n     */\n    TransitionHook.LOG_REJECTED_RESULT = function (hook) { return function (result) {\n        predicates_1.isPromise(result) && result.catch(function (err) { return hook.logError(rejectFactory_1.Rejection.normalize(err)); });\n        return undefined;\n    }; };\n    /**\n     * These GetErrorHandler(s) are used by [[invokeHook]] below\n     * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])\n     */\n    TransitionHook.LOG_ERROR = function (hook) { return function (error) { return hook.logError(error); }; };\n    TransitionHook.REJECT_ERROR = function (hook) { return function (error) { return common_1.silentRejection(error); }; };\n    TransitionHook.THROW_ERROR = function (hook) { return function (error) {\n        throw error;\n    }; };\n    return TransitionHook;\n}());\nexports.TransitionHook = TransitionHook;\n//# sourceMappingURL=transitionHook.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module transition\n */\n/** for typedoc */\nvar interface_1 = require(\"./interface\");\nvar transition_1 = require(\"./transition\");\nvar hookRegistry_1 = require(\"./hookRegistry\");\nvar coreResolvables_1 = require(\"../hooks/coreResolvables\");\nvar redirectTo_1 = require(\"../hooks/redirectTo\");\nvar onEnterExitRetain_1 = require(\"../hooks/onEnterExitRetain\");\nvar resolve_1 = require(\"../hooks/resolve\");\nvar views_1 = require(\"../hooks/views\");\nvar updateGlobals_1 = require(\"../hooks/updateGlobals\");\nvar url_1 = require(\"../hooks/url\");\nvar lazyLoad_1 = require(\"../hooks/lazyLoad\");\nvar transitionEventType_1 = require(\"./transitionEventType\");\nvar transitionHook_1 = require(\"./transitionHook\");\nvar predicates_1 = require(\"../common/predicates\");\nvar common_1 = require(\"../common/common\");\nvar hof_1 = require(\"../common/hof\");\nvar ignoredTransition_1 = require(\"../hooks/ignoredTransition\");\nvar invalidTransition_1 = require(\"../hooks/invalidTransition\");\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 */\nexports.defaultTransOpts = {\n    location: true,\n    relative: null,\n    inherit: false,\n    notify: true,\n    reload: false,\n    custom: {},\n    current: function () { return null; },\n    source: 'unknown',\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 */\nvar TransitionService = /** @class */ (function () {\n    /** @hidden */\n    function TransitionService(_router) {\n        /** @hidden */\n        this._transitionCount = 0;\n        /** @hidden The transition hook types, such as `onEnter`, `onStart`, etc */\n        this._eventTypes = [];\n        /** @hidden The registered transition hooks */\n        this._registeredHooks = {};\n        /** @hidden The  paths on a criteria object */\n        this._criteriaPaths = {};\n        this._router = _router;\n        this.$view = _router.viewService;\n        this._deregisterHookFns = {};\n        this._pluginapi = common_1.createProxyFunctions(hof_1.val(this), {}, hof_1.val(this), [\n            '_definePathType',\n            '_defineEvent',\n            '_getPathTypes',\n            '_getEvents',\n            'getHooks',\n        ]);\n        this._defineCorePaths();\n        this._defineCoreEvents();\n        this._registerCoreTransitionHooks();\n        _router.globals.successfulTransitions.onEvict(coreResolvables_1.treeChangesCleanup);\n    }\n    /**\n     * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.\n     *\n     * Registers a transition lifecycle hook, which is invoked during transition construction.\n     *\n     * This low level hook should only be used by plugins.\n     * This can be a useful time for plugins to add resolves or mutate the transition as needed.\n     * The Sticky States plugin uses this hook to modify the treechanges.\n     *\n     * ### Lifecycle\n     *\n     * `onCreate` hooks are invoked *while a transition is being constructed*.\n     *\n     * ### Return value\n     *\n     * The hook's return value is ignored\n     *\n     * @internalapi\n     * @param criteria defines which Transitions the Hook should be invoked for.\n     * @param callback the hook function which will be invoked.\n     * @param options the registration options\n     * @returns a function which deregisters the hook.\n     */\n    TransitionService.prototype.onCreate = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    TransitionService.prototype.onBefore = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    TransitionService.prototype.onStart = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    TransitionService.prototype.onExit = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    TransitionService.prototype.onRetain = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    TransitionService.prototype.onEnter = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    TransitionService.prototype.onFinish = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    TransitionService.prototype.onSuccess = function (criteria, callback, options) {\n        return;\n    };\n    /** @inheritdoc */\n    TransitionService.prototype.onError = function (criteria, callback, options) {\n        return;\n    };\n    /**\n     * dispose\n     * @internalapi\n     */\n    TransitionService.prototype.dispose = function (router) {\n        common_1.values(this._registeredHooks).forEach(function (hooksArray) {\n            return hooksArray.forEach(function (hook) {\n                hook._deregistered = true;\n                common_1.removeFrom(hooksArray, hook);\n            });\n        });\n    };\n    /**\n     * Creates a new [[Transition]] object\n     *\n     * This is a factory function for creating new Transition objects.\n     * It is used internally by the [[StateService]] and should generally not be called by application code.\n     *\n     * @param fromPath the path to the current state (the from state)\n     * @param targetState the target state (destination)\n     * @returns a Transition\n     */\n    TransitionService.prototype.create = function (fromPath, targetState) {\n        return new transition_1.Transition(fromPath, targetState, this._router);\n    };\n    /** @hidden */\n    TransitionService.prototype._defineCoreEvents = function () {\n        var Phase = interface_1.TransitionHookPhase;\n        var TH = transitionHook_1.TransitionHook;\n        var paths = this._criteriaPaths;\n        var NORMAL_SORT = false, REVERSE_SORT = true;\n        var SYNCHRONOUS = true;\n        this._defineEvent('onCreate', Phase.CREATE, 0, paths.to, NORMAL_SORT, TH.LOG_REJECTED_RESULT, TH.THROW_ERROR, SYNCHRONOUS);\n        this._defineEvent('onBefore', Phase.BEFORE, 0, paths.to);\n        this._defineEvent('onStart', Phase.RUN, 0, paths.to);\n        this._defineEvent('onExit', Phase.RUN, 100, paths.exiting, REVERSE_SORT);\n        this._defineEvent('onRetain', Phase.RUN, 200, paths.retained);\n        this._defineEvent('onEnter', Phase.RUN, 300, paths.entering);\n        this._defineEvent('onFinish', Phase.RUN, 400, paths.to);\n        this._defineEvent('onSuccess', Phase.SUCCESS, 0, paths.to, NORMAL_SORT, TH.LOG_REJECTED_RESULT, TH.LOG_ERROR, SYNCHRONOUS);\n        this._defineEvent('onError', Phase.ERROR, 0, paths.to, NORMAL_SORT, TH.LOG_REJECTED_RESULT, TH.LOG_ERROR, SYNCHRONOUS);\n    };\n    /** @hidden */\n    TransitionService.prototype._defineCorePaths = function () {\n        var STATE = interface_1.TransitionHookScope.STATE, TRANSITION = interface_1.TransitionHookScope.TRANSITION;\n        this._definePathType('to', TRANSITION);\n        this._definePathType('from', TRANSITION);\n        this._definePathType('exiting', STATE);\n        this._definePathType('retained', STATE);\n        this._definePathType('entering', STATE);\n    };\n    /** @hidden */\n    TransitionService.prototype._defineEvent = function (name, hookPhase, hookOrder, criteriaMatchPath, reverseSort, getResultHandler, getErrorHandler, synchronous) {\n        if (reverseSort === void 0) { reverseSort = false; }\n        if (getResultHandler === void 0) { getResultHandler = transitionHook_1.TransitionHook.HANDLE_RESULT; }\n        if (getErrorHandler === void 0) { getErrorHandler = transitionHook_1.TransitionHook.REJECT_ERROR; }\n        if (synchronous === void 0) { synchronous = false; }\n        var eventType = new transitionEventType_1.TransitionEventType(name, hookPhase, hookOrder, criteriaMatchPath, reverseSort, getResultHandler, getErrorHandler, synchronous);\n        this._eventTypes.push(eventType);\n        hookRegistry_1.makeEvent(this, this, eventType);\n    };\n    /** @hidden */\n    // tslint:disable-next-line\n    TransitionService.prototype._getEvents = function (phase) {\n        var transitionHookTypes = predicates_1.isDefined(phase)\n            ? this._eventTypes.filter(function (type) { return type.hookPhase === phase; })\n            : this._eventTypes.slice();\n        return transitionHookTypes.sort(function (l, r) {\n            var cmpByPhase = l.hookPhase - r.hookPhase;\n            return cmpByPhase === 0 ? l.hookOrder - r.hookOrder : cmpByPhase;\n        });\n    };\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     * @hidden\n     */\n    TransitionService.prototype._definePathType = function (name, hookScope) {\n        this._criteriaPaths[name] = { name: name, scope: hookScope };\n    };\n    /** * @hidden */\n    // tslint:disable-next-line\n    TransitionService.prototype._getPathTypes = function () {\n        return this._criteriaPaths;\n    };\n    /** @hidden */\n    TransitionService.prototype.getHooks = function (hookName) {\n        return this._registeredHooks[hookName];\n    };\n    /** @hidden */\n    TransitionService.prototype._registerCoreTransitionHooks = function () {\n        var fns = this._deregisterHookFns;\n        fns.addCoreResolves = coreResolvables_1.registerAddCoreResolvables(this);\n        fns.ignored = ignoredTransition_1.registerIgnoredTransitionHook(this);\n        fns.invalid = invalidTransition_1.registerInvalidTransitionHook(this);\n        // Wire up redirectTo hook\n        fns.redirectTo = redirectTo_1.registerRedirectToHook(this);\n        // Wire up onExit/Retain/Enter state hooks\n        fns.onExit = onEnterExitRetain_1.registerOnExitHook(this);\n        fns.onRetain = onEnterExitRetain_1.registerOnRetainHook(this);\n        fns.onEnter = onEnterExitRetain_1.registerOnEnterHook(this);\n        // Wire up Resolve hooks\n        fns.eagerResolve = resolve_1.registerEagerResolvePath(this);\n        fns.lazyResolve = resolve_1.registerLazyResolveState(this);\n        fns.resolveAll = resolve_1.registerResolveRemaining(this);\n        // Wire up the View management hooks\n        fns.loadViews = views_1.registerLoadEnteringViews(this);\n        fns.activateViews = views_1.registerActivateViews(this);\n        // Updates global state after a transition\n        fns.updateGlobals = updateGlobals_1.registerUpdateGlobalState(this);\n        // After globals.current is updated at priority: 10000\n        fns.updateUrl = url_1.registerUpdateUrl(this);\n        // Lazy load state trees\n        fns.lazyLoad = lazyLoad_1.registerLazyLoadHook(this);\n    };\n    return TransitionService;\n}());\nexports.TransitionService = TransitionService;\n//# sourceMappingURL=transitionService.js.map","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./urlMatcher\"));\n__export(require(\"./urlMatcherFactory\"));\n__export(require(\"./urlRouter\"));\n__export(require(\"./urlRule\"));\n__export(require(\"./urlService\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module url\n */\n/** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar hof_1 = require(\"../common/hof\");\nvar predicates_1 = require(\"../common/predicates\");\nvar param_1 = require(\"../params/param\");\nvar strings_1 = require(\"../common/strings\");\n/** @hidden */\nfunction quoteRegExp(str, param) {\n    var surroundPattern = ['', ''], result = str.replace(/[\\\\\\[\\]\\^$*+?.()|{}]/g, '\\\\$&');\n    if (!param)\n        return result;\n    switch (param.squash) {\n        case false:\n            surroundPattern = ['(', ')' + (param.isOptional ? '?' : '')];\n            break;\n        case true:\n            result = result.replace(/\\/$/, '');\n            surroundPattern = ['(?:/(', ')|/)?'];\n            break;\n        default:\n            surroundPattern = [\"(\" + param.squash + \"|\", ')?'];\n            break;\n    }\n    return result + surroundPattern[0] + param.type.pattern.source + surroundPattern[1];\n}\n/** @hidden */\nvar memoizeTo = function (obj, _prop, fn) { return (obj[_prop] = obj[_prop] || fn()); };\n/** @hidden */\nvar splitOnSlash = strings_1.splitOnDelim('/');\n/**\n * Matches URLs against patterns.\n *\n * Matches URLs against patterns and extracts named parameters from the path or the search\n * part of the URL.\n *\n * A URL pattern consists of a path pattern, optionally followed by '?' and a list of search (query)\n * parameters. Multiple search parameter names are separated by '&'. Search parameters\n * do not influence whether or not a URL is matched, but their values are passed through into\n * the matched parameters returned by [[UrlMatcher.exec]].\n *\n * - *Path parameters* are defined using curly brace placeholders (`/somepath/{param}`)\n * or colon placeholders (`/somePath/:param`).\n *\n * - *A parameter RegExp* may be defined for a param after a colon\n * (`/somePath/{param:[a-zA-Z0-9]+}`) in a curly brace placeholder.\n * The regexp must match for the url to be matched.\n * Should the regexp itself contain curly braces, they must be in matched pairs or escaped with a backslash.\n *\n * Note: a RegExp parameter will encode its value using either [[ParamTypes.path]] or [[ParamTypes.query]].\n *\n * - *Custom parameter types* may also be specified after a colon (`/somePath/{param:int}`) in curly brace parameters.\n *   See [[UrlMatcherFactory.type]] for more information.\n *\n * - *Catch-all parameters* are defined using an asterisk placeholder (`/somepath/*catchallparam`).\n *   A catch-all * parameter value will contain the remainder of the URL.\n *\n * ---\n *\n * Parameter names may contain only word characters (latin letters, digits, and underscore) and\n * must be unique within the pattern (across both path and search parameters).\n * A path parameter matches any number of characters other than '/'. For catch-all\n * placeholders the path parameter matches any number of characters.\n *\n * Examples:\n *\n * * `'/hello/'` - Matches only if the path is exactly '/hello/'. There is no special treatment for\n *   trailing slashes, and patterns have to match the entire path, not just a prefix.\n * * `'/user/:id'` - Matches '/user/bob' or '/user/1234!!!' or even '/user/' but not '/user' or\n *   '/user/bob/details'. The second path segment will be captured as the parameter 'id'.\n * * `'/user/{id}'` - Same as the previous example, but using curly brace syntax.\n * * `'/user/{id:[^/]*}'` - Same as the previous example.\n * * `'/user/{id:[0-9a-fA-F]{1,8}}'` - Similar to the previous example, but only matches if the id\n *   parameter consists of 1 to 8 hex digits.\n * * `'/files/{path:.*}'` - Matches any URL starting with '/files/' and captures the rest of the\n *   path into the parameter 'path'.\n * * `'/files/*path'` - ditto.\n * * `'/calendar/{start:date}'` - Matches \"/calendar/2014-11-12\" (because the pattern defined\n *   in the built-in  `date` ParamType matches `2014-11-12`) and provides a Date object in $stateParams.start\n *\n */\nvar UrlMatcher = /** @class */ (function () {\n    /**\n     * @param pattern The pattern to compile into a matcher.\n     * @param paramTypes The [[ParamTypes]] registry\n     * @param config  A configuration object\n     * - `caseInsensitive` - `true` if URL matching should be case insensitive, otherwise `false`, the default value (for backward compatibility) is `false`.\n     * - `strict` - `false` if matching against a URL with a trailing slash should be treated as equivalent to a URL without a trailing slash, the default value is `true`.\n     */\n    function UrlMatcher(pattern, paramTypes, paramFactory, config) {\n        var _this = this;\n        this.config = config;\n        /** @hidden */\n        this._cache = { path: [this] };\n        /** @hidden */\n        this._children = [];\n        /** @hidden */\n        this._params = [];\n        /** @hidden */\n        this._segments = [];\n        /** @hidden */\n        this._compiled = [];\n        this.pattern = pattern;\n        this.config = common_1.defaults(this.config, {\n            params: {},\n            strict: true,\n            caseInsensitive: false,\n            paramMap: common_1.identity,\n        });\n        // Find all placeholders and create a compiled pattern, using either classic or curly syntax:\n        //   '*' name\n        //   ':' name\n        //   '{' name '}'\n        //   '{' name ':' regexp '}'\n        // The regular expression is somewhat complicated due to the need to allow curly braces\n        // inside the regular expression. The placeholder regexp breaks down as follows:\n        //    ([:*])([\\w\\[\\]]+)              - classic placeholder ($1 / $2) (search version has - for snake-case)\n        //    \\{([\\w\\[\\]]+)(?:\\:\\s*( ... ))?\\}  - curly brace placeholder ($3) with optional regexp/type ... ($4) (search version has - for snake-case\n        //    (?: ... | ... | ... )+         - the regexp consists of any number of atoms, an atom being either\n        //    [^{}\\\\]+                       - anything other than curly braces or backslash\n        //    \\\\.                            - a backslash escape\n        //    \\{(?:[^{}\\\\]+|\\\\.)*\\}          - a matched set of curly braces containing other atoms\n        var placeholder = /([:*])([\\w\\[\\]]+)|\\{([\\w\\[\\]]+)(?:\\:\\s*((?:[^{}\\\\]+|\\\\.|\\{(?:[^{}\\\\]+|\\\\.)*\\})+))?\\}/g;\n        var searchPlaceholder = /([:]?)([\\w\\[\\].-]+)|\\{([\\w\\[\\].-]+)(?:\\:\\s*((?:[^{}\\\\]+|\\\\.|\\{(?:[^{}\\\\]+|\\\\.)*\\})+))?\\}/g;\n        var patterns = [];\n        var last = 0, matchArray;\n        var checkParamErrors = function (id) {\n            if (!UrlMatcher.nameValidator.test(id))\n                throw new Error(\"Invalid parameter name '\" + id + \"' in pattern '\" + pattern + \"'\");\n            if (common_1.find(_this._params, hof_1.propEq('id', id)))\n                throw new Error(\"Duplicate parameter name '\" + id + \"' in pattern '\" + pattern + \"'\");\n        };\n        // Split into static segments separated by path parameter placeholders.\n        // The number of segments is always 1 more than the number of parameters.\n        var matchDetails = function (m, isSearch) {\n            // IE[78] returns '' for unmatched groups instead of null\n            var id = m[2] || m[3];\n            var regexp = isSearch ? m[4] : m[4] || (m[1] === '*' ? '[\\\\s\\\\S]*' : null);\n            var makeRegexpType = function (str) {\n                return common_1.inherit(paramTypes.type(isSearch ? 'query' : 'path'), {\n                    pattern: new RegExp(str, _this.config.caseInsensitive ? 'i' : undefined),\n                });\n            };\n            return {\n                id: id,\n                regexp: regexp,\n                cfg: _this.config.params[id],\n                segment: pattern.substring(last, m.index),\n                type: !regexp ? null : paramTypes.type(regexp) || makeRegexpType(regexp),\n            };\n        };\n        var p, segment;\n        // tslint:disable-next-line:no-conditional-assignment\n        while ((matchArray = placeholder.exec(pattern))) {\n            p = matchDetails(matchArray, false);\n            if (p.segment.indexOf('?') >= 0)\n                break; // we're into the search part\n            checkParamErrors(p.id);\n            this._params.push(paramFactory.fromPath(p.id, p.type, this.config.paramMap(p.cfg, false)));\n            this._segments.push(p.segment);\n            patterns.push([p.segment, common_1.tail(this._params)]);\n            last = placeholder.lastIndex;\n        }\n        segment = pattern.substring(last);\n        // Find any search parameter names and remove them from the last segment\n        var i = segment.indexOf('?');\n        if (i >= 0) {\n            var search = segment.substring(i);\n            segment = segment.substring(0, i);\n            if (search.length > 0) {\n                last = 0;\n                // tslint:disable-next-line:no-conditional-assignment\n                while ((matchArray = searchPlaceholder.exec(search))) {\n                    p = matchDetails(matchArray, true);\n                    checkParamErrors(p.id);\n                    this._params.push(paramFactory.fromSearch(p.id, p.type, this.config.paramMap(p.cfg, true)));\n                    last = placeholder.lastIndex;\n                    // check if ?&\n                }\n            }\n        }\n        this._segments.push(segment);\n        this._compiled = patterns.map(function (_pattern) { return quoteRegExp.apply(null, _pattern); }).concat(quoteRegExp(segment));\n    }\n    /** @hidden */\n    UrlMatcher.encodeDashes = function (str) {\n        // Replace dashes with encoded \"\\-\"\n        return encodeURIComponent(str).replace(/-/g, function (c) {\n            return \"%5C%\" + c\n                .charCodeAt(0)\n                .toString(16)\n                .toUpperCase();\n        });\n    };\n    /** @hidden Given a matcher, return an array with the matcher's path segments and path params, in order */\n    UrlMatcher.pathSegmentsAndParams = function (matcher) {\n        var staticSegments = matcher._segments;\n        var pathParams = matcher._params.filter(function (p) { return p.location === param_1.DefType.PATH; });\n        return common_1.arrayTuples(staticSegments, pathParams.concat(undefined))\n            .reduce(common_1.unnestR, [])\n            .filter(function (x) { return x !== '' && predicates_1.isDefined(x); });\n    };\n    /** @hidden Given a matcher, return an array with the matcher's query params */\n    UrlMatcher.queryParams = function (matcher) {\n        return matcher._params.filter(function (p) { return p.location === param_1.DefType.SEARCH; });\n    };\n    /**\n     * Compare two UrlMatchers\n     *\n     * This comparison function converts a UrlMatcher into static and dynamic path segments.\n     * Each static path segment is a static string between a path separator (slash character).\n     * Each dynamic segment is a path parameter.\n     *\n     * The comparison function sorts static segments before dynamic ones.\n     */\n    UrlMatcher.compare = function (a, b) {\n        /**\n         * Turn a UrlMatcher and all its parent matchers into an array\n         * of slash literals '/', string literals, and Param objects\n         *\n         * This example matcher matches strings like \"/foo/:param/tail\":\n         * var matcher = $umf.compile(\"/foo\").append($umf.compile(\"/:param\")).append($umf.compile(\"/\")).append($umf.compile(\"tail\"));\n         * var result = segments(matcher); // [ '/', 'foo', '/', Param, '/', 'tail' ]\n         *\n         * Caches the result as `matcher._cache.segments`\n         */\n        var segments = function (matcher) {\n            return (matcher._cache.segments =\n                matcher._cache.segments ||\n                    matcher._cache.path\n                        .map(UrlMatcher.pathSegmentsAndParams)\n                        .reduce(common_1.unnestR, [])\n                        .reduce(strings_1.joinNeighborsR, [])\n                        .map(function (x) { return (predicates_1.isString(x) ? splitOnSlash(x) : x); })\n                        .reduce(common_1.unnestR, []));\n        };\n        /**\n         * Gets the sort weight for each segment of a UrlMatcher\n         *\n         * Caches the result as `matcher._cache.weights`\n         */\n        var weights = function (matcher) {\n            return (matcher._cache.weights =\n                matcher._cache.weights ||\n                    segments(matcher).map(function (segment) {\n                        // Sort slashes first, then static strings, the Params\n                        if (segment === '/')\n                            return 1;\n                        if (predicates_1.isString(segment))\n                            return 2;\n                        if (segment instanceof param_1.Param)\n                            return 3;\n                    }));\n        };\n        /**\n         * Pads shorter array in-place (mutates)\n         */\n        var padArrays = function (l, r, padVal) {\n            var len = Math.max(l.length, r.length);\n            while (l.length < len)\n                l.push(padVal);\n            while (r.length < len)\n                r.push(padVal);\n        };\n        var weightsA = weights(a), weightsB = weights(b);\n        padArrays(weightsA, weightsB, 0);\n        var _pairs = common_1.arrayTuples(weightsA, weightsB);\n        var cmp, i;\n        for (i = 0; i < _pairs.length; i++) {\n            cmp = _pairs[i][0] - _pairs[i][1];\n            if (cmp !== 0)\n                return cmp;\n        }\n        return 0;\n    };\n    /**\n     * Creates a new concatenated UrlMatcher\n     *\n     * Builds a new UrlMatcher by appending another UrlMatcher to this one.\n     *\n     * @param url A `UrlMatcher` instance to append as a child of the current `UrlMatcher`.\n     */\n    UrlMatcher.prototype.append = function (url) {\n        this._children.push(url);\n        url._cache = {\n            path: this._cache.path.concat(url),\n            parent: this,\n            pattern: null,\n        };\n        return url;\n    };\n    /** @hidden */\n    UrlMatcher.prototype.isRoot = function () {\n        return this._cache.path[0] === this;\n    };\n    /** Returns the input pattern string */\n    UrlMatcher.prototype.toString = function () {\n        return this.pattern;\n    };\n    /**\n     * Tests the specified url/path against this matcher.\n     *\n     * Tests if the given url matches this matcher's pattern, and returns an object containing the captured\n     * parameter values.  Returns null if the path does not match.\n     *\n     * The returned object contains the values\n     * of any search parameters that are mentioned in the pattern, but their value may be null if\n     * they are not present in `search`. This means that search parameters are always treated\n     * as optional.\n     *\n     * #### Example:\n     * ```js\n     * new UrlMatcher('/user/{id}?q&r').exec('/user/bob', {\n     *   x: '1', q: 'hello'\n     * });\n     * // returns { id: 'bob', q: 'hello', r: null }\n     * ```\n     *\n     * @param path    The URL path to match, e.g. `$location.path()`.\n     * @param search  URL search parameters, e.g. `$location.search()`.\n     * @param hash    URL hash e.g. `$location.hash()`.\n     * @param options\n     *\n     * @returns The captured parameter values.\n     */\n    UrlMatcher.prototype.exec = function (path, search, hash, options) {\n        var _this = this;\n        if (search === void 0) { search = {}; }\n        if (options === void 0) { options = {}; }\n        var match = memoizeTo(this._cache, 'pattern', function () {\n            return new RegExp([\n                '^',\n                common_1.unnest(_this._cache.path.map(hof_1.prop('_compiled'))).join(''),\n                _this.config.strict === false ? '/?' : '',\n                '$',\n            ].join(''), _this.config.caseInsensitive ? 'i' : undefined);\n        }).exec(path);\n        if (!match)\n            return null;\n        // options = defaults(options, { isolate: false });\n        var allParams = this.parameters(), pathParams = allParams.filter(function (param) { return !param.isSearch(); }), searchParams = allParams.filter(function (param) { return param.isSearch(); }), nPathSegments = this._cache.path.map(function (urlm) { return urlm._segments.length - 1; }).reduce(function (a, x) { return a + x; }), values = {};\n        if (nPathSegments !== match.length - 1)\n            throw new Error(\"Unbalanced capture group in route '\" + this.pattern + \"'\");\n        function decodePathArray(paramVal) {\n            var reverseString = function (str) {\n                return str\n                    .split('')\n                    .reverse()\n                    .join('');\n            };\n            var unquoteDashes = function (str) { return str.replace(/\\\\-/g, '-'); };\n            var split = reverseString(paramVal).split(/-(?!\\\\)/);\n            var allReversed = common_1.map(split, reverseString);\n            return common_1.map(allReversed, unquoteDashes).reverse();\n        }\n        for (var i = 0; i < nPathSegments; i++) {\n            var param = pathParams[i];\n            var value = match[i + 1];\n            // if the param value matches a pre-replace pair, replace the value before decoding.\n            for (var j = 0; j < param.replace.length; j++) {\n                if (param.replace[j].from === value)\n                    value = param.replace[j].to;\n            }\n            if (value && param.array === true)\n                value = decodePathArray(value);\n            if (predicates_1.isDefined(value))\n                value = param.type.decode(value);\n            values[param.id] = param.value(value);\n        }\n        searchParams.forEach(function (param) {\n            var value = search[param.id];\n            for (var j = 0; j < param.replace.length; j++) {\n                if (param.replace[j].from === value)\n                    value = param.replace[j].to;\n            }\n            if (predicates_1.isDefined(value))\n                value = param.type.decode(value);\n            values[param.id] = param.value(value);\n        });\n        if (hash)\n            values['#'] = hash;\n        return values;\n    };\n    /**\n     * @hidden\n     * Returns all the [[Param]] objects of all path and search parameters of this pattern in order of appearance.\n     *\n     * @returns {Array.<Param>}  An array of [[Param]] objects. Must be treated as read-only. If the\n     *    pattern has no parameters, an empty array is returned.\n     */\n    UrlMatcher.prototype.parameters = function (opts) {\n        if (opts === void 0) { opts = {}; }\n        if (opts.inherit === false)\n            return this._params;\n        return common_1.unnest(this._cache.path.map(function (matcher) { return matcher._params; }));\n    };\n    /**\n     * @hidden\n     * Returns a single parameter from this UrlMatcher by id\n     *\n     * @param id\n     * @param opts\n     * @returns {T|Param|any|boolean|UrlMatcher|null}\n     */\n    UrlMatcher.prototype.parameter = function (id, opts) {\n        var _this = this;\n        if (opts === void 0) { opts = {}; }\n        var findParam = function () {\n            for (var _i = 0, _a = _this._params; _i < _a.length; _i++) {\n                var param = _a[_i];\n                if (param.id === id)\n                    return param;\n            }\n        };\n        var parent = this._cache.parent;\n        return findParam() || (opts.inherit !== false && parent && parent.parameter(id, opts)) || null;\n    };\n    /**\n     * Validates the input parameter values against this UrlMatcher\n     *\n     * Checks an object hash of parameters to validate their correctness according to the parameter\n     * types of this `UrlMatcher`.\n     *\n     * @param params The object hash of parameters to validate.\n     * @returns Returns `true` if `params` validates, otherwise `false`.\n     */\n    UrlMatcher.prototype.validates = function (params) {\n        var validParamVal = function (param, val) { return !param || param.validates(val); };\n        params = params || {};\n        // I'm not sure why this checks only the param keys passed in, and not all the params known to the matcher\n        var paramSchema = this.parameters().filter(function (paramDef) { return params.hasOwnProperty(paramDef.id); });\n        return paramSchema.map(function (paramDef) { return validParamVal(paramDef, params[paramDef.id]); }).reduce(common_1.allTrueR, true);\n    };\n    /**\n     * Given a set of parameter values, creates a URL from this UrlMatcher.\n     *\n     * Creates a URL that matches this pattern by substituting the specified values\n     * for the path and search parameters.\n     *\n     * #### Example:\n     * ```js\n     * new UrlMatcher('/user/{id}?q').format({ id:'bob', q:'yes' });\n     * // returns '/user/bob?q=yes'\n     * ```\n     *\n     * @param values  the values to substitute for the parameters in this pattern.\n     * @returns the formatted URL (path and optionally search part).\n     */\n    UrlMatcher.prototype.format = function (values) {\n        if (values === void 0) { values = {}; }\n        // Build the full path of UrlMatchers (including all parent UrlMatchers)\n        var urlMatchers = this._cache.path;\n        // Extract all the static segments and Params (processed as ParamDetails)\n        // into an ordered array\n        var pathSegmentsAndParams = urlMatchers\n            .map(UrlMatcher.pathSegmentsAndParams)\n            .reduce(common_1.unnestR, [])\n            .map(function (x) { return (predicates_1.isString(x) ? x : getDetails(x)); });\n        // Extract the query params into a separate array\n        var queryParams = urlMatchers\n            .map(UrlMatcher.queryParams)\n            .reduce(common_1.unnestR, [])\n            .map(getDetails);\n        var isInvalid = function (param) { return param.isValid === false; };\n        if (pathSegmentsAndParams.concat(queryParams).filter(isInvalid).length) {\n            return null;\n        }\n        /**\n         * Given a Param, applies the parameter value, then returns detailed information about it\n         */\n        function getDetails(param) {\n            // Normalize to typed value\n            var value = param.value(values[param.id]);\n            var isValid = param.validates(value);\n            var isDefaultValue = param.isDefaultValue(value);\n            // Check if we're in squash mode for the parameter\n            var squash = isDefaultValue ? param.squash : false;\n            // Allow the Parameter's Type to encode the value\n            var encoded = param.type.encode(value);\n            return { param: param, value: value, isValid: isValid, isDefaultValue: isDefaultValue, squash: squash, encoded: encoded };\n        }\n        // Build up the path-portion from the list of static segments and parameters\n        var pathString = pathSegmentsAndParams.reduce(function (acc, x) {\n            // The element is a static segment (a raw string); just append it\n            if (predicates_1.isString(x))\n                return acc + x;\n            // Otherwise, it's a ParamDetails.\n            var squash = x.squash, encoded = x.encoded, param = x.param;\n            // If squash is === true, try to remove a slash from the path\n            if (squash === true)\n                return acc.match(/\\/$/) ? acc.slice(0, -1) : acc;\n            // If squash is a string, use the string for the param value\n            if (predicates_1.isString(squash))\n                return acc + squash;\n            if (squash !== false)\n                return acc; // ?\n            if (encoded == null)\n                return acc;\n            // If this parameter value is an array, encode the value using encodeDashes\n            if (predicates_1.isArray(encoded))\n                return acc + common_1.map(encoded, UrlMatcher.encodeDashes).join('-');\n            // If the parameter type is \"raw\", then do not encodeURIComponent\n            if (param.raw)\n                return acc + encoded;\n            // Encode the value\n            return acc + encodeURIComponent(encoded);\n        }, '');\n        // Build the query string by applying parameter values (array or regular)\n        // then mapping to key=value, then flattening and joining using \"&\"\n        var queryString = queryParams\n            .map(function (paramDetails) {\n            var param = paramDetails.param, squash = paramDetails.squash, encoded = paramDetails.encoded, isDefaultValue = paramDetails.isDefaultValue;\n            if (encoded == null || (isDefaultValue && squash !== false))\n                return;\n            if (!predicates_1.isArray(encoded))\n                encoded = [encoded];\n            if (encoded.length === 0)\n                return;\n            if (!param.raw)\n                encoded = common_1.map(encoded, encodeURIComponent);\n            return encoded.map(function (val) { return param.id + \"=\" + val; });\n        })\n            .filter(common_1.identity)\n            .reduce(common_1.unnestR, [])\n            .join('&');\n        // Concat the pathstring with the queryString (if exists) and the hashString (if exists)\n        return pathString + (queryString ? \"?\" + queryString : '') + (values['#'] ? '#' + values['#'] : '');\n    };\n    /** @hidden */\n    UrlMatcher.nameValidator = /^\\w+([-.]+\\w+)*(?:\\[\\])?$/;\n    return UrlMatcher;\n}());\nexports.UrlMatcher = UrlMatcher;\n//# sourceMappingURL=urlMatcher.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @internalapi\n * @module url\n */ /** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar predicates_1 = require(\"../common/predicates\");\nvar urlMatcher_1 = require(\"./urlMatcher\");\nvar param_1 = require(\"../params/param\");\nvar paramTypes_1 = require(\"../params/paramTypes\");\n/**\n * Factory for [[UrlMatcher]] instances.\n *\n * The factory is available to ng1 services as\n * `$urlMatcherFactory` or ng1 providers as `$urlMatcherFactoryProvider`.\n */\nvar UrlMatcherFactory = /** @class */ (function () {\n    function UrlMatcherFactory() {\n        var _this = this;\n        /** @hidden */ this.paramTypes = new paramTypes_1.ParamTypes();\n        /** @hidden */ this._isCaseInsensitive = false;\n        /** @hidden */ this._isStrictMode = true;\n        /** @hidden */ this._defaultSquashPolicy = false;\n        /** @internalapi Creates a new [[Param]] for a given location (DefType) */\n        this.paramFactory = {\n            /** Creates a new [[Param]] from a CONFIG block */\n            fromConfig: function (id, type, config) { return new param_1.Param(id, type, config, param_1.DefType.CONFIG, _this); },\n            /** Creates a new [[Param]] from a url PATH */\n            fromPath: function (id, type, config) { return new param_1.Param(id, type, config, param_1.DefType.PATH, _this); },\n            /** Creates a new [[Param]] from a url SEARCH */\n            fromSearch: function (id, type, config) { return new param_1.Param(id, type, config, param_1.DefType.SEARCH, _this); },\n        };\n        /** @hidden */\n        this._getConfig = function (config) {\n            return common_1.extend({ strict: _this._isStrictMode, caseInsensitive: _this._isCaseInsensitive }, config);\n        };\n        common_1.extend(this, { UrlMatcher: urlMatcher_1.UrlMatcher, Param: param_1.Param });\n    }\n    /** @inheritdoc */\n    UrlMatcherFactory.prototype.caseInsensitive = function (value) {\n        return (this._isCaseInsensitive = predicates_1.isDefined(value) ? value : this._isCaseInsensitive);\n    };\n    /** @inheritdoc */\n    UrlMatcherFactory.prototype.strictMode = function (value) {\n        return (this._isStrictMode = predicates_1.isDefined(value) ? value : this._isStrictMode);\n    };\n    /** @inheritdoc */\n    UrlMatcherFactory.prototype.defaultSquashPolicy = function (value) {\n        if (predicates_1.isDefined(value) && value !== true && value !== false && !predicates_1.isString(value))\n            throw new Error(\"Invalid squash policy: \" + value + \". Valid policies: false, true, arbitrary-string\");\n        return (this._defaultSquashPolicy = predicates_1.isDefined(value) ? value : this._defaultSquashPolicy);\n    };\n    /**\n     * Creates a [[UrlMatcher]] for the specified pattern.\n     *\n     * @param pattern  The URL pattern.\n     * @param config  The config object hash.\n     * @returns The UrlMatcher.\n     */\n    UrlMatcherFactory.prototype.compile = function (pattern, config) {\n        return new urlMatcher_1.UrlMatcher(pattern, this.paramTypes, this.paramFactory, this._getConfig(config));\n    };\n    /**\n     * Returns true if the specified object is a [[UrlMatcher]], or false otherwise.\n     *\n     * @param object  The object to perform the type check against.\n     * @returns `true` if the object matches the `UrlMatcher` interface, by\n     *          implementing all the same methods.\n     */\n    UrlMatcherFactory.prototype.isMatcher = function (object) {\n        // TODO: typeof?\n        if (!predicates_1.isObject(object))\n            return false;\n        var result = true;\n        common_1.forEach(urlMatcher_1.UrlMatcher.prototype, function (val, name) {\n            if (predicates_1.isFunction(val))\n                result = result && (predicates_1.isDefined(object[name]) && predicates_1.isFunction(object[name]));\n        });\n        return result;\n    };\n    /**\n     * Creates and registers a custom [[ParamType]] object\n     *\n     * A [[ParamType]] can be used to generate URLs with typed parameters.\n     *\n     * @param name  The type name.\n     * @param definition The type definition. See [[ParamTypeDefinition]] for information on the values accepted.\n     * @param definitionFn A function that is injected before the app runtime starts.\n     *        The result of this function should be a [[ParamTypeDefinition]].\n     *        The result is merged into the existing `definition`.\n     *        See [[ParamType]] for information on the values accepted.\n     *\n     * @returns - if a type was registered: the [[UrlMatcherFactory]]\n     *   - if only the `name` parameter was specified: the currently registered [[ParamType]] object, or undefined\n     *\n     * Note: Register custom types *before using them* in a state definition.\n     *\n     * See [[ParamTypeDefinition]] for examples\n     */\n    UrlMatcherFactory.prototype.type = function (name, definition, definitionFn) {\n        var type = this.paramTypes.type(name, definition, definitionFn);\n        return !predicates_1.isDefined(definition) ? type : this;\n    };\n    /** @hidden */\n    UrlMatcherFactory.prototype.$get = function () {\n        this.paramTypes.enqueue = false;\n        this.paramTypes._flushTypeQueue();\n        return this;\n    };\n    /** @internalapi */\n    UrlMatcherFactory.prototype.dispose = function () {\n        this.paramTypes.dispose();\n    };\n    return UrlMatcherFactory;\n}());\nexports.UrlMatcherFactory = UrlMatcherFactory;\n//# sourceMappingURL=urlMatcherFactory.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @internalapi\n * @module url\n */\n/** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar predicates_1 = require(\"../common/predicates\");\nvar urlMatcher_1 = require(\"./urlMatcher\");\nvar hof_1 = require(\"../common/hof\");\nvar urlRule_1 = require(\"./urlRule\");\nvar targetState_1 = require(\"../state/targetState\");\nvar common_2 = require(\"../common\");\n/** @hidden */\nfunction appendBasePath(url, isHtml5, absolute, baseHref) {\n    if (baseHref === '/')\n        return url;\n    if (isHtml5)\n        return common_2.stripLastPathElement(baseHref) + url;\n    if (absolute)\n        return baseHref.slice(1) + url;\n    return url;\n}\n/** @hidden */\nvar prioritySort = function (a, b) { return (b.priority || 0) - (a.priority || 0); };\n/** @hidden */\nvar typeSort = function (a, b) {\n    var weights = { STATE: 4, URLMATCHER: 4, REGEXP: 3, RAW: 2, OTHER: 1 };\n    return (weights[a.type] || 0) - (weights[b.type] || 0);\n};\n/** @hidden */\nvar urlMatcherSort = function (a, b) {\n    return !a.urlMatcher || !b.urlMatcher ? 0 : urlMatcher_1.UrlMatcher.compare(a.urlMatcher, b.urlMatcher);\n};\n/** @hidden */\nvar idSort = function (a, b) {\n    // Identically sorted STATE and URLMATCHER best rule will be chosen by `matchPriority` after each rule matches the URL\n    var useMatchPriority = { STATE: true, URLMATCHER: true };\n    var equal = useMatchPriority[a.type] && useMatchPriority[b.type];\n    return equal ? 0 : (a.$id || 0) - (b.$id || 0);\n};\n/**\n * Default rule priority sorting function.\n *\n * Sorts rules by:\n *\n * - Explicit priority (set rule priority using [[UrlRulesApi.when]])\n * - Rule type (STATE: 4, URLMATCHER: 4, REGEXP: 3, RAW: 2, OTHER: 1)\n * - `UrlMatcher` specificity ([[UrlMatcher.compare]]): works for STATE and URLMATCHER types to pick the most specific rule.\n * - Rule registration order (for rule types other than STATE and URLMATCHER)\n *   - Equally sorted State and UrlMatcher rules will each match the URL.\n *     Then, the *best* match is chosen based on how many parameter values were matched.\n *\n * @coreapi\n */\nvar defaultRuleSortFn;\ndefaultRuleSortFn = function (a, b) {\n    var cmp = prioritySort(a, b);\n    if (cmp !== 0)\n        return cmp;\n    cmp = typeSort(a, b);\n    if (cmp !== 0)\n        return cmp;\n    cmp = urlMatcherSort(a, b);\n    if (cmp !== 0)\n        return cmp;\n    return idSort(a, b);\n};\n/**\n * Updates URL and responds to URL changes\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 updates the URL when the state changes.\n * It also responds to changes in the URL.\n */\nvar UrlRouter = /** @class */ (function () {\n    /** @hidden */\n    function UrlRouter(router) {\n        /** @hidden */ this._sortFn = defaultRuleSortFn;\n        /** @hidden */ this._rules = [];\n        /** @hidden */ this.interceptDeferred = false;\n        /** @hidden */ this._id = 0;\n        /** @hidden */ this._sorted = false;\n        this._router = router;\n        this.urlRuleFactory = new urlRule_1.UrlRuleFactory(router);\n        common_1.createProxyFunctions(hof_1.val(UrlRouter.prototype), this, hof_1.val(this));\n    }\n    /** @internalapi */\n    UrlRouter.prototype.dispose = function () {\n        this.listen(false);\n        this._rules = [];\n        delete this._otherwiseFn;\n    };\n    /** @inheritdoc */\n    UrlRouter.prototype.sort = function (compareFn) {\n        this._rules = this.stableSort(this._rules, (this._sortFn = compareFn || this._sortFn));\n        this._sorted = true;\n    };\n    UrlRouter.prototype.ensureSorted = function () {\n        this._sorted || this.sort();\n    };\n    UrlRouter.prototype.stableSort = function (arr, compareFn) {\n        var arrOfWrapper = arr.map(function (elem, idx) { return ({ elem: elem, idx: idx }); });\n        arrOfWrapper.sort(function (wrapperA, wrapperB) {\n            var cmpDiff = compareFn(wrapperA.elem, wrapperB.elem);\n            return cmpDiff === 0 ? wrapperA.idx - wrapperB.idx : cmpDiff;\n        });\n        return arrOfWrapper.map(function (wrapper) { return wrapper.elem; });\n    };\n    /**\n     * Given a URL, check all rules and return the best [[MatchResult]]\n     * @param url\n     * @returns {MatchResult}\n     */\n    UrlRouter.prototype.match = function (url) {\n        var _this = this;\n        this.ensureSorted();\n        url = common_1.extend({ path: '', search: {}, hash: '' }, url);\n        var rules = this.rules();\n        if (this._otherwiseFn)\n            rules.push(this._otherwiseFn);\n        // Checks a single rule. Returns { rule: rule, match: match, weight: weight } if it matched, or undefined\n        var checkRule = function (rule) {\n            var match = rule.match(url, _this._router);\n            return match && { match: match, rule: rule, weight: rule.matchPriority(match) };\n        };\n        // The rules are pre-sorted.\n        // - Find the first matching rule.\n        // - Find any other matching rule that sorted *exactly the same*, according to `.sort()`.\n        // - Choose the rule with the highest match weight.\n        var best;\n        for (var i = 0; i < rules.length; i++) {\n            // Stop when there is a 'best' rule and the next rule sorts differently than it.\n            if (best && this._sortFn(rules[i], best.rule) !== 0)\n                break;\n            var current = checkRule(rules[i]);\n            // Pick the best MatchResult\n            best = !best || (current && current.weight > best.weight) ? current : best;\n        }\n        return best;\n    };\n    /** @inheritdoc */\n    UrlRouter.prototype.sync = function (evt) {\n        if (evt && evt.defaultPrevented)\n            return;\n        var router = this._router, $url = router.urlService, $state = router.stateService;\n        var url = {\n            path: $url.path(),\n            search: $url.search(),\n            hash: $url.hash(),\n        };\n        var best = this.match(url);\n        var applyResult = hof_1.pattern([\n            [predicates_1.isString, function (newurl) { return $url.url(newurl, true); }],\n            [targetState_1.TargetState.isDef, function (def) { return $state.go(def.state, def.params, def.options); }],\n            [hof_1.is(targetState_1.TargetState), function (target) { return $state.go(target.state(), target.params(), target.options()); }],\n        ]);\n        applyResult(best && best.rule.handler(best.match, url, router));\n    };\n    /** @inheritdoc */\n    UrlRouter.prototype.listen = function (enabled) {\n        var _this = this;\n        if (enabled === false) {\n            this._stopFn && this._stopFn();\n            delete this._stopFn;\n        }\n        else {\n            return (this._stopFn = this._stopFn || this._router.urlService.onChange(function (evt) { return _this.sync(evt); }));\n        }\n    };\n    /**\n     * Internal API.\n     * @internalapi\n     */\n    UrlRouter.prototype.update = function (read) {\n        var $url = this._router.locationService;\n        if (read) {\n            this.location = $url.url();\n            return;\n        }\n        if ($url.url() === this.location)\n            return;\n        $url.url(this.location, true);\n    };\n    /**\n     * Internal API.\n     *\n     * Pushes a new location to the browser history.\n     *\n     * @internalapi\n     * @param urlMatcher\n     * @param params\n     * @param options\n     */\n    UrlRouter.prototype.push = function (urlMatcher, params, options) {\n        var replace = options && !!options.replace;\n        this._router.urlService.url(urlMatcher.format(params || {}), replace);\n    };\n    /**\n     * Builds and returns a URL with interpolated parameters\n     *\n     * #### Example:\n     * ```js\n     * matcher = $umf.compile(\"/about/:person\");\n     * params = { person: \"bob\" };\n     * $bob = $urlRouter.href(matcher, params);\n     * // $bob == \"/about/bob\";\n     * ```\n     *\n     * @param urlMatcher The [[UrlMatcher]] object which is used as the template of the URL to generate.\n     * @param params An object of parameter values to fill the matcher's required parameters.\n     * @param options Options object. The options are:\n     *\n     * - **`absolute`** - {boolean=false},  If true will generate an absolute url, e.g. \"http://www.example.com/fullurl\".\n     *\n     * @returns Returns the fully compiled URL, or `null` if `params` fail validation against `urlMatcher`\n     */\n    UrlRouter.prototype.href = function (urlMatcher, params, options) {\n        var url = urlMatcher.format(params);\n        if (url == null)\n            return null;\n        options = options || { absolute: false };\n        var cfg = this._router.urlService.config;\n        var isHtml5 = cfg.html5Mode();\n        if (!isHtml5 && url !== null) {\n            url = '#' + cfg.hashPrefix() + url;\n        }\n        url = appendBasePath(url, isHtml5, options.absolute, cfg.baseHref());\n        if (!options.absolute || !url) {\n            return url;\n        }\n        var slash = !isHtml5 && url ? '/' : '';\n        var cfgPort = cfg.port();\n        var port = (cfgPort === 80 || cfgPort === 443 ? '' : ':' + cfgPort);\n        return [cfg.protocol(), '://', cfg.host(), port, slash, url].join('');\n    };\n    /**\n     * Manually adds a URL Rule.\n     *\n     * Usually, a url rule is added using [[StateDeclaration.url]] or [[when]].\n     * This api can be used directly for more control (to register a [[BaseUrlRule]], for example).\n     * Rules can be created using [[UrlRouter.urlRuleFactory]], or create manually as simple objects.\n     *\n     * A rule should have a `match` function which returns truthy if the rule matched.\n     * It should also have a `handler` function which is invoked if the rule is the best match.\n     *\n     * @return a function that deregisters the rule\n     */\n    UrlRouter.prototype.rule = function (rule) {\n        var _this = this;\n        if (!urlRule_1.UrlRuleFactory.isUrlRule(rule))\n            throw new Error('invalid rule');\n        rule.$id = this._id++;\n        rule.priority = rule.priority || 0;\n        this._rules.push(rule);\n        this._sorted = false;\n        return function () { return _this.removeRule(rule); };\n    };\n    /** @inheritdoc */\n    UrlRouter.prototype.removeRule = function (rule) {\n        common_1.removeFrom(this._rules, rule);\n    };\n    /** @inheritdoc */\n    UrlRouter.prototype.rules = function () {\n        this.ensureSorted();\n        return this._rules.slice();\n    };\n    /** @inheritdoc */\n    UrlRouter.prototype.otherwise = function (handler) {\n        var handlerFn = getHandlerFn(handler);\n        this._otherwiseFn = this.urlRuleFactory.create(hof_1.val(true), handlerFn);\n        this._sorted = false;\n    };\n    /** @inheritdoc */\n    UrlRouter.prototype.initial = function (handler) {\n        var handlerFn = getHandlerFn(handler);\n        var matchFn = function (urlParts, router) {\n            return router.globals.transitionHistory.size() === 0 && !!/^\\/?$/.exec(urlParts.path);\n        };\n        this.rule(this.urlRuleFactory.create(matchFn, handlerFn));\n    };\n    /** @inheritdoc */\n    UrlRouter.prototype.when = function (matcher, handler, options) {\n        var rule = this.urlRuleFactory.create(matcher, handler);\n        if (predicates_1.isDefined(options && options.priority))\n            rule.priority = options.priority;\n        this.rule(rule);\n        return rule;\n    };\n    /** @inheritdoc */\n    UrlRouter.prototype.deferIntercept = function (defer) {\n        if (defer === undefined)\n            defer = true;\n        this.interceptDeferred = defer;\n    };\n    return UrlRouter;\n}());\nexports.UrlRouter = UrlRouter;\nfunction getHandlerFn(handler) {\n    if (!predicates_1.isFunction(handler) && !predicates_1.isString(handler) && !hof_1.is(targetState_1.TargetState)(handler) && !targetState_1.TargetState.isDef(handler)) {\n        throw new Error(\"'handler' must be a string, function, TargetState, or have a state: 'newtarget' property\");\n    }\n    return predicates_1.isFunction(handler) ? handler : hof_1.val(handler);\n}\n//# sourceMappingURL=urlRouter.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module url\n */ /** */\nvar urlMatcher_1 = require(\"./urlMatcher\");\nvar predicates_1 = require(\"../common/predicates\");\nvar common_1 = require(\"../common/common\");\nvar hof_1 = require(\"../common/hof\");\n/**\n * Creates a [[UrlRule]]\n *\n * Creates a [[UrlRule]] from a:\n *\n * - `string`\n * - [[UrlMatcher]]\n * - `RegExp`\n * - [[StateObject]]\n * @internalapi\n */\nvar UrlRuleFactory = /** @class */ (function () {\n    function UrlRuleFactory(router) {\n        this.router = router;\n    }\n    UrlRuleFactory.prototype.compile = function (str) {\n        return this.router.urlMatcherFactory.compile(str);\n    };\n    UrlRuleFactory.prototype.create = function (what, handler) {\n        var _this = this;\n        var makeRule = hof_1.pattern([\n            [predicates_1.isString, function (_what) { return makeRule(_this.compile(_what)); }],\n            [hof_1.is(urlMatcher_1.UrlMatcher), function (_what) { return _this.fromUrlMatcher(_what, handler); }],\n            [predicates_1.isState, function (_what) { return _this.fromState(_what, _this.router); }],\n            [hof_1.is(RegExp), function (_what) { return _this.fromRegExp(_what, handler); }],\n            [predicates_1.isFunction, function (_what) { return new BaseUrlRule(_what, handler); }],\n        ]);\n        var rule = makeRule(what);\n        if (!rule)\n            throw new Error(\"invalid 'what' in when()\");\n        return rule;\n    };\n    /**\n     * A UrlRule which matches based on a UrlMatcher\n     *\n     * The `handler` may be either a `string`, a [[UrlRuleHandlerFn]] or another [[UrlMatcher]]\n     *\n     * ## Handler as a function\n     *\n     * If `handler` is a function, the function is invoked with:\n     *\n     * - matched parameter values ([[RawParams]] from [[UrlMatcher.exec]])\n     * - url: the current Url ([[UrlParts]])\n     * - router: the router object ([[UIRouter]])\n     *\n     * #### Example:\n     * ```js\n     * var urlMatcher = $umf.compile(\"/foo/:fooId/:barId\");\n     * var rule = factory.fromUrlMatcher(urlMatcher, match => \"/home/\" + match.fooId + \"/\" + match.barId);\n     * var match = rule.match('/foo/123/456'); // results in { fooId: '123', barId: '456' }\n     * var result = rule.handler(match); // '/home/123/456'\n     * ```\n     *\n     * ## Handler as UrlMatcher\n     *\n     * If `handler` is a UrlMatcher, the handler matcher is used to create the new url.\n     * The `handler` UrlMatcher is formatted using the matched param from the first matcher.\n     * The url is replaced with the result.\n     *\n     * #### Example:\n     * ```js\n     * var urlMatcher = $umf.compile(\"/foo/:fooId/:barId\");\n     * var handler = $umf.compile(\"/home/:fooId/:barId\");\n     * var rule = factory.fromUrlMatcher(urlMatcher, handler);\n     * var match = rule.match('/foo/123/456'); // results in { fooId: '123', barId: '456' }\n     * var result = rule.handler(match); // '/home/123/456'\n     * ```\n     */\n    UrlRuleFactory.prototype.fromUrlMatcher = function (urlMatcher, handler) {\n        var _handler = handler;\n        if (predicates_1.isString(handler))\n            handler = this.router.urlMatcherFactory.compile(handler);\n        if (hof_1.is(urlMatcher_1.UrlMatcher)(handler))\n            _handler = function (match) { return handler.format(match); };\n        function matchUrlParamters(url) {\n            var params = urlMatcher.exec(url.path, url.search, url.hash);\n            return urlMatcher.validates(params) && params;\n        }\n        // Prioritize URLs, lowest to highest:\n        // - Some optional URL parameters, but none matched\n        // - No optional parameters in URL\n        // - Some optional parameters, some matched\n        // - Some optional parameters, all matched\n        function matchPriority(params) {\n            var optional = urlMatcher.parameters().filter(function (param) { return param.isOptional; });\n            if (!optional.length)\n                return 0.000001;\n            var matched = optional.filter(function (param) { return params[param.id]; });\n            return matched.length / optional.length;\n        }\n        var details = { urlMatcher: urlMatcher, matchPriority: matchPriority, type: 'URLMATCHER' };\n        return common_1.extend(new BaseUrlRule(matchUrlParamters, _handler), details);\n    };\n    /**\n     * A UrlRule which matches a state by its url\n     *\n     * #### Example:\n     * ```js\n     * var rule = factory.fromState($state.get('foo'), router);\n     * var match = rule.match('/foo/123/456'); // results in { fooId: '123', barId: '456' }\n     * var result = rule.handler(match);\n     * // Starts a transition to 'foo' with params: { fooId: '123', barId: '456' }\n     * ```\n     */\n    UrlRuleFactory.prototype.fromState = function (state, router) {\n        /**\n         * Handles match by transitioning to matched state\n         *\n         * First checks if the router should start a new transition.\n         * A new transition is not required if the current state's URL\n         * and the new URL are already identical\n         */\n        var handler = function (match) {\n            var $state = router.stateService;\n            var globals = router.globals;\n            if ($state.href(state, match) !== $state.href(globals.current, globals.params)) {\n                $state.transitionTo(state, match, { inherit: true, source: 'url' });\n            }\n        };\n        var details = { state: state, type: 'STATE' };\n        return common_1.extend(this.fromUrlMatcher(state.url, handler), details);\n    };\n    /**\n     * A UrlRule which matches based on a regular expression\n     *\n     * The `handler` may be either a [[UrlRuleHandlerFn]] or a string.\n     *\n     * ## Handler as a function\n     *\n     * If `handler` is a function, the function is invoked with:\n     *\n     * - regexp match array (from `regexp`)\n     * - url: the current Url ([[UrlParts]])\n     * - router: the router object ([[UIRouter]])\n     *\n     * #### Example:\n     * ```js\n     * var rule = factory.fromRegExp(/^\\/foo\\/(bar|baz)$/, match => \"/home/\" + match[1])\n     * var match = rule.match('/foo/bar'); // results in [ '/foo/bar', 'bar' ]\n     * var result = rule.handler(match); // '/home/bar'\n     * ```\n     *\n     * ## Handler as string\n     *\n     * If `handler` is a string, the url is *replaced by the string* when the Rule is invoked.\n     * The string is first interpolated using `string.replace()` style pattern.\n     *\n     * #### Example:\n     * ```js\n     * var rule = factory.fromRegExp(/^\\/foo\\/(bar|baz)$/, \"/home/$1\")\n     * var match = rule.match('/foo/bar'); // results in [ '/foo/bar', 'bar' ]\n     * var result = rule.handler(match); // '/home/bar'\n     * ```\n     */\n    UrlRuleFactory.prototype.fromRegExp = function (regexp, handler) {\n        if (regexp.global || regexp.sticky)\n            throw new Error('Rule RegExp must not be global or sticky');\n        /**\n         * If handler is a string, the url will be replaced by the string.\n         * If the string has any String.replace() style variables in it (like `$2`),\n         * they will be replaced by the captures from [[match]]\n         */\n        var redirectUrlTo = function (match) {\n            // Interpolates matched values into $1 $2, etc using a String.replace()-style pattern\n            return handler.replace(/\\$(\\$|\\d{1,2})/, function (m, what) { return match[what === '$' ? 0 : Number(what)]; });\n        };\n        var _handler = predicates_1.isString(handler) ? redirectUrlTo : handler;\n        var matchParamsFromRegexp = function (url) { return regexp.exec(url.path); };\n        var details = { regexp: regexp, type: 'REGEXP' };\n        return common_1.extend(new BaseUrlRule(matchParamsFromRegexp, _handler), details);\n    };\n    UrlRuleFactory.isUrlRule = function (obj) { return obj && ['type', 'match', 'handler'].every(function (key) { return predicates_1.isDefined(obj[key]); }); };\n    return UrlRuleFactory;\n}());\nexports.UrlRuleFactory = UrlRuleFactory;\n/**\n * A base rule which calls `match`\n *\n * The value from the `match` function is passed through to the `handler`.\n * @internalapi\n */\nvar BaseUrlRule = /** @class */ (function () {\n    function BaseUrlRule(match, handler) {\n        var _this = this;\n        this.match = match;\n        this.type = 'RAW';\n        this.matchPriority = function (match) { return 0 - _this.$id; };\n        this.handler = handler || common_1.identity;\n    }\n    return BaseUrlRule;\n}());\nexports.BaseUrlRule = BaseUrlRule;\n//# sourceMappingURL=urlRule.js.map","\"use strict\";\n/**\n * @coreapi\n * @module url\n */ /** */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar coreservices_1 = require(\"../common/coreservices\");\nvar common_1 = require(\"../common/common\");\n/** @hidden */\nvar makeStub = function (keys) {\n    return keys.reduce(function (acc, key) { return ((acc[key] = coreservices_1.notImplemented(key)), acc); }, { dispose: common_1.noop });\n};\n/** @hidden */\nvar locationServicesFns = ['url', 'path', 'search', 'hash', 'onChange'];\n/** @hidden */\nvar locationConfigFns = ['port', 'protocol', 'host', 'baseHref', 'html5Mode', 'hashPrefix'];\n/** @hidden */\nvar umfFns = ['type', 'caseInsensitive', 'strictMode', 'defaultSquashPolicy'];\n/** @hidden */\nvar rulesFns = ['sort', 'when', 'initial', 'otherwise', 'rules', 'rule', 'removeRule'];\n/** @hidden */\nvar syncFns = ['deferIntercept', 'listen', 'sync', 'match'];\n/**\n * API for URL management\n */\nvar UrlService = /** @class */ (function () {\n    /** @hidden */\n    function UrlService(router, lateBind) {\n        if (lateBind === void 0) { lateBind = true; }\n        this.router = router;\n        this.rules = {};\n        this.config = {};\n        // proxy function calls from UrlService to the LocationService/LocationConfig\n        var locationServices = function () { return router.locationService; };\n        common_1.createProxyFunctions(locationServices, this, locationServices, locationServicesFns, lateBind);\n        var locationConfig = function () { return router.locationConfig; };\n        common_1.createProxyFunctions(locationConfig, this.config, locationConfig, locationConfigFns, lateBind);\n        var umf = function () { return router.urlMatcherFactory; };\n        common_1.createProxyFunctions(umf, this.config, umf, umfFns);\n        var urlRouter = function () { return router.urlRouter; };\n        common_1.createProxyFunctions(urlRouter, this.rules, urlRouter, rulesFns);\n        common_1.createProxyFunctions(urlRouter, this, urlRouter, syncFns);\n    }\n    UrlService.prototype.url = function (newurl, replace, state) {\n        return;\n    };\n    /** @inheritdoc */\n    UrlService.prototype.path = function () {\n        return;\n    };\n    /** @inheritdoc */\n    UrlService.prototype.search = function () {\n        return;\n    };\n    /** @inheritdoc */\n    UrlService.prototype.hash = function () {\n        return;\n    };\n    /** @inheritdoc */\n    UrlService.prototype.onChange = function (callback) {\n        return;\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    UrlService.prototype.parts = function () {\n        return { path: this.path(), search: this.search(), hash: this.hash() };\n    };\n    UrlService.prototype.dispose = function () { };\n    /** @inheritdoc */\n    UrlService.prototype.sync = function (evt) {\n        return;\n    };\n    /** @inheritdoc */\n    UrlService.prototype.listen = function (enabled) {\n        return;\n    };\n    /** @inheritdoc */\n    UrlService.prototype.deferIntercept = function (defer) {\n        return;\n    };\n    /** @inheritdoc */\n    UrlService.prototype.match = function (urlParts) {\n        return;\n    };\n    /** @hidden */\n    UrlService.locationServiceStub = makeStub(locationServicesFns);\n    /** @hidden */\n    UrlService.locationConfigStub = makeStub(locationConfigFns);\n    return UrlService;\n}());\nexports.UrlService = UrlService;\n//# sourceMappingURL=urlService.js.map","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @internalapi\n * @module vanilla\n */\n/** */\n__export(require(\"./vanilla/index\"));\n//# sourceMappingURL=vanilla.js.map","\"use strict\";\n/**\n * @internalapi\n * @module vanilla\n */ /** */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar common_1 = require(\"../common\");\nvar utils_1 = require(\"./utils\");\n/** A base `LocationServices` */\nvar BaseLocationServices = /** @class */ (function () {\n    function BaseLocationServices(router, fireAfterUpdate) {\n        var _this = this;\n        this.fireAfterUpdate = fireAfterUpdate;\n        this._listeners = [];\n        this._listener = function (evt) { return _this._listeners.forEach(function (cb) { return cb(evt); }); };\n        this.hash = function () { return utils_1.parseUrl(_this._get()).hash; };\n        this.path = function () { return utils_1.parseUrl(_this._get()).path; };\n        this.search = function () { return utils_1.getParams(utils_1.parseUrl(_this._get()).search); };\n        this._location = common_1.root.location;\n        this._history = common_1.root.history;\n    }\n    BaseLocationServices.prototype.url = function (url, replace) {\n        if (replace === void 0) { replace = true; }\n        if (common_1.isDefined(url) && url !== this._get()) {\n            this._set(null, null, url, replace);\n            if (this.fireAfterUpdate) {\n                this._listeners.forEach(function (cb) { return cb({ url: url }); });\n            }\n        }\n        return utils_1.buildUrl(this);\n    };\n    BaseLocationServices.prototype.onChange = function (cb) {\n        var _this = this;\n        this._listeners.push(cb);\n        return function () { return common_1.removeFrom(_this._listeners, cb); };\n    };\n    BaseLocationServices.prototype.dispose = function (router) {\n        common_1.deregAll(this._listeners);\n    };\n    return BaseLocationServices;\n}());\nexports.BaseLocationServices = BaseLocationServices;\n//# sourceMappingURL=baseLocationService.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @internalapi\n * @module vanilla\n */\n/** */\nvar predicates_1 = require(\"../common/predicates\");\n/** A `LocationConfig` that delegates to the browser's `location` object */\nvar BrowserLocationConfig = /** @class */ (function () {\n    function BrowserLocationConfig(router, _isHtml5) {\n        if (_isHtml5 === void 0) { _isHtml5 = false; }\n        this._isHtml5 = _isHtml5;\n        this._baseHref = undefined;\n        this._hashPrefix = '';\n    }\n    BrowserLocationConfig.prototype.port = function () {\n        if (location.port) {\n            return Number(location.port);\n        }\n        return this.protocol() === 'https' ? 443 : 80;\n    };\n    BrowserLocationConfig.prototype.protocol = function () {\n        return location.protocol.replace(/:/g, '');\n    };\n    BrowserLocationConfig.prototype.host = function () {\n        return location.hostname;\n    };\n    BrowserLocationConfig.prototype.html5Mode = function () {\n        return this._isHtml5;\n    };\n    BrowserLocationConfig.prototype.hashPrefix = function (newprefix) {\n        return predicates_1.isDefined(newprefix) ? (this._hashPrefix = newprefix) : this._hashPrefix;\n    };\n    BrowserLocationConfig.prototype.baseHref = function (href) {\n        return predicates_1.isDefined(href)\n            ? (this._baseHref = href)\n            : predicates_1.isDefined(this._baseHref) ? this._baseHref : this.applyDocumentBaseHref();\n    };\n    BrowserLocationConfig.prototype.applyDocumentBaseHref = function () {\n        var baseTag = document.getElementsByTagName('base')[0];\n        return (this._baseHref = baseTag ? baseTag.href.substr(location.origin.length) : location.pathname || '/');\n    };\n    BrowserLocationConfig.prototype.dispose = function () { };\n    return BrowserLocationConfig;\n}());\nexports.BrowserLocationConfig = BrowserLocationConfig;\n//# sourceMappingURL=browserLocationConfig.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @internalapi\n * @module vanilla\n */\n/** */\nvar common_1 = require(\"../common\");\nvar baseLocationService_1 = require(\"./baseLocationService\");\n/** A `LocationServices` that uses the browser hash \"#\" to get/set the current location */\nvar HashLocationService = /** @class */ (function (_super) {\n    __extends(HashLocationService, _super);\n    function HashLocationService(router) {\n        var _this = _super.call(this, router, false) || this;\n        common_1.root.addEventListener('hashchange', _this._listener, false);\n        return _this;\n    }\n    HashLocationService.prototype._get = function () {\n        return common_1.trimHashVal(this._location.hash);\n    };\n    HashLocationService.prototype._set = function (state, title, url, replace) {\n        this._location.hash = url;\n    };\n    HashLocationService.prototype.dispose = function (router) {\n        _super.prototype.dispose.call(this, router);\n        common_1.root.removeEventListener('hashchange', this._listener);\n    };\n    return HashLocationService;\n}(baseLocationService_1.BaseLocationServices));\nexports.HashLocationService = HashLocationService;\n//# sourceMappingURL=hashLocationService.js.map","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./q\"));\n__export(require(\"./injector\"));\n__export(require(\"./baseLocationService\"));\n__export(require(\"./hashLocationService\"));\n__export(require(\"./memoryLocationService\"));\n__export(require(\"./pushStateLocationService\"));\n__export(require(\"./memoryLocationConfig\"));\n__export(require(\"./browserLocationConfig\"));\n__export(require(\"./utils\"));\n__export(require(\"./plugins\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @internalapi\n * @module vanilla\n */\n/** */\nvar index_1 = require(\"../common/index\");\n// globally available injectables\nvar globals = {};\nvar STRIP_COMMENTS = /((\\/\\/.*$)|(\\/\\*[\\s\\S]*?\\*\\/))/gm;\nvar ARGUMENT_NAMES = /([^\\s,]+)/g;\n/**\n * A basic angular1-like injector api\n *\n * This object implements four methods similar to the\n * [angular 1 dependency injector](https://docs.angularjs.org/api/auto/service/$injector)\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 object provides a naive implementation of a globally scoped dependency injection system.\n * It supports the following DI approaches:\n *\n * ### Function parameter names\n *\n * A function's `.toString()` is called, and the parameter names are parsed.\n * This only works when the parameter names aren't \"mangled\" by a minifier such as UglifyJS.\n *\n * ```js\n * function injectedFunction(FooService, BarService) {\n *   // FooService and BarService are injected\n * }\n * ```\n *\n * ### Function annotation\n *\n * A function may be annotated with an array of dependency names as the `$inject` property.\n *\n * ```js\n * injectedFunction.$inject = [ 'FooService', 'BarService' ];\n * function injectedFunction(fs, bs) {\n *   // FooService and BarService are injected as fs and bs parameters\n * }\n * ```\n *\n * ### Array notation\n *\n * An array provides the names of the dependencies to inject (as strings).\n * The function is the last element of the array.\n *\n * ```js\n * [ 'FooService', 'BarService', function (fs, bs) {\n *   // FooService and BarService are injected as fs and bs parameters\n * }]\n * ```\n *\n * @type {$InjectorLike}\n */\nexports.$injector = {\n    /** Gets an object from DI based on a string token */\n    get: function (name) { return globals[name]; },\n    /** Returns true if an object named `name` exists in global DI */\n    has: function (name) { return exports.$injector.get(name) != null; },\n    /**\n     * Injects a function\n     *\n     * @param fn the function to inject\n     * @param context the function's `this` binding\n     * @param locals An object with additional DI tokens and values, such as `{ someToken: { foo: 1 } }`\n     */\n    invoke: function (fn, context, locals) {\n        var all = index_1.extend({}, globals, locals || {});\n        var params = exports.$injector.annotate(fn);\n        var ensureExist = index_1.assertPredicate(function (key) { return all.hasOwnProperty(key); }, function (key) { return \"DI can't find injectable: '\" + key + \"'\"; });\n        var args = params.filter(ensureExist).map(function (x) { return all[x]; });\n        if (index_1.isFunction(fn))\n            return fn.apply(context, args);\n        else\n            return fn.slice(-1)[0].apply(context, args);\n    },\n    /**\n     * Returns a function's dependencies\n     *\n     * Analyzes a function (or array) and returns an array of DI tokens that the function requires.\n     * @return an array of `string`s\n     */\n    annotate: function (fn) {\n        if (!index_1.isInjectable(fn))\n            throw new Error(\"Not an injectable function: \" + fn);\n        if (fn && fn.$inject)\n            return fn.$inject;\n        if (index_1.isArray(fn))\n            return fn.slice(0, -1);\n        var fnStr = fn.toString().replace(STRIP_COMMENTS, '');\n        var result = fnStr.slice(fnStr.indexOf('(') + 1, fnStr.indexOf(')')).match(ARGUMENT_NAMES);\n        return result || [];\n    },\n};\n//# sourceMappingURL=injector.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar predicates_1 = require(\"../common/predicates\");\nvar common_1 = require(\"../common/common\");\n/** A `LocationConfig` mock that gets/sets all config from an in-memory object */\nvar MemoryLocationConfig = /** @class */ (function () {\n    function MemoryLocationConfig() {\n        var _this = this;\n        this.dispose = common_1.noop;\n        this._baseHref = '';\n        this._port = 80;\n        this._protocol = 'http';\n        this._host = 'localhost';\n        this._hashPrefix = '';\n        this.port = function () { return _this._port; };\n        this.protocol = function () { return _this._protocol; };\n        this.host = function () { return _this._host; };\n        this.baseHref = function () { return _this._baseHref; };\n        this.html5Mode = function () { return false; };\n        this.hashPrefix = function (newval) { return (predicates_1.isDefined(newval) ? (_this._hashPrefix = newval) : _this._hashPrefix); };\n    }\n    return MemoryLocationConfig;\n}());\nexports.MemoryLocationConfig = MemoryLocationConfig;\n//# sourceMappingURL=memoryLocationConfig.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @internalapi\n * @module vanilla\n */\n/** */\nvar baseLocationService_1 = require(\"./baseLocationService\");\n/** A `LocationServices` that gets/sets the current location from an in-memory object */\nvar MemoryLocationService = /** @class */ (function (_super) {\n    __extends(MemoryLocationService, _super);\n    function MemoryLocationService(router) {\n        return _super.call(this, router, true) || this;\n    }\n    MemoryLocationService.prototype._get = function () {\n        return this._url;\n    };\n    MemoryLocationService.prototype._set = function (state, title, url, replace) {\n        this._url = url;\n    };\n    return MemoryLocationService;\n}(baseLocationService_1.BaseLocationServices));\nexports.MemoryLocationService = MemoryLocationService;\n//# sourceMappingURL=memoryLocationService.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @internalapi\n * @module vanilla\n */\n/** */\nvar browserLocationConfig_1 = require(\"./browserLocationConfig\");\nvar hashLocationService_1 = require(\"./hashLocationService\");\nvar utils_1 = require(\"./utils\");\nvar pushStateLocationService_1 = require(\"./pushStateLocationService\");\nvar memoryLocationService_1 = require(\"./memoryLocationService\");\nvar memoryLocationConfig_1 = require(\"./memoryLocationConfig\");\nvar injector_1 = require(\"./injector\");\nvar q_1 = require(\"./q\");\nvar coreservices_1 = require(\"../common/coreservices\");\nfunction servicesPlugin(router) {\n    coreservices_1.services.$injector = injector_1.$injector;\n    coreservices_1.services.$q = q_1.$q;\n    return { name: 'vanilla.services', $q: q_1.$q, $injector: injector_1.$injector, dispose: function () { return null; } };\n}\nexports.servicesPlugin = servicesPlugin;\n/** A `UIRouterPlugin` uses the browser hash to get/set the current location */\nexports.hashLocationPlugin = utils_1.locationPluginFactory('vanilla.hashBangLocation', false, hashLocationService_1.HashLocationService, browserLocationConfig_1.BrowserLocationConfig);\n/** A `UIRouterPlugin` that gets/sets the current location using the browser's `location` and `history` apis */\nexports.pushStateLocationPlugin = utils_1.locationPluginFactory('vanilla.pushStateLocation', true, pushStateLocationService_1.PushStateLocationService, browserLocationConfig_1.BrowserLocationConfig);\n/** A `UIRouterPlugin` that gets/sets the current location from an in-memory object */\nexports.memoryLocationPlugin = utils_1.locationPluginFactory('vanilla.memoryLocation', false, memoryLocationService_1.MemoryLocationService, memoryLocationConfig_1.MemoryLocationConfig);\n//# sourceMappingURL=plugins.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar baseLocationService_1 = require(\"./baseLocationService\");\nvar common_1 = require(\"../common\");\n/**\n * A `LocationServices` that gets/sets the current location using the browser's `location` and `history` apis\n *\n * Uses `history.pushState` and `history.replaceState`\n */\nvar PushStateLocationService = /** @class */ (function (_super) {\n    __extends(PushStateLocationService, _super);\n    function PushStateLocationService(router) {\n        var _this = _super.call(this, router, true) || this;\n        _this._config = router.urlService.config;\n        common_1.root.addEventListener('popstate', _this._listener, false);\n        return _this;\n    }\n    /**\n     * Gets the base prefix without:\n     * - trailing slash\n     * - trailing filename\n     * - protocol and hostname\n     *\n     * If <base href='/base/'>, this returns '/base'.\n     * If <base href='/foo/base/'>, this returns '/foo/base'.\n     * If <base href='/base/index.html'>, this returns '/base'.\n     * If <base href='http://localhost:8080/base/index.html'>, this returns '/base'.\n     * If <base href='/base'>, this returns ''.\n     * If <base href='http://localhost:8080'>, this returns ''.\n     * If <base href='http://localhost:8080/'>, this returns ''.\n     *\n     * See: https://html.spec.whatwg.org/dev/semantics.html#the-base-element\n     */\n    PushStateLocationService.prototype._getBasePrefix = function () {\n        return common_1.stripLastPathElement(this._config.baseHref());\n    };\n    PushStateLocationService.prototype._get = function () {\n        var _a = this._location, pathname = _a.pathname, hash = _a.hash, search = _a.search;\n        search = common_1.splitQuery(search)[1]; // strip ? if found\n        hash = common_1.splitHash(hash)[1]; // strip # if found\n        var basePrefix = this._getBasePrefix();\n        var exactBaseHrefMatch = pathname === this._config.baseHref();\n        var startsWithBase = pathname.substr(0, basePrefix.length) === basePrefix;\n        pathname = exactBaseHrefMatch ? '/' : startsWithBase ? pathname.substring(basePrefix.length) : pathname;\n        return pathname + (search ? '?' + search : '') + (hash ? '#' + hash : '');\n    };\n    PushStateLocationService.prototype._set = function (state, title, url, replace) {\n        var basePrefix = this._getBasePrefix();\n        var slash = url && url[0] !== '/' ? '/' : '';\n        var fullUrl = url === '' || url === '/' ? this._config.baseHref() : basePrefix + slash + url;\n        if (replace) {\n            this._history.replaceState(state, title, fullUrl);\n        }\n        else {\n            this._history.pushState(state, title, fullUrl);\n        }\n    };\n    PushStateLocationService.prototype.dispose = function (router) {\n        _super.prototype.dispose.call(this, router);\n        common_1.root.removeEventListener('popstate', this._listener);\n    };\n    return PushStateLocationService;\n}(baseLocationService_1.BaseLocationServices));\nexports.PushStateLocationService = PushStateLocationService;\n//# sourceMappingURL=pushStateLocationService.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @internalapi\n * @module vanilla\n */\n/** */\nvar index_1 = require(\"../common/index\");\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 */\nexports.$q = {\n    /** Normalizes a value as a promise */\n    when: function (val) { return new Promise(function (resolve, reject) { return resolve(val); }); },\n    /** Normalizes a value as a promise rejection */\n    reject: function (val) {\n        return new Promise(function (resolve, reject) {\n            reject(val);\n        });\n    },\n    /** @returns a deferred object, which has `resolve` and `reject` functions */\n    defer: function () {\n        var deferred = {};\n        deferred.promise = new Promise(function (resolve, reject) {\n            deferred.resolve = resolve;\n            deferred.reject = reject;\n        });\n        return deferred;\n    },\n    /** Like Promise.all(), but also supports object key/promise notation like $q */\n    all: function (promises) {\n        if (index_1.isArray(promises)) {\n            return Promise.all(promises);\n        }\n        if (index_1.isObject(promises)) {\n            // Convert promises map to promises array.\n            // When each promise resolves, map it to a tuple { key: key, val: val }\n            var chain = Object.keys(promises).map(function (key) { return promises[key].then(function (val) { return ({ key: key, val: val }); }); });\n            // Then wait for all promises to resolve, and convert them back to an object\n            return exports.$q.all(chain).then(function (values) {\n                return values.reduce(function (acc, tuple) {\n                    acc[tuple.key] = tuple.val;\n                    return acc;\n                }, {});\n            });\n        }\n    },\n};\n//# sourceMappingURL=q.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @internalapi\n * @module vanilla\n */\n/** */\nvar common_1 = require(\"../common\");\nexports.keyValsToObjectR = function (accum, _a) {\n    var key = _a[0], val = _a[1];\n    if (!accum.hasOwnProperty(key)) {\n        accum[key] = val;\n    }\n    else if (common_1.isArray(accum[key])) {\n        accum[key].push(val);\n    }\n    else {\n        accum[key] = [accum[key], val];\n    }\n    return accum;\n};\nexports.getParams = function (queryString) {\n    return queryString\n        .split('&')\n        .filter(common_1.identity)\n        .map(common_1.splitEqual)\n        .reduce(exports.keyValsToObjectR, {});\n};\nfunction parseUrl(url) {\n    var orEmptyString = function (x) { return x || ''; };\n    var _a = common_1.splitHash(url).map(orEmptyString), beforehash = _a[0], hash = _a[1];\n    var _b = common_1.splitQuery(beforehash).map(orEmptyString), path = _b[0], search = _b[1];\n    return { path: path, search: search, hash: hash, url: url };\n}\nexports.parseUrl = parseUrl;\nexports.buildUrl = function (loc) {\n    var path = loc.path();\n    var searchObject = loc.search();\n    var hash = loc.hash();\n    var search = Object.keys(searchObject)\n        .map(function (key) {\n        var param = searchObject[key];\n        var vals = common_1.isArray(param) ? param : [param];\n        return vals.map(function (val) { return key + '=' + val; });\n    })\n        .reduce(common_1.unnestR, [])\n        .join('&');\n    return path + (search ? '?' + search : '') + (hash ? '#' + hash : '');\n};\nfunction locationPluginFactory(name, isHtml5, serviceClass, configurationClass) {\n    return function (uiRouter) {\n        var service = (uiRouter.locationService = new serviceClass(uiRouter));\n        var configuration = (uiRouter.locationConfig = new configurationClass(uiRouter, isHtml5));\n        function dispose(router) {\n            router.dispose(service);\n            router.dispose(configuration);\n        }\n        return { name: name, service: service, configuration: configuration, dispose: dispose };\n    };\n}\nexports.locationPluginFactory = locationPluginFactory;\n//# sourceMappingURL=utils.js.map","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./view\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * @coreapi\n * @module view\n */ /** for typedoc */\nvar common_1 = require(\"../common/common\");\nvar hof_1 = require(\"../common/hof\");\nvar predicates_1 = require(\"../common/predicates\");\nvar trace_1 = require(\"../common/trace\");\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 */\nvar ViewService = /** @class */ (function () {\n    function ViewService() {\n        var _this = this;\n        this._uiViews = [];\n        this._viewConfigs = [];\n        this._viewConfigFactories = {};\n        this._listeners = [];\n        this._pluginapi = {\n            _rootViewContext: this._rootViewContext.bind(this),\n            _viewConfigFactory: this._viewConfigFactory.bind(this),\n            _registeredUIViews: function () { return _this._uiViews; },\n            _activeViewConfigs: function () { return _this._viewConfigs; },\n            _onSync: function (listener) {\n                _this._listeners.push(listener);\n                return function () { return common_1.removeFrom(_this._listeners, listener); };\n            },\n        };\n    }\n    /**\n     * Normalizes a view's name from a state.views configuration block.\n     *\n     * This should be used by a framework implementation to calculate the values for\n     * [[_ViewDeclaration.$uiViewName]] and [[_ViewDeclaration.$uiViewContextAnchor]].\n     *\n     * @param context the context object (state declaration) that the view belongs to\n     * @param rawViewName the name of the view, as declared in the [[StateDeclaration.views]]\n     *\n     * @returns the normalized uiViewName and uiViewContextAnchor that the view targets\n     */\n    ViewService.normalizeUIViewTarget = function (context, rawViewName) {\n        if (rawViewName === void 0) { rawViewName = ''; }\n        // TODO: Validate incoming view name with a regexp to allow:\n        // ex: \"view.name@foo.bar\" , \"^.^.view.name\" , \"view.name@^.^\" , \"\" ,\n        // \"@\" , \"$default@^\" , \"!$default.$default\" , \"!foo.bar\"\n        var viewAtContext = rawViewName.split('@');\n        var uiViewName = viewAtContext[0] || '$default'; // default to unnamed view\n        var uiViewContextAnchor = predicates_1.isString(viewAtContext[1]) ? viewAtContext[1] : '^'; // default to parent context\n        // Handle relative view-name sugar syntax.\n        // Matches rawViewName \"^.^.^.foo.bar\" into array: [\"^.^.^.foo.bar\", \"^.^.^\", \"foo.bar\"],\n        var relativeViewNameSugar = /^(\\^(?:\\.\\^)*)\\.(.*$)/.exec(uiViewName);\n        if (relativeViewNameSugar) {\n            // Clobbers existing contextAnchor (rawViewName validation will fix this)\n            uiViewContextAnchor = relativeViewNameSugar[1]; // set anchor to \"^.^.^\"\n            uiViewName = relativeViewNameSugar[2]; // set view-name to \"foo.bar\"\n        }\n        if (uiViewName.charAt(0) === '!') {\n            uiViewName = uiViewName.substr(1);\n            uiViewContextAnchor = ''; // target absolutely from root\n        }\n        // handle parent relative targeting \"^.^.^\"\n        var relativeMatch = /^(\\^(?:\\.\\^)*)$/;\n        if (relativeMatch.exec(uiViewContextAnchor)) {\n            var anchorState = uiViewContextAnchor.split('.').reduce(function (anchor, x) { return anchor.parent; }, context);\n            uiViewContextAnchor = anchorState.name;\n        }\n        else if (uiViewContextAnchor === '.') {\n            uiViewContextAnchor = context.name;\n        }\n        return { uiViewName: uiViewName, uiViewContextAnchor: uiViewContextAnchor };\n    };\n    ViewService.prototype._rootViewContext = function (context) {\n        return (this._rootContext = context || this._rootContext);\n    };\n    ViewService.prototype._viewConfigFactory = function (viewType, factory) {\n        this._viewConfigFactories[viewType] = factory;\n    };\n    ViewService.prototype.createViewConfig = function (path, decl) {\n        var cfgFactory = this._viewConfigFactories[decl.$type];\n        if (!cfgFactory)\n            throw new Error('ViewService: No view config factory registered for type ' + decl.$type);\n        var cfgs = cfgFactory(path, decl);\n        return predicates_1.isArray(cfgs) ? cfgs : [cfgs];\n    };\n    /**\n     * Deactivates a ViewConfig.\n     *\n     * This function deactivates a `ViewConfig`.\n     * After calling [[sync]], it will un-pair from any `ui-view` with which it is currently paired.\n     *\n     * @param viewConfig The ViewConfig view to deregister.\n     */\n    ViewService.prototype.deactivateViewConfig = function (viewConfig) {\n        trace_1.trace.traceViewServiceEvent('<- Removing', viewConfig);\n        common_1.removeFrom(this._viewConfigs, viewConfig);\n    };\n    ViewService.prototype.activateViewConfig = function (viewConfig) {\n        trace_1.trace.traceViewServiceEvent('-> Registering', viewConfig);\n        this._viewConfigs.push(viewConfig);\n    };\n    ViewService.prototype.sync = function () {\n        var _this = this;\n        var uiViewsByFqn = this._uiViews.map(function (uiv) { return [uiv.fqn, uiv]; }).reduce(common_1.applyPairs, {});\n        // Return a weighted depth value for a uiView.\n        // The depth is the nesting depth of ui-views (based on FQN; times 10,000)\n        // plus the depth of the state that is populating the uiView\n        function uiViewDepth(uiView) {\n            var stateDepth = function (context) { return (context && context.parent ? stateDepth(context.parent) + 1 : 1); };\n            return uiView.fqn.split('.').length * 10000 + stateDepth(uiView.creationContext);\n        }\n        // Return the ViewConfig's context's depth in the context tree.\n        function viewConfigDepth(config) {\n            var context = config.viewDecl.$context, count = 0;\n            while (++count && context.parent)\n                context = context.parent;\n            return count;\n        }\n        // Given a depth function, returns a compare function which can return either ascending or descending order\n        var depthCompare = hof_1.curry(function (depthFn, posNeg, left, right) { return posNeg * (depthFn(left) - depthFn(right)); });\n        var matchingConfigPair = function (uiView) {\n            var matchingConfigs = _this._viewConfigs.filter(ViewService.matches(uiViewsByFqn, uiView));\n            if (matchingConfigs.length > 1) {\n                // This is OK.  Child states can target a ui-view that the parent state also targets (the child wins)\n                // Sort by depth and return the match from the deepest child\n                // console.log(`Multiple matching view configs for ${uiView.fqn}`, matchingConfigs);\n                matchingConfigs.sort(depthCompare(viewConfigDepth, -1)); // descending\n            }\n            return { uiView: uiView, viewConfig: matchingConfigs[0] };\n        };\n        var configureUIView = function (tuple) {\n            // If a parent ui-view is reconfigured, it could destroy child ui-views.\n            // Before configuring a child ui-view, make sure it's still in the active uiViews array.\n            if (_this._uiViews.indexOf(tuple.uiView) !== -1)\n                tuple.uiView.configUpdated(tuple.viewConfig);\n        };\n        // Sort views by FQN and state depth. Process uiviews nearest the root first.\n        var uiViewTuples = this._uiViews.sort(depthCompare(uiViewDepth, 1)).map(matchingConfigPair);\n        var matchedViewConfigs = uiViewTuples.map(function (tuple) { return tuple.viewConfig; });\n        var unmatchedConfigTuples = this._viewConfigs\n            .filter(function (config) { return !common_1.inArray(matchedViewConfigs, config); })\n            .map(function (viewConfig) { return ({ uiView: undefined, viewConfig: viewConfig }); });\n        uiViewTuples.forEach(configureUIView);\n        var allTuples = uiViewTuples.concat(unmatchedConfigTuples);\n        this._listeners.forEach(function (cb) { return cb(allTuples); });\n        trace_1.trace.traceViewSync(allTuples);\n    };\n    /**\n     * Registers a `ui-view` component\n     *\n     * When a `ui-view` component is created, it uses this method to register itself.\n     * After registration the [[sync]] method is used to ensure all `ui-view` are configured with the proper [[ViewConfig]].\n     *\n     * Note: the `ui-view` component uses the `ViewConfig` to determine what view should be loaded inside the `ui-view`,\n     * and what the view's state context is.\n     *\n     * Note: There is no corresponding `deregisterUIView`.\n     *       A `ui-view` should hang on to the return value of `registerUIView` and invoke it to deregister itself.\n     *\n     * @param uiView The metadata for a UIView\n     * @return a de-registration function used when the view is destroyed.\n     */\n    ViewService.prototype.registerUIView = function (uiView) {\n        trace_1.trace.traceViewServiceUIViewEvent('-> Registering', uiView);\n        var uiViews = this._uiViews;\n        var fqnAndTypeMatches = function (uiv) { return uiv.fqn === uiView.fqn && uiv.$type === uiView.$type; };\n        if (uiViews.filter(fqnAndTypeMatches).length)\n            trace_1.trace.traceViewServiceUIViewEvent('!!!! duplicate uiView named:', uiView);\n        uiViews.push(uiView);\n        this.sync();\n        return function () {\n            var idx = uiViews.indexOf(uiView);\n            if (idx === -1) {\n                trace_1.trace.traceViewServiceUIViewEvent('Tried removing non-registered uiView', uiView);\n                return;\n            }\n            trace_1.trace.traceViewServiceUIViewEvent('<- Deregistering', uiView);\n            common_1.removeFrom(uiViews)(uiView);\n        };\n    };\n    /**\n     * Returns the list of views currently available on the page, by fully-qualified name.\n     *\n     * @return {Array} Returns an array of fully-qualified view names.\n     */\n    ViewService.prototype.available = function () {\n        return this._uiViews.map(hof_1.prop('fqn'));\n    };\n    /**\n     * Returns the list of views on the page containing loaded content.\n     *\n     * @return {Array} Returns an array of fully-qualified view names.\n     */\n    ViewService.prototype.active = function () {\n        return this._uiViews.filter(hof_1.prop('$config')).map(hof_1.prop('name'));\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.$default.bar\",          uiViewContextAnchor: \"A\" }\n     * - ViewConfig4: { uiViewName: \"$default.foo.$default.bar\", uiViewContextAnchor: \"\" }\n     *\n     * Using ViewConfig3 as an example, it matches the ui-view with fqn \"$default.foo.$default.bar\" because:\n     * - The ViewConfig's segmented target name is: [ \"foo\", \"$default\", \"bar\" ]\n     * - There exists a parent ui-view (which has fqn: \"$default.foo\") where:\n     *    - the parent ui-view's name \"foo\" matches the first segment \"foo\" of the ViewConfig's target name\n     *    - the parent ui-view's context \"A\" matches the ViewConfig's anchor context \"A\"\n     * - And the remaining segments [ \"$default\", \"bar\" ].join(\".\"_ of the ViewConfig's target name match\n     *   the tail of the ui-view's fqn \"default.bar\"\n     *\n     * @internalapi\n     */\n    ViewService.matches = function (uiViewsByFqn, uiView) { return function (viewConfig) {\n        // Don't supply an ng1 ui-view with an ng2 ViewConfig, etc\n        if (uiView.$type !== viewConfig.viewDecl.$type)\n            return false;\n        // Split names apart from both viewConfig and uiView into segments\n        var vc = viewConfig.viewDecl;\n        var vcSegments = vc.$uiViewName.split('.');\n        var uivSegments = uiView.fqn.split('.');\n        // Check if the tails of the segment arrays match. ex, these arrays' tails match:\n        // vc: [\"foo\", \"bar\"], uiv fqn: [\"$default\", \"foo\", \"bar\"]\n        if (!common_1.equals(vcSegments, uivSegments.slice(0 - vcSegments.length)))\n            return false;\n        // Now check if the fqn ending at the first segment of the viewConfig matches the context:\n        // [\"$default\", \"foo\"].join(\".\") == \"$default.foo\", does the ui-view $default.foo context match?\n        var negOffset = 1 - vcSegments.length || undefined;\n        var fqnToFirstSegment = uivSegments.slice(0, negOffset).join('.');\n        var uiViewContext = uiViewsByFqn[fqnToFirstSegment].creationContext;\n        return vc.$uiViewContextAnchor === (uiViewContext && uiViewContext.name);\n    }; };\n    return ViewService;\n}());\nexports.ViewService = ViewService;\n//# sourceMappingURL=view.js.map","export default class RmRoutesConstant {\r\n  // For telemetry appName\r\n  public static readonly RelationshipManagement = 'RelationshipManagement';\r\n\r\n  // For /rmdelivery\r\n  public static readonly RmDeliveryRouteName = 'rmdelivery';\r\n  public static readonly RmDeliveryRouteUrl = '/mydeliveries';\r\n\r\n  // For /relationshipmanagementdashboard\r\n  public static readonly RmDashboardRouteName = 'relationship_management_dashboard';\r\n  public static readonly RmDashboardRouteUrl = '/relationshipmanagementdashboard';\r\n\r\n  // For /reportsunauthorized\r\n  public static readonly RmSearchReportsUnauthorizedRoute = 'reportsunauthorized';\r\n  public static readonly RmSearchReportsUnauthorizedRouteUrl = `/reportsunauthorized`;\r\n  public static readonly RmSearchReportsUnAuthorizedOwnerCoOwnerList = 'ownersList';\r\n  public static readonly sdpId = 'sdpId';\r\n  public static readonly sdpName = 'sdpName';\r\n\r\n  public static readonly RmReportCases = 'rmreportcases';\r\n  public static readonly RmReportCasesRouteUrl = '/rmreportcases';\r\n\r\n  public static readonly RmGenerateReport = 'rmgeneratereport';\r\n  public static readonly RmGenerateReportRouteUrl = '/rmgeneratereport';\r\n\r\n  // For /relationshipmanagementdashboard / Summary\r\n  public static readonly RmDashboardSummary = 'relationship_management_dashboard.summary';\r\n  public static readonly RmDashboardSummaryRouteUrl = '/summary';\r\n\r\n  // For /relationshipmanagementdashboard /  Agreements\r\n  public static readonly RmDashboardAgreements = 'relationship_management_dashboard.agreements';\r\n  public static readonly RmDashboardAgreementsRouteUrl = '/agreements';\r\n\r\n  // For /relationshipmanagementdashboard /  Programs\r\n  public static readonly RmDashboardPrograms = 'relationship_management_dashboard.programs';\r\n  public static readonly RmDashboardProgramsRouteUrl = `/supportprojects`;\r\n\r\n  // For /relationshipmanagementdashboard /  Deliveries\r\n  public static readonly RmDashboardDeliveries = 'relationship_management_dashboard.deliveries';\r\n  public static readonly RmDashboardDeliveriesRouteUrl = `/deliveries`;\r\n\r\n  // For /relationshipmanagementdashboard /  Cases\r\n  public static readonly RmDashboardCases = 'relationship_management_dashboard.cases';\r\n  public static readonly RmDashboardCasesRouteUrl = `/cases`;\r\n\r\n  // For /relationshipmanagementdashboard /  Utilization\r\n  public static readonly RmDashboardUtilizationView = 'relationship_management_dashboard.utilization';\r\n  public static readonly RmDashboardUtilizationViewUrl = '/utilization';\r\n\r\n  // For /relationshipmanagementdashboard /  Accounts\r\n  public static readonly RmDashboardAccounts = 'relationship_management_dashboard.accounts';\r\n  public static readonly RmDashboardAccountsRouteUrl = `/accounts`;\r\n\r\n  // For /relationshipmanagementdashboard /  CSAT\r\n  public static readonly CSATView = 'relationship_management_dashboard.csat';\r\n  public static readonly CSATViewUrl = '/csat';\r\n\r\n  // For /relationshipmanagementdashboard  / CSPM\r\n  public static readonly CloudKnowsPremier = 'relationship_management_dashboard.cspm';\r\n  public static readonly CloudKnowsPremierUrl = '/cspm';\r\n\r\n  public static readonly CloudKnowsPremierSearch = 'relationship_management_dashboard.cspm.search';\r\n  public static readonly CloudKnowsPremierSearchUrl = '/search/{grid}';\r\n\r\n  // For /relationshipmanagementdashboard /  Software Assurance Benefits\r\n  public static readonly RmDashboardSoftwareAssurance = 'relationship_management_dashboard.software-assurance-benefits';\r\n  public static readonly RmDashboardSoftwareRouteUrl = '/software-assurance-benefits';\r\n\r\n  // For /dmm\r\n  public static readonly DmmRouteName = 'dmm';\r\n  public static readonly DmmRouteUrl = '/csammanager';\r\n\r\n  // For /dmmmportfolio\r\n  public static readonly DmmPorfolioRouteName = 'dmm.portfolio';\r\n  public static readonly DmmPortfolioRouteUrl = '/portfolio';\r\n  public static readonly DmmPortfolio = 'DmmPortfolio';\r\n\r\n  // For Dmm /  Utilization\r\n  public static readonly DmmUtilization = 'dmm.utilization';\r\n  public static readonly DmmUtilizationRouteUrl = `/utilization`;\r\n\r\n  // For Dmm / ActionView\r\n  public static readonly DmmActionView = 'dmm.actionview';\r\n  public static readonly DmmActionViewRouteUrl = `/actionview`;\r\n\r\n  // For Dmm /  SDPReview\r\n  public static readonly DmmSdpReview = 'dmm.sdpreview';\r\n  public static readonly DmmSdpReviewRouteUrl = `/sdpreview`;\r\n\r\n  // For Dmm /  CPESurvey\r\n  public static readonly DmmCpeSurvey = 'dmm.cpesurvey';\r\n  public static readonly DmmCpeSurveyRouteUrl = `/cpesurvey`;\r\n\r\n  // For Dmm /  CPESurveyDetails\r\n  public static readonly DmmCpeSurveyDetails = 'cpedetails';\r\n  public static readonly DmmCpeSurveyDetailsRouteUrl = `/csammanager/cpesurvey/cpedetails/surveyId/{surveyId}/packageId/{packageId}/regionType/{regionType}`;\r\n\r\n  // For Dmm /  Software Assurance Benefits\r\n  public static readonly DmmSoftwareAssurance = 'dmm.software-assurance-benefits';\r\n  public static readonly DmmSoftwareRouteUrl = '/software-assurance-benefits';\r\n\r\n  // For Dmm /  CSPM\r\n  public static readonly DmmCkp = 'dmm.cspm';\r\n  public static readonly DmmCkpRouteUrl = '/cspm';\r\n\r\n  // For Program Management /  Utilization\r\n  public static readonly CKPView = 'rmdelivery.cspm';\r\n  public static readonly CKPViewUrl = '/cspm';\r\n\r\n  // For /rm\r\n  public static readonly RmRouteName = 'rm';\r\n  public static readonly RmRouteUrl = '/rm';\r\n  public static readonly RmRouteParamTab = 'tab';\r\n  public static readonly RmRouteParamItemType = 'itemtype';\r\n  public static readonly RmRouteAccountItemType = 'Account';\r\n  public static readonly RmRoutePortfolioItemType = 'Portfolio';\r\n  public static readonly RmRouteTabSummary = 'Summary';\r\n  public static readonly RmRouteTabContacts = 'Contacts';\r\n  public static readonly RmRouteTabPrograms = 'Programs';\r\n  public static readonly RmRouteTabAccount = 'Accounts';\r\n  public static readonly RmRouteTabOpportunities = 'Opportunities';\r\n  public static readonly RmRouteTabSuccessEngagements = 'Success Engagements';\r\n\r\n\r\n  // For /rm/account*\r\n  public static readonly AccountRouteName = 'account';\r\n  public static readonly AccountRouteUrl = `${RmRoutesConstant.RmRouteUrl}/account/:accountid/:tab`;\r\n  public static readonly AccountRouteParamTab = 'tab';\r\n  public static readonly AccountRouteParamAccountId = 'accountid';\r\n  public static readonly AccountRouteTabSummary = 'Summary';\r\n  public static readonly AccountRouteTabOpportunities = 'Opportunities';\r\n  public static readonly AccountRouteTabContacts = 'Contacts';\r\n  public static readonly AccountRouteAccountItemType = 'Account';\r\n  public static readonly AccountRouteTabSuccessEngagements = 'Success Engagements';\r\n\r\n  // For Program Management\r\n  public static readonly ProgramManagement = 'rmprogrammanagement';\r\n  public static readonly ProgramManagementRouteUrl = `/supportprojectmanagement`;\r\n\r\n  // For Program Management /  Summary\r\n  public static readonly PortfolioSummary = 'rmdelivery.summary';\r\n  public static readonly PortfolioSummaryRouteUrl = `/summary`;\r\n  public static readonly PortfolioTabSummary = 'Summary';\r\n  public static readonly PortfolioTabPrograms = 'Programs';\r\n  public static readonly PortfolioTabDeliveries = 'Deliveries';\r\n  public static readonly PortfolioTabAccounts = 'Accounts';\r\n\r\n  // For Program Management /  Accounts\r\n  public static readonly PortfolioAccounts = 'rmdelivery.accounts';\r\n  public static readonly PortfolioAccountsRouteUrl = `/accounts`;\r\n\r\n  // For Program Management /  Programs\r\n  public static readonly PortfolioPrograms = 'rmdelivery.programs';\r\n  public static readonly PortfolioProgramsRouteUrl = `/supportprojects`;\r\n\r\n  // For Program Management /  Deliveries\r\n  public static readonly PortfolioDeliveries = 'rmdelivery.deliveries';\r\n  public static readonly PortfolioDeliveriesRouteUrl = `/deliveries`;\r\n\r\n  // For Program Management /  Unassigned Packages\r\n  public static readonly UnassignedPackages = 'rmdelivery.unassignedpackages';\r\n  public static readonly UnassignedPackagesRouteUrl = `/unassignedpackages`;\r\n\r\n  public static readonly UnlinkedRequests = 'rmdelivery.unlinkedrequests';\r\n  public static readonly UnlinkedRequestsRouteUrl = `/unlinkedrequests`;\r\n\r\n   // For Program Management /  unlinked projects in React framework\r\n  public static readonly UnlinkedProjects = 'rmdelivery.unlinkedprojects';\r\n  \r\n  // For Program Management /  Cases\r\n  public static readonly PortfolioCases = 'rmdelivery.cases';\r\n  public static readonly PortfolioCasesRouteUrl = `/cases`;\r\n\r\n  // For Program Management /  Agreements\r\n  public static readonly PortfolioAgreements = 'rmdelivery.agreements';\r\n  public static readonly PortfolioAgreementsRouteUrl = '/agreements';\r\n\r\n  // For Program Management /  Utilization\r\n  public static readonly PortfolioUtilizationView = 'rmdelivery.utilization';\r\n  public static readonly PortfolioUtilizationViewUrl = '/utilization';\r\n\r\n  // For Program Management /  SDP\r\n  public static readonly ServiceDeliveryPlan = 'rmdelivery.sdp';\r\n  public static readonly ServiceDeliveryPlanRouteUrl = `/sdps/{sdpId}`;\r\n  public static readonly SdpRouteParamSdpId = 'sdpId';\r\n\r\n  // For Program Management /  SDP / Summary\r\n  public static readonly SdpSummary = 'rmdelivery.sdp.summary';\r\n  public static readonly SdpSummaryRouteUrl = `/summary`;\r\n\r\n  // For Program Management /  SDP / Programs\r\n  public static readonly SdpPrograms = 'rmdelivery.sdp.programs';\r\n  public static readonly SdpProgramsRouteUrl = `/supportprojects`;\r\n\r\n  // For Support Projects in React framework\r\n  public static readonly SupportProjects = 'rmdelivery.sdp.supportprojects';\r\n\r\n  // For Program Management /  SDP / Create Program\r\n  // public static readonly SdpCreateProgram = 'rmdelivery.sdp.programs.new';\r\n  public static readonly SdpCreateProgram = 'program_create';\r\n  public static readonly SdpCreateProgramRouteUrl = `/mydeliveries/sdps/{sdpId}/supportprojects/new`;\r\n\r\n  public static readonly SdpEditPrograms = 'program_edit';\r\n  public static readonly SdpEditProgramsRouteUrl = `/mydeliveries/sdps/{sdpId}/supportprojects/{programId}/edit`;\r\n\r\n  // For Program Management /  SDP / Deliveries\r\n  public static readonly SdpDeliveries = 'rmdelivery.sdp.deliveries';\r\n  public static readonly SdpDeliveriesRouteUrl = `/deliveries`;\r\n\r\n  // For Program Management /  SDP / Contacts\r\n  public static readonly SdpContacts = 'rmdelivery.sdp.contacts';\r\n  public static readonly SdpContactsRouteUrl = `/contacts`;\r\n\r\n  // For Program Management /  SDP / access id\r\n  public static readonly SdpAccessId = 'rmdelivery.sdp.accessid';\r\n  public static readonly SdpAccessIdRouteUrl = `/accessid`;\r\n\r\n  // For Program Management /  SDP / View Program\r\n  public static readonly SdpViewProgram = 'rmdelivery.sdp.viewprogram';\r\n  public static readonly SdpViewProgramRouteUrl = `/supportprojects/{programId}`;\r\n  public static readonly SdpProgramRouteParamProgramId = 'programId';\r\n  public static readonly SdpProgramRouteParamIsProspectiveCustomer = 'isProspectiveCustomer';\r\n\r\n\r\n  // For Program Management /  SDP / Edit Program\r\n  public static readonly SdpEditProgram = 'rmdelivery.sdp.editprogram';\r\n  public static readonly SdpEditProgramRouteUrl = `/supportprojects/{programId}/edit`;\r\n\r\n  // For Program Management /  SDP / Create Delivery\r\n  public static readonly SdpCreateDelivery = 'rmdelivery.sdp.createdelivery';\r\n  public static readonly SdpCreateDeliveryRouteUrl = `/deliveries/create`;\r\n\r\n  // For Program Management /  SDP / View Delivery\r\n  public static readonly SdpViewDelivery = 'rmdelivery.sdp.viewdelivery';\r\n  public static readonly SdpViewDeliveryRouteUrl = `/deliveries/{deliveryId}`;\r\n  public static readonly SdpDeliveryRouteParamDeliveryId = 'deliveryId';\r\n\r\n  // For Program Management /  SDP / Edit Delivery\r\n  public static readonly SdpEditDelivery = 'rmdelivery.sdp.editdelivery';\r\n  public static readonly SdpEditDeliveryRouteUrl = `/deliveries/{deliveryId}/edit`;\r\n\r\n  // For Program Management /  SDP / Outcomes\r\n  public static readonly SdpOutcomes = 'rmdelivery.sdp.outcomes';\r\n  public static readonly SdpOutcomesRouteUrl = `/outcomes`;\r\n\r\n  // For Program Management /  SDP / Agreements\r\n  public static readonly SdpAgreements = 'rmdelivery.sdp.agreements';\r\n  public static readonly SdpAgreementsRouteUrl = `/agreements`;\r\n\r\n  // For Program Management /  SDP / SuccessEngagement\r\n  public static readonly SuccessEngagement = 'rmdelivery.sdp.successengagement';\r\n  public static readonly SuccessEngagementUrl = `/successengagement`;\r\n  \r\n  // Leads Routes\r\n\r\n  // This route doesn't have to be explicit since it's being built from child routes\r\n  public static readonly SdpLeads = 'rmdelivery.sdp.supportneeds';\r\n  public static readonly SdpLeadsRouteUrl = `/supportneeds`;\r\n\r\n  // public static readonly SdpCreateLead = 'rmdelivery.sdp.leads.new';\r\n  public static readonly SdpCreateLead = 'supportneeds_create';\r\n  public static readonly SdpCreateLeadRouteUrl = `/mydeliveries/sdps/{sdpId}/supportneeds/new`;\r\n\r\n  public static readonly SdpEditLead = 'supportneeds_edit';\r\n  public static readonly SdpEditLeadRouteUrl = `/mydeliveries/sdps/{sdpId}/supportneeds/{leadId}/edit`;\r\n\r\n\r\n  // For Program Management /  SDP / Package / Summary\r\n  public static readonly SDPPackageSummary = 'rmdelivery.sdp.packageSummary';\r\n  public static readonly PackageSummaryRouteUrl = `/packages/{combinedPackageId}/overview`;\r\n  public static readonly PackageRouteCombinedPackageId = 'combinedPackageId';\r\n\r\n  // For Program Management /  SDP / Package / Consumption\r\n  public static readonly SdpConsumption = 'rmdelivery.sdp.consumption';\r\n  public static readonly PackageConsumptionRouteUrl = `/packages/{combinedPackageId}/consumption`;\r\n\r\n  // For Program Management / SDP / Package / Service\r\n  public static readonly SdpPackageService = 'rmdelivery.sdp.packageService';\r\n  public static readonly PackageServiceRouteUrl = `/packages/{combinedPackageId}/service`;\r\n\r\n  // For Program Management / SDP / Package / Cases\r\n  public static readonly SdpCases = 'rmdelivery.sdp.packageCases';\r\n  public static readonly PackageCasesRouteUrl = `/packages/{combinedPackageId}/cases`;\r\n\r\n  // For Program Management /  SDP / Package / Contacts\r\n  public static readonly SdpPackageCustomerContacts = 'rmdelivery.sdp.packageCustomerContacts';\r\n  public static readonly PackageCustomerContactsRouteUrl = `/packages/{combinedPackageId}/customercontacts`;\r\n\r\n  // For Program Management /  SDP / Package / Contacts\r\n  public static readonly SdpPackageContacts = 'rmdelivery.sdp.packageContacts';\r\n  public static readonly PackageContactsRouteUrl = `/packages/{combinedPackageId}/contacts`;\r\n\r\n  // For Program Management / SDP / Package / Mailing List\r\n  public static readonly SdpPackageMailingList = 'rmdelivery.sdp.packageMailingList';\r\n  public static readonly PackageMailingListRouteUrl = `/packages/{combinedPackageId}/schedule-mailing-list`;\r\n\r\n  // For Program Management / Package / Summary\r\n  public static readonly UnassignedPackageSummary = 'rmdelivery.packageSummary';\r\n\r\n  // For Program Management / Package / Consumption\r\n  public static readonly UnassignedPackageConsumption = 'rmdelivery.consumption';\r\n\r\n  // For Program Management / Package / Service\r\n  public static readonly UnassignedPackageService = 'rmdelivery.packageService';\r\n\r\n  // For Program Management / Package / Cases\r\n  public static readonly UnassignedPackageCases = 'rmdelivery.packageCases';\r\n\r\n  // For Program Management /  Package / Contacts\r\n  public static readonly UnassignedPackageContacts = 'rmdelivery.packageContacts';\r\n\r\n  // For Program Management /  SDP / Summary\r\n  public static readonly UnAuthorized = 'rmdelivery.sdp.unauthorized';\r\n  public static readonly UnAuthorizedRouteUrl = `/unauthorized`;\r\n  public static readonly UnAuthorizedOwnerCoOwnerList = 'OwnerCoOwnerList';\r\n\r\n  // For /queries\r\n  public static readonly QueryRouteName = 'rmdelivery.queries';\r\n  public static readonly QueryRouteUrl = '/queries/{queryName}';\r\n\r\n  // For /managequeries\r\n  public static readonly ManageQueriesRouteName = 'rmdelivery.manageQueries';\r\n  public static readonly ManageQueriesRouteUrl = '/manageQueries';\r\n\r\n\r\n\r\n  // For Program Management /  Agreements / Cases\r\n  public static readonly AgreementCase = 'rmdelivery.agreementCases';\r\n  public static readonly AgreementRouteCombinedAgreementId = 'combinedAgreementId';\r\n  public static readonly AgreementCaseRouteUrl = '/agreement/{combinedAgreementId}/cases';\r\n\r\n  // For Program Management /  Agreements / Consumption\r\n  public static readonly AgreementConsumption = 'rmdelivery.agreementSdpConsumption';\r\n  public static readonly AgreementConsumptionRouteUrl = `/agreements/{combinedAgreementId}/consumption`;\r\n\r\n  // For Program Management /  Agreements / Details\r\n  public static readonly AgreementDetails = 'rmdelivery.agreementsDetails';\r\n  public static readonly AgreementDetailseRouteUrl = '/agreement/{combinedAgreementId}/details';\r\n}\r\n","import { settings } from '../configs/appSettings';\r\nimport { aurorasit } from '../configs/appSettings.aurorasit';\r\nimport { dev } from '../configs/appSettings.dev';\r\nimport { prod } from '../configs/appSettings.prod';\r\nimport { sit } from '../configs/appSettings.sit';\r\nimport { uat } from '../configs/appSettings.uat';\r\nimport { IPartnerAppSettings } from '../interface/IPartnerAppSettings';\r\nimport { Environment } from '@fxp/fxpservices';\r\n\r\nexport const mergeObjects = (destination: object, ...sources: object[]): object => {\r\n    const sourceLength = sources.length;\r\n    for (let objIndex = 0; objIndex < sourceLength; objIndex++) {\r\n        const source = sources[objIndex];\r\n        if (typeof (source) === 'object') {\r\n            const keys = Object.keys(source);\r\n            const keysLength = keys.length;\r\n            Object.keys(source).forEach((key) => {\r\n                const prop = source[key];\r\n                if (typeof (prop) === 'object') {\r\n                    if (!typeof (destination[key] === 'object')) {\r\n                        destination[key] = Array.isArray(prop) ? [] : {};\r\n                    }\r\n                    mergeObjects(destination[key], prop);\r\n\r\n                } else {\r\n                    destination[key] = prop;\r\n                }\r\n            });\r\n            for (let keyIndex = 0; keyIndex < keysLength; keyIndex++) {\r\n\r\n            }\r\n        }\r\n    }\r\n    return destination;\r\n};\r\n\r\n\r\nexport const appSettings = (): IPartnerAppSettings => {\r\n    let environmentAppSetting;\r\n    switch (window['FxpAppSettings'].EnvironmentName) {\r\n        case Environment.Dev: environmentAppSetting = dev; break;\r\n        case Environment.Sit: environmentAppSetting = sit; break;\r\n        case Environment.Uat: environmentAppSetting = uat; break;\r\n        case Environment.AuroraSit: environmentAppSetting = aurorasit; break;\r\n        case Environment.Prod: environmentAppSetting = prod; break;\r\n        default: environmentAppSetting = dev; break;\r\n    }\r\n\r\n    // properties in later spreads “win out” over previously created properties.\r\n    const mergedSettings = mergeObjects(settings, environmentAppSetting);\r\n\r\n    return mergedSettings as IPartnerAppSettings;\r\n};\r\n\r\n","import { IPartnerAppSettings } from '../interface/IPartnerAppSettings';\r\n\r\nexport const aurorasit: IPartnerAppSettings = {\r\n  cdnBaseUrl: 'https://rmux.blob.core.windows.net/aurorasit',\r\n  serviceEndPoints: [\r\n    {\r\n      clientId: 'c1df0735-5f8f-4429-9977-80e732362bdd',\r\n      serviceEndPoint: 'https://professionalservicesint.microsoft.com/rmsvcsit/',\r\n    },\r\n    {\r\n      clientId: '00000003-0000-0000-c000-000000000000',\r\n      serviceEndPoint: 'https://graph.microsoft.com/',\r\n    },\r\n  ],\r\n  RmAppConfiguration: {\r\n    'oneProfile': 'https://oneprofilesitapipack-aurora.azurewebsites.net/api/v1/profile/searchprofile?searchText=%s',\r\n  }\r\n};\r\n","import { IPartnerAppSettings } from '../interface/IPartnerAppSettings';\r\n\r\nexport const dev: IPartnerAppSettings = {\r\n    cdnBaseUrl: 'http://localhost:5003',\r\n    serviceEndPoints: [\r\n        {\r\n            clientId: 'c1df0735-5f8f-4429-9977-80e732362bdd',\r\n            serviceEndPoint: 'https://professionalservicesint.microsoft.com/rmsvcsit/'\r\n            //serviceEndPoint: 'http://localhost:32073',\r\n        },\r\n        {\r\n            clientId: 'c1df0735-5f8f-4429-9977-80e732362bdd',\r\n            serviceEndPoint: 'https://fd-rmxcsvc-sit-dch6dacwbedegta6.b02.azurefd.net'\r\n            // serviceEndPoint: 'https://localhost:6001'\r\n        },\r\n        {\r\n            clientId: '00000003-0000-0000-c000-000000000000',\r\n            serviceEndPoint: 'https://graph.microsoft.com/'\r\n        },\r\n        {\r\n            clientId: 'c8955af6-b4a7-4e96-86b7-ad0930c25fa7',\r\n            serviceEndPoint: 'https://dmsit.azurewebsites.net/'\r\n        }\r\n    ],\r\n    RmAppConfiguration: {\r\n         //'rmServiceBaseUri': 'http://localhost:32073',\r\n         // 'rmGraphQLBaseUri': 'https://localhost:6001'\r\n    }\r\n};\r\n","import { IPartnerAppSettings } from '../interface/IPartnerAppSettings';\r\n\r\nexport const prod: IPartnerAppSettings = {\r\n  cdnBaseUrl: 'https://rmux.azureedge.net/prod-ux',\r\n  serviceEndPoints: [\r\n    {\r\n      clientId: 'e42b0f1c-114a-42a1-853a-089f1ab22b22',\r\n      serviceEndPoint: 'https://professionalservices.microsoft.com/rmsvc/',\r\n    },\r\n    {\r\n      clientId: 'e42b0f1c-114a-42a1-853a-089f1ab22b22',\r\n      serviceEndPoint: 'https://fd-rmxcsvc-prod-hea9ftfragehe3b9.b02.azurefd.net',\r\n    },\r\n    {\r\n      clientId: '00000003-0000-0000-c000-000000000000',\r\n      serviceEndPoint: 'https://graph.microsoft.com/',\r\n    },\r\n    {\r\n      clientId: '6db56845-5ebb-4b74-88d0-28cc0e41e163',\r\n      serviceEndPoint: 'https://professionalservices.microsoft.com/dm/',\r\n    }\r\n  ],\r\n  RmAppConfiguration: {\r\n    'rmServiceBaseUri': 'https://professionalservices.microsoft.com/rmsvc',\r\n    'rmGraphQLBaseUri': 'https://fd-rmxcsvc-prod-hea9ftfragehe3b9.b02.azurefd.net',\r\n    'apimSubscriptionKey': '417a9ef072044af7857c0def6a5ed7af',\r\n    'PartnerEndpoints': [\r\n      {\r\n        'Endpoint': 'https://professionalservices.microsoft.com/rmsvc/',\r\n        'ResourceId': 'e42b0f1c-114a-42a1-853a-089f1ab22b22'\r\n      }\r\n    ],\r\n    'opportunities': {\r\n      'msxLink': 'https://microsoftsales.crm.dynamics.com/main.aspx?appid=fe0c3504-3700-e911-a849-000d3a10b7cc&pagetype=entityrecord&etn=opportunity&id={0}'\r\n    },\r\n    'cloudConsumption': {\r\n      'sccr': 'https://microsoft.sharepoint.com/teams/esbi/cloud%20consumption/pages/default.aspx',\r\n      'cePortalForConsumption': 'https://cecustomers.microsoftonline.com/',\r\n      'us_bsoReporting': 'https://microsoft.sharepoint.com/teams/usmobpo/bso/SitePages/reports-for-msxi.aspx?chromeless=True'\r\n    },\r\n    'serviceFinancials': {\r\n      'tamRolePerformanceDashboard': 'https://msit.powerbi.com/groups/me/reports/c9c3a607-be68-49fe-a89f-c75409c8f0fa/ReportSectionf7f244c90383db8a1c8d',\r\n      'servicesInsightsES': 'https://msit.powerbi.com/groups/56e3ce91-0de0-43bb-a4b3-245db704ea4a/dashboards/283edfd8-d60b-451b-b296-c25b1e09aa'\r\n    },\r\n    'featureFlighting': {\r\n      'appName': 'Relationship Management Experience',\r\n      'environment': 'prod'\r\n    },\r\n    'oneProfile': 'https://oneprofileprodapipack.azurefd.net/api/v1/profile/searchprofile?searchText=%s',\r\n    'axisConfig': {\r\n      'requestDetails': 'https://esxp.microsoft.com/#/supportdelivery/requestdetails/%s'\r\n    },\r\n    'msxConfig': {\r\n      'engagementMsxUrlTemplate': 'https://microsoftsales.crm.dynamics.com/main.aspx?appid=fe0c3504-3700-e911-a849-000d3a10b7cc&pagetype=entityrecord&etn=msp_engagement&id=%s',\r\n      'milestoneMsxUrlTemplate': 'https://microsoftsales.crm.dynamics.com/main.aspx?appid=fe0c3504-3700-e911-a849-000d3a10b7cc&pagetype=entityrecord&etn=msp_engagementmilestone&id=%s'\r\n    },\r\n    'supportDeliveryApimSubscriptionKey': 'bcdb82ce854046859e1eb53fc166b9f4',\r\n    'supportDeliveryBaseUrl': 'https://professionalservices.microsoft.com/dm/api/v1',\r\n    'supportDeliveryApi': {\r\n      'BatchDeliveriesRequest':'/Batch/Deliveries?includeAssignments=%s',\r\n      'GetDeliveriesCounts': '/Landing/Requests/%s/Count',\r\n      'SupportDeliveries': 'https://esxp.microsoft.com/#/supportdelivery/mydeliveries',\r\n      'FilteredSupportDeliveries': 'https://esxp.microsoft.com/#/supportdelivery/mydeliveries?status=%s'\r\n    }\r\n  }\r\n};\r\n","import { IPartnerAppSettings } from '../interface/IPartnerAppSettings';\r\n\r\nexport const sit: IPartnerAppSettings = {\r\n  cdnBaseUrl: 'https://rmux-nonprod.azureedge.net/servicesint-ux',\r\n  serviceEndPoints: [\r\n    {\r\n      clientId: 'c1df0735-5f8f-4429-9977-80e732362bdd',\r\n      serviceEndPoint: 'https://professionalservicesint.microsoft.com/rmsvcsit/',\r\n    },\r\n    {\r\n      clientId: 'c1df0735-5f8f-4429-9977-80e732362bdd',\r\n      serviceEndPoint: 'https://fd-rmxcsvc-sit-dch6dacwbedegta6.b02.azurefd.net'\r\n    },\r\n    {\r\n      clientId: '00000003-0000-0000-c000-000000000000',\r\n      serviceEndPoint: 'https://graph.microsoft.com/',\r\n    },\r\n    {\r\n      clientId: '181ef486-9e47-4ad6-9454-7a326432dc00',\r\n      serviceEndPoint: 'https://professionalservicesint.microsoft.com/dmuat/',\r\n    }\r\n  ],\r\n  RmAppConfiguration: {}\r\n};\r\n","import { IPartnerAppSettings } from '../interface/IPartnerAppSettings';\r\n\r\nexport const settings: IPartnerAppSettings = {\r\n    cdnBaseUrl: 'https://rmux.blob.core.windows.net/servicesint',\r\n    serviceEndPoints: [\r\n        {\r\n            clientId: 'c1df0735-5f8f-4429-9977-80e732362bdd',\r\n            serviceEndPoint: 'https://professionalservicesint.microsoft.com/rmsvcsit/'\r\n        },\r\n        {\r\n            clientId: 'c1df0735-5f8f-4429-9977-80e732362bdd',\r\n            serviceEndPoint: 'https://fd-rmxcsvc-sit-dch6dacwbedegta6.b02.azurefd.net'\r\n        },\r\n        {\r\n            clientId: '00000003-0000-0000-c000-000000000000',\r\n            serviceEndPoint: 'https://graph.microsoft.com/',\r\n        },\r\n        {\r\n            clientId: 'c8955af6-b4a7-4e96-86b7-ad0930c25fa7',\r\n            serviceEndPoint: 'https://dmsitafd.azurefd.net/',\r\n        }\r\n    ],\r\n    RmAppConfiguration: {\r\n        'rmServiceBaseUri': 'https://professionalservicesint.microsoft.com/rmsvcsit',\r\n        'rmGraphQLBaseUri': 'https://fd-rmxcsvc-sit-dch6dacwbedegta6.b02.azurefd.net',\r\n        'graphApiBaseUri': 'https://graph.microsoft.com/v1.0',\r\n        'graphApiBatchSize': 20,\r\n        'PartnerEndpoints': [\r\n            {\r\n                'Endpoint': 'https://professionalservicesint.microsoft.com/rmsvcsit',\r\n                'ResourceId': 'c1df0735-5f8f-4429-9977-80e732362bdd'\r\n            },\r\n            {\r\n                'Endpoint': 'https://graph.microsoft.com/',\r\n                'ResourceId': '00000003-0000-0000-c000-000000000000'\r\n            }\r\n        ],\r\n        'rmServiceApi': {\r\n            'AccountDetails': '/api/Accounts/%s/details',\r\n            'AccountOpportunities': '/api/accounts/%s/opportunities?pageNumber=%s&includeProducts=%s',\r\n            'SdpProgram': '/api/sdps/%s/Programs',\r\n            'EditProgram': '/api/sdps/%s/Programs/%s',\r\n            'DeleteSdpProgram': '/api/sdps/%s/Programs/delete',\r\n            'GetPortfolioPrograms': '/api/Programs',\r\n            'DeliveriesByAlias': '/api/deliveries',\r\n            'GetBasicDeliveriesBySdpId': '/api/sdps/%s/basicdeliveries',\r\n            'GetDeliveriesBySdpId': '/api/sdps/%s/deliveries',\r\n            'GetDeliveriesBySdpIdReports': '/api/report/sdps/%s/deliveries',\r\n            'GetBasicDeliveriesByProgramId': '/api/sdps/%s/programs/%s/basicdeliveries',\r\n            'GetDeliveriesByProgramId': '/api/sdps/%s/programs/%s/deliveries',\r\n            // Packages is deprecated by GetPackages\r\n            'Packages': '/api/packages?packageType=%s&%s&userAlias=%s',\r\n            'GetPackages': '/api/packages?packageType=%s&%s&userAlias=%s',\r\n            // PackageById is deprecated by GetPackageById\r\n            'PackageById': '/api/packages/%s?includeServices=%s&includeAgreement=%s&includeContacts=%s&filterServices=%s&excludeCKPContacts=%s',\r\n            'GetPackageById': '/api/packages/%s?includeServices=%s&includeAgreement=%s&includeContacts=%s&filterServices=%s&excludeCKPContacts=%s',\r\n            // AssignedPackages is deprecated by GetSdpPackages\r\n            'AssignedPackages': '/api/sdps/%s/packages?filterPackagesWithoutDeliveries=%s&%s&includeServices=%s',\r\n            'GetSdpPackages': '/api/sdps/%s/packages?filterPackagesWithoutDeliveries=%s&%s&includeServices=%s&includeContacts=%s',\r\n            // PackageConsumption is deprecated by GetPackageConsumptions\r\n            'PackageConsumption': '/api/packages/%s/consumptions?',\r\n            'GetPackageConsumptions': '/api/packages/%s/consumptions?',\r\n            // tamSearchGroupBySdp is deprecated by GetSdpListByAlias\r\n            'tamSearchGroupBySdp': '/api/sdps?tamAlias=%s&includeInactive=%s',\r\n            'GetSdpListByAlias': '/api/sdps?tamAlias=%s&includeInactive=%s',\r\n            // AdjustmentsEligible is deprecated by AdjustmentsEligibility\r\n            'AdjustmentsEligible': '/api/Packages/%s/Services/%s/IsEligible',\r\n            'AdjustmentsEligibility': '/api/Packages/%s/Services/%s/IsEligible',\r\n            // AdjustmentList is deprecated by GetAdjustmentDetails\r\n            'AdjustmentList': '/api/Packages/%s/Services/%s/Adjustments',\r\n            'GetAdjustmentDetails': '/api/Packages/%s/Services/%s/Adjustments?regionType=%s&componentCode=%s',\r\n            'MsftSdpTeamContacts': '/api/sdps/%s/msftsdpteamcontacts',\r\n            // Offerings is deprecated by GetOfferings\r\n            'Offerings': '/api/Offerings',\r\n            'GetOfferings': '/api/Offerings',\r\n            'GetOffering': '/api/Offerings/%s',\r\n            'CustomerContacts': '/api/Packages/%s/customerContacts',\r\n            'OrgUnitsBySdpId': '/api/sdps/%s/OrgUnits',\r\n            'CreateMsftSdpTeamContact': '/api/sdps/%s/MsftSdpTeamContacts',\r\n            'EditMsftSdpTeamContact': '/api/sdps/%s/MsftSdpTeamContacts/%s',\r\n            'DeleteMsftSdpTeamContact': '/api/sdps/%s/MsftSdpTeamContacts/delete',\r\n            'AssignPackageToSdp': '/api/sdps/%s/packages',\r\n            'GetAirportCodes': '/api/DeliveryRequests/airportcodes',\r\n            'GetWorldLanguages': '/api/DeliveryRequests/languages',\r\n            'BillingChoices': '/api/DeliveryRequests/billingchoices',\r\n            'GetDressCodes': '/api/DeliveryRequests/dresscodes',\r\n            'GetTransportationChoices': '/api/DeliveryRequests/transportations',\r\n            'GetCountries': '/api/DeliveryRequests/countries',\r\n            'GetStateChoices': '/api/DeliveryRequests/GetStatesByCountry?countryCode=%s',\r\n            'GetCityChoices': '/api/DeliveryRequests/GetCitiesByStateAndCountry?countryCode=%s&stateName=%s',\r\n            // Cities is deprecated by GetCityChoices\r\n            'Cities': '/api/DeliveryRequests/GetCitiesByStateAndCountry?countryCode=%s&stateName=%s',\r\n            'GetTimeZoneChoices': '/api/DeliveryRequests/timezones',\r\n            'SDPSummaryDetails': '/api/sdps/%s',\r\n            'AgreementRenewalMetrics': '/api/Agreements/renewalmetrics',\r\n            'Agreements': '/api/Agreements',\r\n            'AgreementDetail': '/api/Agreements/%s?InstallationSiteId=%d&FetchFromCache=false',\r\n            'DmmAgreements': '/api/Agreements/directreports',\r\n            'AssignedPackagesReports': '/api/report/sdps/%s/packages?filterPackagesWithoutDeliveries=%s&%s&includeServices=%s',\r\n            'PackageConsumptionReports': '/api/report/packages/%s/consumptions?',\r\n            'CreateCustomerContact': '/api/packages/%s/contacts',\r\n            'ReactiveDeliveriesAggregatedByStatus': '/api/reactivedeliveries/status',\r\n            'ReactiveDeliveries': '/api/reactivedeliveries',\r\n            'SdpReactiveDeliveries': '/api/sdps/%s/reactivedeliveries',\r\n            'DeliveryRequestDrafts': '/api/DeliveryRequests/drafts',\r\n            'GetDeliveryById': '/api/Sdps/%s/deliveries/%s',\r\n            'KeyActions': '/api/KeyActions',\r\n            'KeyActionsCompletion': '/api/KeyActions/%s/completionStatus',\r\n            'KeyActionsBySdpId': '/api/KeyActions/sdps/%s',\r\n            'GetCaseDetailsByPackageId': '/api/Packages/%s/cases',\r\n            'AdjustmentReason': '/api/Packages/%s/Services/%s/Reasons',\r\n            'AddAdjustment': '/api/Packages/%s/Services/%s/Adjustments',\r\n            'EditAdjustment': '/api/Packages/%s/Services/%s/Adjustments/%s',\r\n            'DeliveryRequests': '/api/DeliveryRequests',\r\n            'DeliveryReviewDetail': '/api/sdps/deliveryreviewdetail',\r\n            'AccessIdDetailsById': '/api/accessid/%s?packageId=%d',\r\n            'UnMapUsersFromAccessId': '/api/accessid/%s/profiles/unmap',\r\n            // CaseSummary is deprecated by GetCaseSummary\r\n            'CaseSummary': '/api/cases/summary',\r\n            'GetCaseSummary': '/api/cases/summary',\r\n            'ProactiveDeliveriesAggregatedByStatus': '/api/deliveries/status',\r\n            'GetPasswordByAccessId': '/api/accessid/%s',\r\n            'SetPasswordByAccessId': '/api/accessid/%s',\r\n            'DisassociateCustomerContact': '/api/customercontacts/delete',\r\n            'ReactiveCaseDetails': '/api/cases',\r\n            'AssignPackageToNewSdp': '/api/Sdps',\r\n            'DeleteAdjustments': '/api/Packages/%s/Services/%s/Adjustments/Delete',\r\n            'GetPesProductsByName': '/api/Offerings/Products?productName=%s',\r\n            'Skills': '/api/DeliveryRequests/Skills',\r\n            'EditDeliveryDraft': '/api/sdps/%s/deliveries/%s',\r\n            'EditSubmittedDelivery': '/api/sdps/%s/deliveries/%s',\r\n            'EditCustomerContact': '/api/packages/%s/updateContact',\r\n            'DeliveryRequestSync': '/api/DeliveryRequests/sync',\r\n            'CreateAndLinkBasicDelivery': '/api/programs/basicdeliveries',\r\n            'SyncDeliveryByRossId': '/api/sdps/%s/programs/%s/deliverysync/%s',\r\n            'RmUserLogin': '/api/UserLogin',\r\n            'DeleteSdp': '/api/sdps/%s',\r\n            'UnlinkPackageFromSdp': '/api/Sdps/%s/Packages/Delete',\r\n            'DeleteDelivery': '/api/Sdps/%s/deliveries/%s',\r\n            'EditCampusSite': '/api/Sdps/%s/campussites',\r\n            'AddCampusSite': '/api/Sdps/%s/campussites',\r\n            'DeleteCampusSite': '/api/Sdps/%s/campussites/delete',\r\n            'UpdateSdpSPM': '/api/sdps/%s/msftsdpteamcontacts/updateSpm',\r\n            'GetReviewBySdpId': '/api/sdps/%s/SdpReviews',\r\n            'GetReviewBySdpIdReports': '/api/report/sdps/%s/SdpReviews',\r\n            'EditTAMBAMAlias': '/api/Packages/%s',\r\n            'AgreementPackages': '/api/Agreements/%s',\r\n            'tamSearchGroupByAgreement': '/api/Agreements?userAlias=%s&agreementStatus=%s',\r\n            'casesHealthOptions': '/api/Cases/%s/HealthStateDetails',\r\n            'casesHealthDetails': '/api/Cases/%s/HealthDetails',\r\n            'casesAddHealthDetails': '/api/Cases/%s/HealthDetails',\r\n            'GetCaseTrendDetails': '/api/Cases/%s/TrendDetails',\r\n            'GetParentTrendDetails': '/api/Cases/%s/ParentTrendDetails',\r\n            'GetChildTrendDetails': '/api/Cases/%s/%s/ChildTrendDetails',\r\n            'AddTrendDetails': '/api/Cases/%s/TrendDetails',\r\n            'UpdateTrendDetails': '/api/Cases/%s/TrendDetails',\r\n            'sdpReviewDataOptions': '/api/sdps?tamAlias=%s&accessLevel=%s',\r\n            'SdpReviewDataOptionsReports': '/api/report/sdps?tamAlias=%s&accessLevel=%s',\r\n            'SubmitNewSdpReview': '/api/sdps/%s/SdpReviews/Create',\r\n            'GetSurveyHeaders': '/api/Surveys',\r\n            'GetDMMSurveyHeaders': '/api/dmm/Surveys',\r\n            'GetSurveyDetails': '/api/Surveys/%s?packageId=%s&regionType=%s',\r\n            'GetDMMSurveyDetails': '/api/dmm/Surveys/%s?packageId=%s&regionType=%s',\r\n            'GetSurveyResponses': '/api/Surveys/%s/customerSurveyResponse?packageId=%s',\r\n            'GetSurveyOptions': '/api/Surveys/options',\r\n            'UpdateSurvey': '/api/Surveys/%s?packageId=%s&regionType=%s',\r\n            'DMMUpdateSurvey': '/api/dmm/Surveys/%s?packageId=%s&regionType=%s',\r\n            'CreateRCA': '/api/Surveys/%s/rcas?packageId=%s&regionType=%s',\r\n            'UpdateRCA': '/api/Surveys/%s/rcas/%s?packageId=%s&regionType=%s',\r\n            'DeleteRCA': '/api/Surveys/%s/rcas/%s?packageId=%s&regionType=%s',\r\n            'CreateRemediation': '/api/Surveys/%s/rcas/%s/remediationStep?packageId=%s&regionType=%s',\r\n            'UpdateRemediation': '/api/Surveys/%s/rcas/%s/remediationSteps/%s?packageId=%s&regionType=%s',\r\n            'DeleteRemediation': '/api/Surveys/%s/rcas/%s/remediationSteps/%s?packageId=%s&regionType=%s',\r\n            'GetSurveyAggregates': '/api/Surveys/aggregates',\r\n            'GetAzureInternalBillingAccounts': '/api/AzureInternalBillingAccounts',\r\n            'GetAzureInternalAccountsAlert': '/api/azureinternalbillingaccountsalerts',\r\n            'GetAzureBillingAccounts': '/api/azurebillingaccounts',\r\n            'GetAzureAccountsAlert': '/api/azurebillingaccountsalerts',\r\n            'AddAzureSubscription': '/api/azurebillingaccounts/%s/packages',\r\n            'AddAzureInternalSubscription': '/api/azureinternalbillingaccounts/%s/packages',\r\n            'GetO365Tenants': '/api/O365Tenants',\r\n            'GetO365TenantAlerts': '/api/o365tenantsalerts',\r\n            'GetAzureInternalPackagesBySubscriptionId': '/api/azureinternalsubscriptions/%s/probablePackages',\r\n            'GetAzurePackagesBySubscriptionId': '/api/azuresubscriptions/%s/probablePackages',\r\n            'ProgramsSummary': '/api/sdps/%s/Programs',\r\n            'GetProgramDetails': '/api/program/basicDetails',\r\n            'ProgramSummaryForProgram': '/api/sdps/%s/Programs/%s/summary',\r\n            'GetO365ProbableTenants': '/api/o365probabletenants?tenantId=%s&domainName=%s',\r\n            'AddO365ProbableTenantsWithPackage': '/api/o365tenants/%s/packages',\r\n            'UpdateO365Tenants': '/api/o365tenantsmatchings',\r\n            'GetSdpRisksAndIssues': '/api/sdps/%s/issuerisks',\r\n            'GetProgramRisksAndIssues': '/api/sdps/%s/programs/%s/issueRisks',\r\n            'GetMailingList': '/api/packages/%s/mailingLists',\r\n            'AddMailingList': '/api/packages/%s/mailingLists',\r\n            'EditMailingList': '/api/packages/%s/mailingLists/%s',\r\n            'DeleteMailingList': '/api/packages/%s/MailingLists/%s',\r\n            'GetMailingListOptions': '/api/config/dropdowns/%s',\r\n            'GetO365TenantsV2': '/api/v2/o365tenants',\r\n            'UpdateO365TenantsV2': '/api/v2/o365tenants/matchings',\r\n            'GetO365SearchTenantsV2': '/api/v2/o365searchtenants?searchType=%s&searchValue=%s',\r\n            'GetO365Packages': '/api/v2/o365packages',\r\n            'GetAzureBillingAccountsV2': '/api/v2/azurebillingaccounts',\r\n            'UpdateAzureBillingAccountV2': '/api/v2/azurebillingaccounts/matching',\r\n            'GetAzureSearchSubscriptionsV2': '/api/v2/azuresearchsubscriptions?searchType=%s&searchValue=%s',\r\n            'GetAzurePackages': '/api/v2/azurepackages',\r\n            'GetAzureInternalBillingAccountsV2': '/api/v2/AzureInternalBillingAccounts',\r\n            'UpdateAzureInternalBillingAccountV2': '/api/v2/azureinternalbillingaccounts/matching',\r\n            'GetAzureInternalSearchSubscriptionsV2': '/api/v2/azureinternalsearchsubscriptions?subscriptionId=%s',\r\n            'GetAzureInternalPackages': '/api/v2/azureinternalpackages',\r\n            'GetAzureAndInternalSubscriptionsV3': '/api/v3/azuresubscriptions',\r\n            'UpdateAzureUnMatchSubscriptionsV3': '/api/v3/azuresubscriptions/unmatch',\r\n            'UpdateAzureMatchSubscriptionsV3': '/api/v3/azuresubscriptions/match',\r\n            'UpdateSubscriptionNoSupportDetailsV3': '/api/v3/azuresubscriptions/nosupport',\r\n            'GetO365TenantsV3': '/api/v3/o365tenants',\r\n            'UpdateO365UnMatchTenantsV3': '/api/v3/o365tenants/unmatch',\r\n            'UpdateO365MatchTenantsV3': '/api/v3/o365tenants/match',\r\n            'UpdateTenantNoSupportDetailsV3': '/api/v3/o365tenants/nosupport',\r\n            'GetCkpV3Packages': '/api/v3/azuresubscriptions/ckppackages?serviceType=%s',\r\n            'GetEnrollmentDetails': '/api/v3/azuresubscriptions/enrollmentDetails',\r\n            'CreateSdpRisksAndIssues': '/api/sdps/%s/issueRisks',\r\n            'CreateProgramRisksAndIssues': '/api/sdps/%s/programs/%s/issueRisks',\r\n            'SearchByAgreement': '/api/Agreements/Search',\r\n            'GetSdpProgram': '/api/sdps/%s/programs/%s',\r\n            'UpdateAzureInternalBillingAccount': '/api/azureinternalbillingaccountsmatching',\r\n            'UpdateAzureBillingAccount': '/api/azurebillingaccountsmatching',\r\n            'MsftProgramTeamContacts': '/api/sdps/%s/programs/%s/MsftProgramTeamContacts',\r\n            'CreateMsftProgramTeamContacts': '/api/sdps/%s/programs/%s/MsftProgramTeamContacts',\r\n            'DeleteMsftProgramTeamContacts': '/api/sdps/%s/programs/%s/MsftProgramTeamContacts/delete',\r\n            'UpdateMsftProgramTeamContacts': '/api/sdps/%s/programs/%s/MsftProgramTeamContacts/%s',\r\n            'GetSdpActionRegister': '/api/sdps/%s/actions',\r\n            'GetProgramActions': '/api/sdps/%s/programs/%s/actions',\r\n            'EditSdpActionRegister': '/api/sdps/%s/actions/%s',\r\n            'EditProgramActionRegister': '/api/sdps/%s/programs/%s/actions/%s',\r\n            'BillableAccountIdUrlFormat': 'https://cecustomers.microsoftonline.com/#account/%s',\r\n            'TenantIdUrlFormat': 'https://lynx.office.net/#/tenants/%s/health/exchange',\r\n            'GetLeads': '/api/sdps/%s/Leads',\r\n            'GetLeadsGraphQL': '/graphql',\r\n            'GetLead': '/api/sdps/%s/Leads/%s',\r\n            'GetLeadGraphQL': '/graphql',\r\n            'CreateLead': '/api/sdps/%s/Leads',\r\n            'EditLead': '/api/sdps/%s/Leads/%s',\r\n            'DisqualifyLead': '/api/sdps/%s/Leads/%s/disqualify',\r\n            'CreateLeadV1': '/api/v1.0/supportneeds',\r\n            'EditLeadV1': '/api/v1.0/supportneeds',\r\n            'DisqualifyLeadV1': '/api/v1.0/supportneeds/%s/disqualify?customerId=%s',\r\n            'GetLeadOptions': '/api/config/dropdowns/%s',\r\n            'GetLeadOptionsGraphQL': '/graphql',\r\n            'GetOptions': '/api/config/dropdowns/%s',\r\n            'UpdateSdpRiskAndIssues': '/api/sdps/%s/issuerisks/%s',\r\n            'UpdateProgramRiskAndIssues': '/api/sdps/%s/programs/%s/issuerisks/%s',\r\n            'LinkLeadsToProgram': '/api/sdps/%s/Programs/%s/link',\r\n            'DeleteSdpAction': '/api/sdps/%s/actions/delete',\r\n            'GetSdpDecisionLog': '/api/sdps/%s/decisionlogs',\r\n            'AddSdpDecisionLog': '/api/sdps/%s/decisionlogs',\r\n            'EditSdpDecisionLog': '/api/sdps/%s/decisionlogs/%s',\r\n            'EditProgramDecisionLog': '/api/sdps/%s/programs/%s/decisionlogs/%s',\r\n            'DeleteProgramAction': '/api/sdps/%s/programs/%s/actions/delete',\r\n            'DeleteSdpDecisionLog': '/api/sdps/%s/decisionlogs?decisionLogIds=%s',\r\n            'DeleteProgramDecisionLog': '/api/sdps/%s/programs/%s/decisionlogs?decisionLogIds=%s',\r\n            'DeleteSdpRisksAndIssues': '/api/sdps/%s/issuerisks/delete',\r\n            'DeleteProgramRisksAndIssues': '/api/sdps/%s/programs/%s/issuerisks/delete',\r\n            'DeleteProgramDeliveryStatus': '/api/sdps/%s/programs/%s/deliverystatuses/delete',\r\n            'UnlinkLeadsFromProgram': '/api/sdps/%s/programs/%s/unlink',\r\n            'AddProgramDeliveryStatus': '/api/sdps/%s/programs/%s/deliverystatuses',\r\n            'EditProgramDeliveryStatus': '/api/sdps/%s/programs/%s/deliverystatuses/%s',\r\n            'GetProgramDeliveryStatuses': '/api/sdps/%s/programs/%s/deliverystatuses',\r\n            'GetProgramLeads': '/api/sdps/%s/programs/%s/Leads',\r\n            'GetProgramLeadsGraphQL': '/graphql',\r\n            'GetProgramDecisionLog': '/api/sdps/%s/programs/%s/decisionlogs',\r\n            'AddProgramDecisionLog': '/api/sdps/%s/programs/%s/decisionlogs',\r\n            'TransferDeliveries': '/api/sdps/%s/programs/%s/deliveries/transfer',\r\n            'GetSDPCustomerContacts': '/api/sdps/%s/contacts',\r\n            'GetSDPCustomerContact': '/api/sdps/%s/contacts/%s',\r\n            'GetProgramCustomerContacts': '/api/sdps/%s/programs/%s/contacts',\r\n            'CreateSDPCustomerContacts': '/api/sdps/%s/contacts',\r\n            'UpdateProgramCustomerContact': '/api/sdps/%s/programs/%s/contacts/%s',\r\n            'UpdateCustomerContactProperties': '/api/sdps/%s/contacts/%s',\r\n            'GetDispositionByProgramId': '/api/sdps/%s/programs/%s/dispositions',\r\n            'SaveProgramDisposition': '/api/sdps/%s/programs/%s/dispositions',\r\n            'UnlinkCustomerContactFromProgram': '/api/sdps/%s/programs/%s/contacts/delete',\r\n            'LinkCustomerContactToProgram': '/api/sdps/%s/programs/%s/contacts/%s/create',\r\n            'GetPackageMsftContacts': '/api/packages/%s/msftcontacts',\r\n            'AgreementConsumption': '/api/Agreements/%s/Consumptions',\r\n            'CreatePackageMsftContact': '/api/packages/%s/msftcontacts/create',\r\n            'UpdatePackageMsftContact': '/api/packages/%s/msftcontacts/%s',\r\n            'DeletePackageMsftContact': '/api/packages/%s/msftcontacts/%s/%s',\r\n            'GetCasesDetailsByAgreement': '/api/agreements/%s/cases?regionType=%s',\r\n            // PostCasesDetailsByAgreement is Deprecated\r\n            // TODO: REMOVE THIS OLD ENDPOINT WHEN PSR RETIRES\r\n            'PostCasesDetailsByAgreement': '/api/agreements/%s/cases',\r\n            'GetExpenseDecrements': '/api/packages/%s/services/%s/transactions/expenses?regionType=%s&componentCode=%s',\r\n            'CreateExpenseDecrement': '/api/packages/%s/services/%s/transactions/expenses?regionType=%s',\r\n            'UpdateExpenseDecrement': '/api/packages/%s/services/%s/transactions/expenses/%s?regionType=%s',\r\n            'DeleteExpenseDecrement': '/api/packages/%s/services/%s/transactions/expenses/%s?regionType=%s&componentCode=%s',\r\n            'CaseLaborAdjustmentReasons': '/api/case/Adjustments/Reasons?packageId=%s&serviceId=%s&componentCode=%s',\r\n            'CaseAdjustmentdetails': '/api/case/Adjustments?caseNumber=%s',\r\n            'AddCaseLaborAdjustment': '/api/packages/%s/cases/%s',\r\n            'EditCaseLaborAdjustment': '/api/packages/%s/cases/%s',\r\n            'CdsAgreementConsumption': '/api/agreements/%s/Consumptions/region/%s',\r\n            'DeleteCaseLaborAdjustment': '/api/packages/%s/cases/%s/delete',\r\n            'GetBulkMailPackages': '/api/packages/%s',\r\n            'GetProgram': '/api/sdps/%s/programs/%s',\r\n            'CreateProgram': '/api/v2/sdps/%s/programs',\r\n            'CreateProgramFromWizard': '/api/sdps/%s/programs/wizard',\r\n            'EditProgramV2': '/api/v2/sdps/%s/programs/%s',\r\n            'UpdateProgramState': '/api/v2/sdps/%s/programs/%s',\r\n            'GetProgramOutcomes': '/api/sdps/%s/programs/%s/Outcomes',\r\n            'CreateProgramOutcome': '/api/sdps/%s/programs/%s/Outcomes',\r\n            'DeleteProgramOutcomes': '/api/sdps/%s/programs/%s/Outcomes/%s',\r\n            'EditProgramOutcome': '/api/sdps/%s/programs/%s/Outcomes/%s',\r\n            'GetUnifiedDetails': '/api/deliverymetrics/unified-deliveries?userAlias=%s',\r\n            'GetPlanDetails': '/api/deliverymetrics/planned-deliveries?userAlias=%s',\r\n            'GetDeliverOverBookedDetails': '/api/deliverymetrics/overbooked-deliveries?userAlias=%s',\r\n            'GetDeliverBookedDetails': '/api/deliverymetrics/booked-deliveries?userAlias=%s',\r\n            'GetDeliverBehindOnDeliveryDetails': '/api/deliverymetrics/delayed-deliveries?userAlias=%s',\r\n            'GetAzureAndAzureInternalSearchSubscriptionsV3': '/api/v3/azuresubscriptions/search?searchType=%s&searchValue=%s&RegionId=%s',\r\n            'GetO365SearchTenantsV3': '/api/v3/o365tenants/search?searchType=%s&searchValue=%s&RegionId=%s',\r\n            'GetDmmCkpDetails': '/api/matchingmetrics/dmm',\r\n            'GetCSAMCloudSupportDetails': '/api/matchingmetrics', \r\n            'GetEngagements': '/api/accounts/%s/engagements?ViewType=%s',\r\n            'GetEngagementsBySdp': '/api/sdps/%s/engagements?engagementViewType=%s',\r\n            'GetEngagementsByProgramId': '/api/sdps/%s/programs/%s/engagements',\r\n            'GetMilestones': '/api/accounts/%s/engagements/%s/milestones',\r\n            'GetMilestonesByOpportunityId': '/api/v2/opportunities/%s/milestones?accountId=%s',            \r\n            'GetMilestonesByProgramId': '/api/sdps/%s/programs/%s/milestones',\r\n            'LinkEngagementsToProgram': '/api/sdps/%s/programs/%s/engagements',\r\n            'LinkMilestoneToProgram': '/api/sdps/%s/programs/%s/milestone',\r\n            'UnlinkEngagementsFromProgram': '/api/sdps/%s/programs/%s/engagement/%s?ids=%s',\r\n            'UnlinkMilestonesFromProgram': '/api/sdps/%s/programs/%s/milestone/%s?ids=%s',\r\n            'UnlinkSalesEntitiesFromProgram': '/api/v1/sdps/%s/programs/%s/salesentities?%s&salesEntityType=%s',\r\n            'GetProgramsBySalesEntity': '/api/v1/salesentities/%s/programs?salesEntityType=%s',\r\n            'GetSalesEntitesByProgram':'/api/v1/sdps/%s/programs/%s/salesentities?salesEntityType=%s',\r\n            'LinkSalesEntitiesToProgram':'/api/v1/sdps/%s/programs/%s/salesentities',\r\n            'GetSalesEntitesBySdpId':'/api/v1/sdps/%s/salesentities?salesEntityType=%s',\r\n            'GetCSPMAuditHistory': '/api/v3/cspmaudithistory?searchType=%s&searchValue=%s',\r\n            'DeleteProgram': '/api/sdps/%s/Programs/%s',\r\n            'GetUnlinkedDeliveryRequests': '/api/programs/deliveries/unlinked',\r\n            'LinkDeliveryRequestToProgram': '/api/v1/sdps/%s/programs/%s/manualmatch-program',\r\n            'CreateSupportProjectTemplate': '/api/v1/programTemplates',\r\n            'GetOpportunitiesBySdpId': '/api/sdps/%s/opportunities',\r\n            'GetOpportunitiesBySdpIdV2': '/api/v2/sdps/%s/opportunities?opportunityViewType=%s',\r\n            'CreateNewProspectiveCustomer': '/api/Sdps/prospect',\r\n            'GetFlightedCountries': '/api/config/scopedRequest/flightcountries',\r\n            'GetCustomerDeliverySettingGraphQL':'/graphql',\r\n            'GetUnlinkedSupportProjectsGraphQL':'/graphql',\r\n            'SaveCustomerDeliverySettingGraphQL':'/api/v1.0/customer/%s/deliveries/settings/save'\r\n        },\r\n        'ckpServiceApis':\r\n        {\r\n            'AzureMatches': '/api/Azure/GetBillingAccounts?'\r\n        },\r\n        'opportunities': {\r\n            'msxLink': 'https://msxuat.crm.dynamics.com/main.aspx?appid=fe0c3504-3700-e911-a849-000d3a10b7cc&pagetype=entityrecord&etn=opportunity&id={0}'\r\n        },\r\n        'cloudConsumption': {\r\n            'sccr': 'https://microsoft.sharepoint.com/teams/esbi/cloud%20consumption/pages/default.aspx',\r\n            'cePortalForConsumption': 'https://cecustomers.microsoftonline.com/',\r\n            'us_bsoReporting': 'https://microsoft.sharepoint.com/teams/usmobpo/bso/SitePages/reports-for-msxi.aspx?chromeless=True'\r\n        },\r\n        'serviceFinancials': {\r\n            'tamRolePerformanceDashboard': 'https://msit.powerbi.com/groups/me/reports/c9c3a607-be68-49fe-a89f-c75409c8f0fa/ReportSectionf7f244c90383db8a1c8d',\r\n            'servicesInsightsES': 'https://msit.powerbi.com/groups/56e3ce91-0de0-43bb-a4b3-245db704ea4a/dashboards/283edfd8-d60b-451b-b296-c25b1e09aa'\r\n        },\r\n        'apimSubscriptionKey': '01e62d14a5f04161818c5ef9ee321875',\r\n        'CKPApimSubscriptionKey': '',\r\n        'featureFlighting': {\r\n            'appName': 'Relationship Management Experience',\r\n            'environment': 'dev'\r\n        },\r\n        'oneProfile': 'https://oneprofileuatapipack.azurefd.net/api/v1/profile/searchprofile?searchText=%s',\r\n        'accounts': {\r\n            'numberOfContactsOnSummary': 8\r\n        },\r\n        'offeringsConfig': {\r\n            'voltaComponentCodes': ['AN7', 'AN8', 'ZG6', 'ZG4', 'ZY5', 'ZY6', 'Z1A', 'Z1B', 'Z1C', 'Z1D', 'Z1E', 'Z1F', 'Z1G', 'Z1H', 'Z1I', 'Z1J', 'Z1K', 'Z1L', '0EA', '0EB', '0ED', '0EE', '0ET', '0EU', '0FP', '0FQ'],\r\n            'unifiedComponentCode': 'Y98',\r\n            'pesServiceIds': ['1135', '1136', '1137', '1267', '1284']\r\n        },\r\n        'axisConfig': {\r\n            'requestDetails': 'https://servicesint.azurewebsites.net/#/supportdelivery/requestdetails/%s'\r\n        },\r\n        'casesServiceDeskConfig': {\r\n            'requestDetails': 'https://onesupport.crm.dynamics.com/main.aspx?appid=101acb62-8d00-eb11-a813-000d3a8b3117'\r\n        },\r\n        'casesRaveConfig': {\r\n            'requestDetails': 'https://rave.office.net/cases/%s'\r\n        },\r\n        'cpeConfig': {\r\n            'remediationGuidelinesLink': 'https://sdmplus.azurewebsites.net/sdm/Index#/topics/Remediation%20Guidelines?id=224&ref=sdmplus'\r\n        },\r\n        'msxConfig': {\r\n            'engagementMsxUrlTemplate': 'https://msxuat.crm.dynamics.com/main.aspx?appid=fe0c3504-3700-e911-a849-000d3a10b7cc&pagetype=entityrecord&etn=msp_engagement&id=%s',\r\n            'milestoneMsxUrlTemplate': 'https://msxuat.crm.dynamics.com/main.aspx?appid=fe0c3504-3700-e911-a849-000d3a10b7cc&pagetype=entityrecord&etn=msp_engagementmilestone&id=%s'\r\n        },\r\n        'OneProfileSkillsConfig': {\r\n            'filterConfigDataValue': {\r\n                'orgType': 'CES'\r\n            },\r\n            'skillSearchKeyValue': {\r\n                'tenant': 'RMEX', \r\n                'purpose': 'Request Creation'\r\n            },\r\n            'uiConfigDataValue': {\r\n                'inputSearch': {\r\n                    'width': '500px',\r\n                    'height': '35px',\r\n                    'fontSize': 14\r\n                }\r\n            },\r\n            'isDisabled': false \r\n        },\r\n        'supportDeliveryApimSubscriptionKey': 'd3a845ddf84b487f876d67d7e05ae692',\r\n        'supportDeliveryBaseUrl': 'https://dmsitafd.azurefd.net/api/v1',\r\n        'supportDeliveryApi': {\r\n            'BatchDeliveriesRequest':'/Batch/Deliveries?includeAssignments=%s',\r\n            'GetDeliveriesCounts': '/Landing/Requests/%s/Count',\r\n            'SupportDeliveries': 'https://servicesint.azurewebsites.net/#/supportdelivery/mydeliveries',\r\n            'FilteredSupportDeliveries': 'https://servicesint.azurewebsites.net/#/supportdelivery/mydeliveries?status=%s',\r\n        },\r\n        'cpeProfileLink': 'https://aka.ms/cpeprofile?filter=CALCAccountParenting~2FTPID%20eq%20%27{tpid}%27&chromeless=1'\r\n    }\r\n};\r\n","import { IPartnerAppSettings } from '../interface/IPartnerAppSettings';\r\n\r\nexport const uat: IPartnerAppSettings = {\r\n  cdnBaseUrl: 'https://rmux-nonprod.azureedge.net/servicesuat-ux',\r\n  serviceEndPoints: [\r\n    {\r\n      clientId: 'c1df0735-5f8f-4429-9977-80e732362bdd',\r\n      serviceEndPoint: 'https://professionalservicesint.microsoft.com/rmsvcsit/',\r\n    },\r\n    {\r\n      clientId: '00000003-0000-0000-c000-000000000000',\r\n      serviceEndPoint: 'https://graph.microsoft.com/',\r\n    },\r\n    {\r\n      clientId: '181ef486-9e47-4ad6-9454-7a326432dc00',\r\n      serviceEndPoint: 'https://professionalservicesint.microsoft.com/dmuat/',\r\n    },\r\n    {\r\n        clientId: 'c1df0735-5f8f-4429-9977-80e732362bdd',\r\n        serviceEndPoint: 'https://fd-rmxcsvc-sit-dch6dacwbedegta6.b02.azurefd.net'\r\n    }\r\n  ],\r\n  RmAppConfiguration: {\r\n    'axisConfig': {\r\n      'requestDetails': 'https://servicesuat.microsoft.com/#/supportdelivery/requestdetails/%s'\r\n    },\r\n    'msxConfig': {\r\n      'engagementMsxUrlTemplate': 'https://msxuat.crm.dynamics.com/main.aspx?appid=fe0c3504-3700-e911-a849-000d3a10b7cc&pagetype=entityrecord&etn=msp_engagement&id=%s',\r\n      'milestoneMsxUrlTemplate': 'https://msxuat.crm.dynamics.com/main.aspx?appid=fe0c3504-3700-e911-a849-000d3a10b7cc&pagetype=entityrecord&etn=msp_engagementmilestone&id=%s'\r\n    },\r\n    'supportDeliveryApimSubscriptionKey': 'd3a845ddf84b487f876d67d7e05ae692',\r\n    'supportDeliveryBaseUrl': 'https://professionalservicesint.microsoft.com/dmuat/api/v1',\r\n    'supportDeliveryApi': {\r\n      'BatchDeliveriesRequest': '/Batch/Deliveries?includeAssignments=%s',\r\n      'GetDeliveriesCounts': '/Landing/Requests/%s/Count',\r\n      'SupportDeliveries': 'https://servicesuat.microsoft.com/#/supportdelivery/mydeliveries',\r\n      'FilteredSupportDeliveries': 'https://servicesuat.microsoft.com/#/supportdelivery/mydeliveries?status=%s'\r\n    }\r\n  }\r\n};\r\n","import { IStateConfig, IAppService, IFxpAppContext, IServiceEndPoints, IPartnerBundle, IRouteInfo } from '@fxp/fxpservices';\nimport RmRoutesConstant from './app/common/rm-routes-constant';\nimport { StateParams } from '@uirouter/core';\nimport { appSettings } from './environments/common/appsettingsGenerator';\nimport { PartnerAppRegistrationService } from '@fxp/fxpservices';\n\nexport class RMApp_routes implements IAppService {\r\n\r\n  getRoutes(fxpAppContext: IFxpAppContext): IRouteInfo {\r\n\r\n    const stateCollection: Array<IStateConfig> = [\r\n      {\r\n        name: RmRoutesConstant.DmmRouteName,\r\n        url: RmRoutesConstant.DmmRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Relationship Management',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'ManagementView',\r\n          featureName: 'Management.ActionView', // Default landing page in Management\r\n          actionName: 'View',\r\n          breadcrumbText: 'CSAM Manager',\r\n          pageTitle: 'CSAM Manager',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.DmmPorfolioRouteName,\r\n        url: RmRoutesConstant.DmmPortfolioRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Relationship Management',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'ManagementPortfolio',\r\n          featureName: 'Management.Portfolio',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Portfolio',\r\n          pageTitle: 'Portfolio',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.DmmUtilization,\r\n        url: RmRoutesConstant.DmmUtilizationRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Utilization',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'ManagementUtilization',\r\n          featureName: 'Management.Utilization',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Utilization',\r\n          pageTitle: 'Utilization',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.DmmActionView,\r\n        url: RmRoutesConstant.DmmActionViewRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'ActionView',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'ManagementActionView',\r\n          featureName: 'Management.ActionView',\r\n          actionName: 'View',\r\n          breadcrumbText: 'ActionView',\r\n          pageTitle: 'ActionView',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.DmmSdpReview,\r\n        url: RmRoutesConstant.DmmSdpReviewRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Review',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'ManagementSDPReview',\r\n          featureName: 'Management.SDPReview',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Customer Review',\r\n          pageTitle: 'Customer Review',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.DmmCpeSurvey,\r\n        url: RmRoutesConstant.DmmCpeSurveyRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'CPE Survey',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'ManagementCPESurveys',\r\n          featureName: 'Management.CPESurveys',\r\n          actionName: 'View',\r\n          breadcrumbText: 'CPE Survey',\r\n          pageTitle: 'CPE Survey',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.DmmCpeSurveyDetails,\r\n        url: RmRoutesConstant.DmmCpeSurveyDetailsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'CPE Details',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'ManagementCPESurveyDetails',\r\n          featureName: 'Management.CPESurveyDetails',\r\n          actionName: 'View',\r\n          breadcrumbText: 'CPE Details',\r\n          pageTitle: 'CPE Details',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ surveyId: { dynamic: true }, packageId: { dynamic: true }, regionType: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.DmmSoftwareAssurance,\r\n        url: RmRoutesConstant.DmmSoftwareRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Software Assurance Benefits',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'ManagementSoftwareAssuranceBenefits',\r\n          featureName: 'Management.SoftwareAssuranceBenefits',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Software Assurance Benefits',\r\n          pageTitle: 'Software Assurance Benefits',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n      },\r\n      {\r\n        name: RmRoutesConstant.DmmCkp,\r\n        url: RmRoutesConstant.DmmCkpRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Cloud Support Plan Management',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'ManagementCSPM',\r\n          featureName: 'Management.CSPM',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Cloud Support Plan Management',\r\n          pageTitle: 'Cloud Support Plan Management',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n      },\r\n      {\r\n        name: RmRoutesConstant.RmDeliveryRouteName,\r\n        url: RmRoutesConstant.RmDeliveryRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Relationship Management',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'MyCustomers',\r\n          featureName: 'Customers',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Customers',\r\n          pageTitle: 'Customers',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.RmRouteName,\r\n        url: RmRoutesConstant.RmRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Relationship Management',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomersPortfolio', // loads under dashboard accounts\r\n          featureName: 'Customers.MyPortfolio',\r\n          actionName: 'View',\r\n          breadcrumbText: 'My Portfolio',\r\n          pageTitle: 'My Portfolio',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.RmDashboardRouteName,\r\n        url: RmRoutesConstant.RmDashboardRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Relationship Management Dashboard',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RelationshipManagementDashboard',\r\n          featureName: 'RMDashboard.DashboardSummary',  // landing page\r\n          actionName: 'View',\r\n          breadcrumbText: 'Dashboard',\r\n          pageTitle: 'Dashboard',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.RmDashboardSummary,\r\n        url: RmRoutesConstant.RmDashboardSummaryRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'RM Dashboard Summary',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RelationshipManagementDashboardSummary',\r\n          featureName: 'RMDashboard.DashboardSummary',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Summary',\r\n          pageTitle: 'RM Dashboard Summary',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.UnAuthorized,\r\n        url: RmRoutesConstant.UnAuthorizedRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Unauthorized',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'Unauthorized',\r\n          featureName: 'RMDashboard.CustomerUnauthorized',\r\n          actionName: 'Unauthorized',\r\n          breadcrumbText: 'Unauthorized',\r\n          pageTitle: 'Customer Unauthorized',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpName: { dynamic: true }, ownersList: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.RmDashboardAgreements,\r\n        url: RmRoutesConstant.RmDashboardAgreementsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'RM Dashboard Agreement',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RMDashboardAgreements',\r\n          featureName: 'RMDashboard.Agreements',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Agreement',\r\n          pageTitle: 'RM Dashboard Agreement',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n      },\r\n      {\r\n        name: RmRoutesConstant.RmDashboardSoftwareAssurance,\r\n        url: RmRoutesConstant.RmDashboardSoftwareRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Software Assurance Benefits',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RMDashboardSoftwareAssuranceBenefits',\r\n          featureName: 'RMDashboard.SoftwareAssuranceBenefits',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Software Assurance Benefits',\r\n          pageTitle: 'Software Assurance Benefits',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n      },\r\n      {\r\n        name: RmRoutesConstant.RmDashboardPrograms,\r\n        url: RmRoutesConstant.RmDashboardProgramsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'RM Dashboard Support Projects',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RMDashboardPrograms',\r\n          featureName: 'RMDashboard.Programs',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Support Projects',\r\n          pageTitle: 'RM Dashboard Support Projects',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.RmDashboardDeliveries,\r\n        url: RmRoutesConstant.RmDashboardDeliveriesRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'RM Dashboard Deliveries',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RMDashboardDeliveries',\r\n          featureName: 'RMDashboard.Deliveries',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Deliveries',\r\n          pageTitle: 'RM Dashboard Deliveries',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.RmDashboardCases,\r\n        url: RmRoutesConstant.RmDashboardCasesRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'RM Dashboard Cases',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RMDashboardCases',\r\n          featureName: 'RMDashboard.Cases',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Cases',\r\n          pageTitle: 'RM Dashboard Cases',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.RmDashboardUtilizationView,\r\n        url: RmRoutesConstant.RmDashboardUtilizationViewUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'RM Dashboard Utilization',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RMDashboardUtilization',\r\n          featureName: 'RMDashboard.Utilization',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Utilization',\r\n          pageTitle: 'RM Dashboard Utilization',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.RmDashboardAccounts,\r\n        url: RmRoutesConstant.RmDashboardAccountsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'RM Dashboard Accounts',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RMDashboardAccounts',\r\n          featureName: 'RMDashboard.Accounts',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Accounts',\r\n          pageTitle: 'RM Dashboard Accounts',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.CloudKnowsPremier,\r\n        url: RmRoutesConstant.CloudKnowsPremierUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Cloud Support Plan Management',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RMDashboardCSPM',\r\n          featureName: 'RMDashboard.CSPM',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Cloud Support Plan Management',\r\n          pageTitle: 'Cloud Support Plan Management',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.CloudKnowsPremierSearch,\r\n        url: RmRoutesConstant.CloudKnowsPremierSearchUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Cloud Support Plan Management',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RMDashboardCSPM',\r\n          featureName: 'RMDashboard.SearchAndMatch',\r\n          actionName: 'SearchAndMatch',\r\n          breadcrumbText: 'Cloud Support Plan Management Search',\r\n          pageTitle: 'Cloud Support Plan Management',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ gridName: { dynamic: true }, tpid: { dynamic: true }, grid: { dynamic: true}, filter: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.AccountRouteName,\r\n        url: RmRoutesConstant.AccountRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Relationship Management',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'MyPortfolio', // not able to locate in UI\r\n          featureName: 'MyPortfolio',\r\n          actionName: 'MyPortfolio',\r\n          breadcrumbText: 'My Portfolio',\r\n          pageTitle: 'My Portfolio',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.ProgramManagement,\r\n        url: RmRoutesConstant.ProgramManagementRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Support Project Management',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerProgramManagement', // not able to locate in UI\r\n          featureName: 'Program',\r\n          subFeatureName: 'ProgramManagement',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Customers',\r\n          pageTitle: 'Customers',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.PortfolioSummary,\r\n        url: RmRoutesConstant.PortfolioSummaryRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Portfolio Summary',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'PortfolioSummary', // not able to locate in UI\r\n          featureName: 'Summary',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Summary',\r\n          pageTitle: 'Portfolio Summary',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.PortfolioAccounts,\r\n        url: RmRoutesConstant.PortfolioAccountsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Accounts',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'PortfolioAccounts', // not able to locate in UI\r\n          featureName: 'Accounts',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Accounts',\r\n          pageTitle: 'Accounts',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.PortfolioPrograms,\r\n        url: RmRoutesConstant.PortfolioProgramsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Support Projects',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'PortfolioPrograms', // not able to locate in UI\r\n          featureName: 'Programs',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Support Projects',\r\n          pageTitle: 'Support Projects',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.PortfolioDeliveries,\r\n        url: RmRoutesConstant.PortfolioDeliveriesRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Deliveries',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'PortfolioDeliveries', // not able to locate in UI\r\n          featureName: 'Deliveries',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Deliveries',\r\n          pageTitle: 'Deliveries',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.UnassignedPackages,\r\n        url: RmRoutesConstant.UnassignedPackagesRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Unassigned Packages',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'UnassignedPackages',\r\n          featureName: 'UnassignedPackages',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Unassigned Packages',\r\n          pageTitle: 'Unassigned Packages',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.UnlinkedRequests,\r\n        url: RmRoutesConstant.UnlinkedRequestsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Unlinked Requests',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'UnlinkedRequests',\r\n          featureName: 'UnlinkedRequests',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Unlinked Requests',\r\n          pageTitle: 'Unlinked Requests',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.PortfolioCases,\r\n        url: RmRoutesConstant.PortfolioCasesRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Cases',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'PortfolioCases', // not able to locate in UI\r\n          featureName: 'Cases',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Cases',\r\n          pageTitle: 'Cases',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.PortfolioAgreements,\r\n        url: RmRoutesConstant.PortfolioAgreementsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Agreements',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'PortfolioAgreements', // not able to locate in UI\r\n          featureName: 'Agreements',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Agreements',\r\n          pageTitle: 'Agreements',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.PortfolioUtilizationView,\r\n        url: RmRoutesConstant.PortfolioUtilizationViewUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Utilization',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'PortfolioUtilization', // not able to locate in UI\r\n          featureName: 'Utilization',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Utilization',\r\n          pageTitle: 'Utilization',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.CKPView,\r\n        url: RmRoutesConstant.CKPViewUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Cloud Support Plan Management',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'ProgramManagementCSPM', // not able to locate in UI\r\n          featureName: 'ProgramManagement.CSPM ',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Cloud Support Plan Management',\r\n          pageTitle: 'Cloud Support Plan Management',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.CSATView,\r\n        url: RmRoutesConstant.CSATViewUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'CPE',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'RMDashboardCPE',\r\n          featureName: 'RMDashboard.CPE',\r\n          actionName: 'View',\r\n          breadcrumbText: 'CPE',\r\n          pageTitle: 'CPE',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true\r\n      },\r\n      {\r\n        name: RmRoutesConstant.ServiceDeliveryPlan,\r\n        url: RmRoutesConstant.ServiceDeliveryPlanRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Name',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerDetail', // not able to view in UI\r\n          featureName: 'Customers.CustomerDetail',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Customer Name',\r\n          pageTitle: 'Customer Name',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpSummary,\r\n        url: RmRoutesConstant.SdpSummaryRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Summary',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerSummary',\r\n          featureName: 'Customers.Customer.Summary',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Summary',\r\n          pageTitle: 'Customer Summary',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpPrograms,\r\n        url: RmRoutesConstant.SdpProgramsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Support Projects',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerPrograms',\r\n          featureName: 'Customers.Customer.Programs',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Support Projects',\r\n          pageTitle: 'Customer Support Projects',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, isNewSupportProjectExperience: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpDeliveries,\r\n        url: RmRoutesConstant.SdpDeliveriesRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Deliveries',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerDeliveries',\r\n          featureName: 'Customers.Customer.Deliveries',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Deliveries',\r\n          pageTitle: 'Customer Deliveries',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpContacts,\r\n        url: RmRoutesConstant.SdpContactsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Microsoft Contacts',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerMsftContacts',\r\n          featureName: 'Customers.Customer.MsftContacts',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Contacts',\r\n          pageTitle: 'Microsoft Contacts',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpConsumption,\r\n        url: RmRoutesConstant.PackageConsumptionRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Consumption',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerPacakgeConsumption',\r\n          featureName: 'Customers.Packages.Consumption',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Consumption',\r\n          pageTitle: 'Customer Consumption',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpAccessId,\r\n        url: RmRoutesConstant.SdpAccessIdRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Access ID',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerAccessID', // not able to locate in UI\r\n          featureName: 'AccessID',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Access ID',\r\n          pageTitle: 'Customer Access ID',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpCreateDelivery,\r\n        url: RmRoutesConstant.SdpCreateDeliveryRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Create Delivery',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerDeliveries',\r\n          featureName: 'Customers.Customer.Deliveries', // not able to locate in UI\r\n          actionName: 'Create',\r\n          breadcrumbText: 'Create Delivery',\r\n          pageTitle: 'Create Delivery',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, isProspectiveCustomer: { dynamic: true} })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpViewProgram,\r\n        url: RmRoutesConstant.SdpViewProgramRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'View Support Project',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerProgramDetail',\r\n          featureName: 'Customers.Customer.ProgramDetail',\r\n          actionName: 'View',\r\n          breadcrumbText: 'View Support Project',\r\n          pageTitle: 'View Support Project',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, programId: { dynamic: true }, isProspectiveCustomer: { dynamic: true} })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpEditProgram,\r\n        url: RmRoutesConstant.SdpEditProgramRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Edit Support Project',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerPrograms',\r\n          featureName: 'Customers.Customer.Programs',\r\n          actionName: 'Edit',\r\n          breadcrumbText: 'Edit Support Project',\r\n          pageTitle: 'Edit Support Project',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, programId: { dynamic: true }, isProspectiveCustomer: { dynamic: true} })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpViewDelivery,\r\n        url: RmRoutesConstant.SdpViewDeliveryRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'View Delivery',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerDeliveries',\r\n          featureName: 'Customers.Customer.Deliveries',\r\n          actionName: 'View',\r\n          breadcrumbText: 'View Delivery',\r\n          pageTitle: 'View Delivery',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, serviceId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpEditDelivery,\r\n        url: RmRoutesConstant.SdpEditDeliveryRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Edit Delivery',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerDeliveries', // loading under deliveries view url\r\n          featureName: 'Deliveries',\r\n          actionName: 'Edit',\r\n          breadcrumbText: 'Edit Delivery',\r\n          pageTitle: 'Edit Delivery',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, serviceId: { dynamic: true } })\r\n      },\r\n     \r\n      {\r\n        name: RmRoutesConstant.SdpOutcomes,\r\n        url: RmRoutesConstant.SdpOutcomesRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Outcomes',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerPrograms',\r\n          featureName: 'Customers.Customer.Programs',\r\n          subFeatureName: 'Outcomes',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Outcomes',\r\n          pageTitle: 'Customer Outcomes',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpCases,\r\n        url: RmRoutesConstant.PackageCasesRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Cases',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerPackageCases',\r\n          featureName: 'Customers.Packages.Cases',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Cases',\r\n          pageTitle: 'Customer Cases',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpAgreements,\r\n        url: RmRoutesConstant.SdpAgreementsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Agreement',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerAgreements',\r\n          featureName: 'Customers.Packages.Agreements',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Agreement',\r\n          pageTitle: 'Customer Agreement',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SuccessEngagement,\r\n        url: RmRoutesConstant.SuccessEngagementUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Success Engagements',\r\n          breadcrumbText: 'Success Engagements',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'Success Engagements',\r\n          featureName: 'SuccessEngagements',\r\n          actionName: 'View',\r\n          pageTitle: 'Customer Success Engagements',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpLeads,\r\n        url: RmRoutesConstant.SdpLeadsRouteUrl,\r\n        // url: '/mydeliveries/sdps/:sdpId/leads',\r\n\n        // component: LeadsGridContainerComponent,\r\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Support Needs',\r\n          breadcrumbText: 'Support Needs',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerSupportNeeds',\r\n          featureName: 'Customers.Customer.SupportNeeds',\r\n          actionName: 'View',\r\n          pageTitle: 'Customer Support Needs',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpEditLead,\r\n        url: RmRoutesConstant.SdpEditLeadRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Support Needs',\r\n          breadcrumbText: 'Support Needs',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerSupportNeeds',\r\n          featureName: 'Customers.Customer.SupportNeeds',\r\n          actionName: 'Edit',\r\n          pageTitle: 'Customer Support Needs',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, leadId: { dynamic: true }, lead: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpCreateLead,\r\n        url: RmRoutesConstant.SdpCreateLeadRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Support Needs',\r\n          breadcrumbText: 'Support Needs',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerSupportNeed',\r\n          featureName: 'Customers.Customer.SupportNeeds',\r\n          actionName: 'Create',\r\n          pageTitle: 'Customer Support Needs',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SDPPackageSummary,\r\n        url: RmRoutesConstant.PackageSummaryRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Package',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerPackageOverview',\r\n          featureName: 'Customers.Packages.Overview',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Overview',\r\n          pageTitle: 'Customer Package',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpPackageCustomerContacts,\r\n        url: RmRoutesConstant.PackageCustomerContactsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Package Contacts',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerPackageCustomerContacts',\r\n          featureName: 'Customers.Packages.CustomerContacts',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Contacts',\r\n          pageTitle: 'Customer Package Contacts',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpPackageContacts,\r\n        url: RmRoutesConstant.PackageContactsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Package Contacts',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerandMsftContacts',\r\n          featureName: 'Customers.Customer.MsftContacts',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Contacts',\r\n          pageTitle: 'Package Contacts',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpPackageService,\r\n        url: RmRoutesConstant.PackageServiceRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Package Service',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerPackageServices',\r\n          featureName: 'Customers.Packages.Services',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Service',\r\n          pageTitle: 'Customer Package Service',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.SdpPackageMailingList,\r\n        url: RmRoutesConstant.PackageMailingListRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Package Mailing List',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CustomerPackageMailingList',\r\n          featureName: 'Customers.Packages.MailingList',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Mailing List',\r\n          pageTitle: 'Customer Package Mailing List',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ sdpId: { dynamic: true }, combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.UnassignedPackageSummary,\r\n        url: RmRoutesConstant.PackageSummaryRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Package',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'UnassignedPackagesOverview',\r\n          featureName: 'UnassignedPackages.Overview',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Overview',\r\n          pageTitle: 'Package Summary',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.UnassignedPackageContacts,\r\n        url: RmRoutesConstant.PackageContactsRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Package Contacts',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'UnassignedPackagesContacts',\r\n          featureName: 'UnassignedPackages.Contacts',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Contacts',\r\n          pageTitle: 'Package Contacts',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.UnassignedPackageService,\r\n        url: RmRoutesConstant.PackageServiceRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Package Service',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'UnassignedPackagesServices',\r\n          featureName: 'UnassignedPackages.Services',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Service',\r\n          pageTitle: 'Package Service',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.UnassignedPackageCases,\r\n        url: RmRoutesConstant.PackageCasesRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Cases',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'UnassignedPackagesCases',\r\n          featureName: 'UnassignedPackages.Cases',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Cases',\r\n          pageTitle: 'Cases',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.UnassignedPackageConsumption,\r\n        url: RmRoutesConstant.PackageConsumptionRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Consumption',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'UnassignedPackagesConsumption',\r\n          featureName: 'UnassignedPackages.Consumption',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Consumption',\r\n          pageTitle: 'Consumption',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ combinedPackageId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.QueryRouteName,\r\n        url: RmRoutesConstant.QueryRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Query',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'CSAM/AgreementSearchQuery',\r\n          featureName: 'Customers.Search',\r\n          actionName: 'Query',\r\n          breadcrumbText: 'Query',\r\n          pageTitle: 'Query',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ queryName: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.ManageQueriesRouteName,\r\n        url: RmRoutesConstant.ManageQueriesRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Manage Queries',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'ManageSearchQuery',\r\n          featureName: 'Customers.Search.ManageQueries',\r\n          actionName: 'Manage',\r\n          breadcrumbText: 'Manage Queries',\r\n          pageTitle: 'Manage Queries',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ tab: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.AgreementCase,\r\n        url: RmRoutesConstant.AgreementCaseRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Agreement Case',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'AgreementCases',\r\n          featureName: 'Agreement.Cases',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Cases',\r\n          pageTitle: 'Agreement Case',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ combinedAgreementId: { dynamic: true } })\r\n      },\r\n      {\r\n        name: RmRoutesConstant.AgreementConsumption,\r\n        url: RmRoutesConstant.AgreementConsumptionRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Consumption ',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'AgreementConsumption',\r\n          featureName: 'Agreement.Consumption',\r\n          actionName: 'View',\r\n          breadcrumbText: 'Consumption',\r\n          pageTitle: 'Consumption',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ combinedAgreementId: { dynamic: true } })\r\n      },\r\n    \r\n      {\r\n        name: RmRoutesConstant.RmSearchReportsUnauthorizedRoute,\r\n        url: RmRoutesConstant.RmSearchReportsUnauthorizedRouteUrl,\r\n\ngeneratedBundle: '0570f6fd3d7f-RMAppModule-Bundle',\n        data: {\r\n          headerName: 'Customer Unauthorised for Report',\r\n          partnerTelemetryName: 'RM',\r\n          appNameForTelemetry: RmRoutesConstant.RelationshipManagement,\r\n          pageNameForTelemetry: 'UnauthorisedView',\r\n          featureName: 'CustomerUnauthorisedforReport',\r\n          actionName: 'Unauthorised',\r\n          breadcrumbText: 'Unauthorised for Report',\r\n          pageTitle: 'Customer Unauthorised for Report',\r\n          style: 'icon icon-people'\r\n        },\r\n        includeRootModule: true,\r\n        params: new StateParams({ OwnerCoOwnerList: { dynamic: true }, sdpName: { dynamic: true } })\r\n      },\r\n    ];\r\n    const routeInfo: IRouteInfo = {\r\n      applicationName: 'RM',\r\n      sharedBundles: [],\r\n      routes: stateCollection\r\n    };\r\n\r\n    return routeInfo;\r\n  }\r\n\r\n  getServiceEndPoints(): Array<IServiceEndPoints> {\r\n    return appSettings().serviceEndPoints;\r\n  }\r\n\r\n  public getBundles(): IPartnerBundle[] {\r\n    const baseUrl = appSettings().cdnBaseUrl;\r\n    let bundlesData = [\r\n      {\r\n        name: 'RM-Bundle',\r\n        files: [\r\n          `${baseUrl}/vendor.bundle.js`,\r\n          `${baseUrl}/styles.bundle.js`,\r\n          `${baseUrl}/main.bundle.js`\r\n        ],\r\n        sequentialLoading: true\r\n      }\r\n    ];\r\n    return bundlesData;\r\n  }\r\n\n public getGeneratedBundles(){\n let currentScriptUrl = document.currentScript['src']; \nlet baseUrl = currentScriptUrl.substring(0, currentScriptUrl.lastIndexOf('/')); \n return [\n{\n                name: '0570f6fd3d7f-RMAppModule-Bundle',\n                files: [\n                    baseUrl + '/styles.bundle.js',\n                    baseUrl + '/RMAppModule.vendor.bundle.js',\n                    baseUrl + '/RMAppModule.bundle.js'\n                ],\n                sequentialLoading: true           \n            },\n\n]\n \n}\n}\n\nPartnerAppRegistrationService.registerLazyLoadedApp(RMApp_routes, 'RM');\n"],"sourceRoot":"webpack:///rm-exp-v-next"}