@coolon/angular-ui-powerups 0.0.101 → 0.0.103

package/esm2015/lib/place/guards/place-component-deactivation-handler.js

@@ -3,60 +3,93 @@
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 import * as tslib_1 from "tslib";
+import * as _ from 'lodash';
 export class PlaceComponentDeactivationHandler {
     /**
      * @param {?} component
-     * @param {?} navigationSession
+     * @param {?} navigationState
+     * @param {?} isPrimaryComponent
      */
-    constructor(component, navigationSession) {
+    constructor(component, navigationState, isPrimaryComponent) {
         this.component = component;
-        this.navigationSession = navigationSession;
+        this.navigationState = navigationState;
+        this.isPrimaryComponent = isPrimaryComponent;
     }
     /**
+     * @return {?}
+     */
+    get interactionService() {
+        return this.navigationState.interactionService;
+    }
+    /**
+     * @return {?}
+     */
+    get placeRouter() {
+        return this.navigationState.placeRouter;
+    }
+    /**
+     * @param {?} currentUrl
      * @param {?} nextState
      * @return {?}
      */
-    canDeactivate(nextState) {
+    canDeactivate(currentUrl, nextState) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             // We'll get called multiple times if there's any parameter sanitisation so
             // we always return true if we accepted promise from a previous cycle of the current
             // navigation session.
             if (!this.canDeactivatePromise) {
-                this.canDeactivatePromise = this.canDeactivateComponent(nextState);
+                console.log(`creating deactivate promise for -> ${this.component.constructor.name}`);
+                this.canDeactivatePromise = this.canDeactivateComponent(currentUrl, nextState);
             }
             return this.canDeactivatePromise;
         });
     }
+    // @Trace()
     /**
      * @protected
+     * @param {?} currentUrl
      * @param {?} nextState
      * @return {?}
      */
-    canDeactivateComponent(nextState) {
+    canDeactivateComponent(currentUrl, nextState) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            console.log(this.navigationState.toString());
             // Automatically cancel any active activities if the navigation session was triggered by the back button.
-            // any other navigations (such as the user clicking a differnt place) must be handled by the component itself
-            // during the canDeativate method.  If we handled more than just the pop state then it leads to the UI ignoring
-            // clicks and just cancelling things which is deeply disconcerting.
-            if (this.navigationSession.isPopState && this.component.interactionContext && this.component.interactionContext.isActive()) {
-                // Note: Modal interactions are run in a different router outlet so we never get place deactivating while
-                // a model interaction is active. This is because:
-                // 1. the user can't click anything to navigate away
-                // 2. clicking the back button will only change the outlet route portion of the URL. This
-                //    is all handled by the InteractionGuard and so the component guards will never run.
-                //
-                // Now we just cancel the current activity...
-                /** @type {?} */
-                const activity = yield this.component.interactionContext.getCurrentActivity();
-                activity.cancel(null);
-                return false; // ..and stay where we are.
+            // If we handled more than just the pop state then it leads to the UI ignoring clicks and just cancelling things which is deeply disconcerting.
+            if (this.navigationState.isPopState) {
+                if (this.isPrimaryComponent && this.interactionService.isModalActive()) {
+                    /** @type {?} */
+                    const routeIds = this.placeRouter.getActiveInteractionIdsFromUrl(nextState.url);
+                    /** @type {?} */
+                    const currentIds = this.interactionService.activeInteractionContextIds.value;
+                    if (!_.isEqual(currentIds, routeIds)) {
+                        yield this.interactionService.getActiveContext().cancelCurrentActivity();
+                        return currentUrl.updateInteractionIds(this.interactionService.activeInteractionContextIds.value);
+                    }
+                }
+                else {
+                    // check if the component has an in place interaction
+                    if (this.component.interactionContext && this.component.interactionContext.isActive()) {
+                        yield this.component.interactionContext.cancelCurrentActivity();
+                        return currentUrl
+                            .updateInteractionIds(this.interactionService.activeInteractionContextIds.value);
+                    }
+                }
             }
             // Ok, so now we're really leaving, so we ask the component if we should.;
-            if (this.isNotJustAChangeInRouteId(nextState) && this.component.canDeactivate) {
-                // No interaction in progress, so ask the component .
-                // This may start an interaction, hence checking the interaction context before now. I.e. if the place pops up the dialog, and
-                // the user clicks back again, we'll re-enter here and go bang when the component tries to open another dialog.
-                return this.component.canDeactivate(this.navigationSession.interactionContext);
+            if (this.isNotJustAChangeInRouteId(nextState)) {
+                if (this.component.canDeactivate) {
+                    // No interaction in progress, so ask the component .
+                    // This may start an interaction, hence checking the interaction context before now. I.e. if the place pops up the dialog, and
+                    // the user clicks back again, we'll re-enter here and go bang when the component tries to open another dialog.
+                    return this.component.canDeactivate(this.navigationState.interactionContext);
+                }
+                // The component has an active interaction but no deactivation hook.  Rather than guessing what to do
+                // we'll just cancel the navigation and print a warning.
+                if (this.component.interactionContext && this.component.interactionContext.isActive()) {
+                    console.warn('Route changed while component has active interaction, cancelling navigation');
+                    return false;
+                }
             }
             return true;
         });
@@ -82,6 +115,8 @@ if (false) {
     /** @type {?} */
     PlaceComponentDeactivationHandler.prototype.component;
     /** @type {?} */
-    PlaceComponentDeactivationHandler.prototype.navigationSession;
+    PlaceComponentDeactivationHandler.prototype.navigationState;
+    /** @type {?} */
+    PlaceComponentDeactivationHandler.prototype.isPrimaryComponent;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"place-component-deactivation-handler.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/guards/place-component-deactivation-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { Trace } from '@coolon/pectin';\nimport * as _ from 'lodash';\nimport { PlaceComponent } from '../place-component';\nimport { UrlSnapshot } from '../url-snapshot';\nimport { NavigationState } from './navigation-state';\n\nexport class PlaceComponentDeactivationHandler {\n\n  private canDeactivatePromise: Promise<boolean | UrlSnapshot>;\n\n  constructor(readonly component: PlaceComponent, readonly navigationState: NavigationState, readonly isPrimaryComponent: boolean) {\n  }\n\n  get interactionService() {\n    return this.navigationState.interactionService;\n  }\n\n  get placeRouter() {\n    return this.navigationState.placeRouter;\n  }\n\n  async canDeactivate(currentUrl: UrlSnapshot, nextState: UrlSnapshot): Promise<boolean | UrlSnapshot> {\n    // We'll get called multiple times if there's any parameter sanitisation so\n    // we always return true if we accepted promise from a previous cycle of the current\n    // navigation session.\n    if (!this.canDeactivatePromise) {\n      console.log(`creating deactivate promise for -> ${this.component.constructor.name}`);\n      this.canDeactivatePromise = this.canDeactivateComponent(currentUrl, nextState);\n    }\n    return this.canDeactivatePromise;\n  }\n\n\n  // @Trace()\n  protected async canDeactivateComponent(currentUrl: UrlSnapshot, nextState: UrlSnapshot): Promise<UrlSnapshot | boolean> {\n    console.log(this.navigationState.toString());\n    // Automatically cancel any active activities if the navigation session was triggered by the back button.\n    // If we handled more than just the pop state then it leads to the UI ignoring clicks and just cancelling things which is deeply disconcerting.\n    if (this.navigationState.isPopState) {\n      if (this.isPrimaryComponent && this.interactionService.isModalActive()) {\n        const routeIds = this.placeRouter.getActiveInteractionIdsFromUrl(nextState.url);\n        const currentIds = this.interactionService.activeInteractionContextIds.value;\n\n        if (!_.isEqual(currentIds, routeIds)) {\n          await this.interactionService.getActiveContext().cancelCurrentActivity();\n          return currentUrl.updateInteractionIds(this.interactionService.activeInteractionContextIds.value);\n        }\n      } else {\n        // check if the component has an in place interaction\n        if (this.component.interactionContext && this.component.interactionContext.isActive()) {\n          await this.component.interactionContext.cancelCurrentActivity();\n          return currentUrl\n            .updateInteractionIds(this.interactionService.activeInteractionContextIds.value)\n        }\n      }\n    }\n\n    // Ok, so now we're really leaving, so we ask the component if we should.;\n    if (this.isNotJustAChangeInRouteId(nextState)) {\n\n      if (this.component.canDeactivate) {\n        // No interaction in progress, so ask the component .\n        // This may start an interaction, hence checking the interaction context before now. I.e. if the place pops up the dialog, and\n        // the user clicks back again, we'll re-enter here and go bang when the component tries to open another dialog.\n        return this.component.canDeactivate(this.navigationState.interactionContext);\n      }\n\n      // The component has an active interaction but no deactivation hook.  Rather than guessing what to do\n      // we'll just cancel the navigation and print a warning.\n      if (this.component.interactionContext && this.component.interactionContext.isActive()) {\n        console.warn('Route changed while component has active interaction, cancelling navigation');\n        return false;\n      }\n\n    }\n    return true;\n  }\n\n  protected isNotJustAChangeInRouteId(nextState: UrlSnapshot) {\n    // Because places with a route-id cover two route segments we get asked to deactivate\n    // if the route id is added or removed.  So if our path is still present the url\n    // then we shouldn't deactivate the place.\n    return !nextState.includesPathOf(this.component.placeDefinition);\n  }\n}\n"]}

package/esm2015/lib/place/guards/place.guard.js

@@ -0,0 +1,215 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { lang } from '@coolon/pectin';
+import { Observable } from 'rxjs';
+import { PlaceComponent } from '../place-component';
+import { VisitSanitiser } from '../route/visit-sanitiser';
+import { UrlSnapshot } from '../url-snapshot';
+import { Visit } from '../visit';
+import { ConsolidatedParameterMap } from './consolidated-param-map';
+/**
+ * @abstract
+ */
+export class PlaceGuard {
+    /**
+     * @param {?} router
+     * @param {?} urlSerializer
+     * @param {?} placeRouter
+     * @param {?} placeHistory
+     * @param {?} interactionService
+     * @param {?} injector
+     */
+    constructor(router, urlSerializer, placeRouter, placeHistory, interactionService, injector) {
+        this.router = router;
+        this.urlSerializer = urlSerializer;
+        this.placeRouter = placeRouter;
+        this.placeHistory = placeHistory;
+        this.interactionService = interactionService;
+        this.injector = injector;
+    }
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    canActivate(activatedRoute, state) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // TODO: this is ugly now that I'm return UrlSnapshots and not UrlTrees.  It'd be better if the functions
+            //        weren't nested or if I implemented a handler chain.
+            return this.authorisePlaceThen(activatedRoute, state, (/**
+             * @param {?} placeDefinition
+             * @return {?}
+             */
+            (placeDefinition) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                /** @type {?} */
+                const result = yield this.cleanInteractionState(activatedRoute, state, (/**
+                 * @return {?}
+                 */
+                () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    // Parse our route params.
+                    /** @type {?} */
+                    const params = new ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);
+                    /** @type {?} */
+                    const parsedParams = placeDefinition.parseRouteParams(params);
+                    /** @type {?} */
+                    const initialVisit = this.placeRouter.navigationState.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);
+                    /** @type {?} */
+                    const sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);
+                    /** @type {?} */
+                    const sanitisedVisit = yield sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams));
+                    // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters
+                    this.placeRouter.navigationState.storeVisit(sanitisedVisit);
+                    if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {
+                        // Regenerate the url
+                        /** @type {?} */
+                        const urlSnapshot = this.placeRouter.parseUrl(state.url).updateVisitSegments(sanitisedVisit);
+                        console.log('##### Place Guard Redirect', urlSnapshot);
+                        return urlSnapshot;
+                    }
+                    else {
+                        return true;
+                    }
+                })));
+                return this.handleGuardResult(result);
+            })));
+        });
+    }
+    // @Trace()
+    /**
+     * @param {?} component
+     * @param {?} currentRoute
+     * @param {?} currentState
+     * @param {?=} nextState
+     * @return {?}
+     */
+    canDeactivate(component, currentRoute, currentState, nextState) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            /** @type {?} */
+            const currentUrl = this.placeRouter.parseUrl(currentState.url);
+            /** @type {?} */
+            const nextUrl = this.placeRouter.parseUrl(nextState.url);
+            /** @type {?} */
+            const result = yield this.placeRouter.navigationState.canDeactivatePlace(component, currentUrl, nextUrl);
+            return this.handleGuardResult(result);
+        });
+    }
+    /**
+     * @private
+     * @param {?} result
+     * @return {?}
+     */
+    handleGuardResult(result) {
+        if (result instanceof UrlSnapshot) {
+            return result.urlTree;
+        }
+        else {
+            return result;
+        }
+    }
+    // @Trace()
+    /**
+     * @protected
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @param {?} runPlaceGuards
+     * @return {?}
+     */
+    authorisePlaceThen(activatedRoute, state, runPlaceGuards) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) {
+                /** @type {?} */
+                const placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);
+                /** @type {?} */
+                const authoriseResult = placeDefinition.authenticate ? yield this.isAuthorised(activatedRoute, state) : true;
+                if (authoriseResult === true) {
+                    // we're authorised, now run the place guards.
+                    return runPlaceGuards(placeDefinition);
+                }
+                else {
+                    console.log('not authorised result', authoriseResult);
+                    return authoriseResult;
+                }
+            }
+            else {
+                return lang.illegalState(`expected component to be an instance of PlaceComponent, got ${activatedRoute.component}`);
+            }
+        });
+    }
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    isAuthorised(activatedRoute, state) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            /** @type {?} */
+            const authorised = this.getAuthGuard(this.injector).canActivate(activatedRoute, state);
+            return (authorised instanceof Observable) ? authorised.toPromise() : authorised;
+        });
+    }
+    // @Trace()
+    /**
+     * @param {?} route
+     * @param {?} state
+     * @param {?} then
+     * @return {?}
+     */
+    cleanInteractionState(route, state, then) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            /** @type {?} */
+            const url = this.placeRouter.parseUrl(state.url);
+            if (!this.interactionService.isActive() && url.hasInteractionIds()) {
+                // This happens if we reload the page or the url was pasted as the route should only be activated
+                // after the interaction context has become active.
+                return url.removeInteractionIds();
+            }
+            else {
+                return then();
+            }
+        });
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.urlSerializer;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.placeRouter;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.placeHistory;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.interactionService;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceGuard.prototype.injector;
+    /**
+     * @abstract
+     * @param {?} injector
+     * @return {?}
+     */
+    PlaceGuard.prototype.getAuthGuard = function (injector) { };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"place.guard.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/guards/place.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector } from '@angular/core';\nimport {\n  ActivatedRouteSnapshot,\n  CanActivate,\n  CanDeactivate,\n  Router,\n  RouterStateSnapshot,\n  UrlSerializer,\n  UrlTree\n} from '@angular/router';\nimport { lang, Trace } from '@coolon/pectin';\nimport { Observable } from 'rxjs';\nimport { InteractionService } from '../../interaction/services/interaction.service';\nimport { PlaceComponent } from '../place-component';\nimport { PlaceDefinition } from '../place-definition';\nimport { PlaceHistory } from '../place-history';\nimport { PlaceRouter } from '../place-router';\nimport { VisitSanitiser } from '../route/visit-sanitiser';\nimport { UrlSnapshot } from '../url-snapshot';\nimport { Visit } from '../visit';\nimport { ConsolidatedParameterMap } from './consolidated-param-map';\n\n\nexport abstract class PlaceGuard implements CanActivate, CanDeactivate<PlaceComponent> {\n\n\n  constructor(private readonly router: Router,\n              private urlSerializer: UrlSerializer,\n              private readonly placeRouter: PlaceRouter,\n              private readonly placeHistory: PlaceHistory,\n              private readonly interactionService: InteractionService,\n              private readonly injector: Injector) {\n  }\n\n  // @Trace()\n  async canActivate(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n\n     // TODO: this is ugly now that I'm return UrlSnapshots and not UrlTrees.  It'd be better if the functions\n    //        weren't nested or if I implemented a handler chain.\n    return this.authorisePlaceThen(activatedRoute, state, async (placeDefinition) => {\n\n      const result = await this.cleanInteractionState(activatedRoute, state, async () => {\n        // Parse our route params.\n        const params = new ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);\n        const parsedParams = placeDefinition.parseRouteParams(params);\n\n        const initialVisit = this.placeRouter.navigationState.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);\n        const sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);\n        const sanitisedVisit = await sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams));\n\n        // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters\n        this.placeRouter.navigationState.storeVisit(sanitisedVisit);\n        if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {\n          // Regenerate the url\n          const urlSnapshot = this.placeRouter.parseUrl(state.url).updateVisitSegments(sanitisedVisit);\n          console.log('##### Place Guard Redirect', urlSnapshot);\n          return urlSnapshot;\n        } else {\n          return true;\n        }\n      });\n      return this.handleGuardResult(result);\n\n    });\n  }\n\n  // @Trace()\n  async canDeactivate(component: PlaceComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Promise<boolean | UrlTree> {\n    const currentUrl = this.placeRouter.parseUrl(currentState.url);\n    const nextUrl = this.placeRouter.parseUrl(nextState.url);\n    const result = await this.placeRouter.navigationState.canDeactivatePlace(component, currentUrl, nextUrl);\n    return this.handleGuardResult(result);\n  }\n\n  private handleGuardResult(result) {\n    if (result instanceof UrlSnapshot) {\n      return result.urlTree;\n    } else {\n      return result;\n    }\n  }\n\n  // @Trace()\n  protected async authorisePlaceThen(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot, runPlaceGuards: (placeDefinition: PlaceDefinition) => Promise<boolean | UrlTree>) {\n    if (PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) {\n      const placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);\n      const authoriseResult = placeDefinition.authenticate ? await this.isAuthorised(activatedRoute, state) : true;\n      if (authoriseResult === true) {\n        // we're authorised, now run the place guards.\n        return runPlaceGuards(placeDefinition);\n      } else {\n        console.log('not authorised result', authoriseResult);\n        return authoriseResult;\n      }\n    } else {\n      return lang.illegalState(`expected component to be an instance of PlaceComponent, got ${activatedRoute.component}`);\n    }\n  }\n\n  // @Trace()\n  async isAuthorised(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n    const authorised = this.getAuthGuard(this.injector).canActivate(activatedRoute, state);\n    return (authorised instanceof Observable) ? authorised.toPromise() : authorised;\n  }\n\n  abstract getAuthGuard(injector: Injector): CanActivate;\n\n  // @Trace()\n  async cleanInteractionState(route: ActivatedRouteSnapshot, state: RouterStateSnapshot, then: () => Promise<boolean | UrlSnapshot>): Promise<boolean | UrlSnapshot> {\n    const url = this.placeRouter.parseUrl(state.url);\n    if (!this.interactionService.isActive() && url.hasInteractionIds()) {\n      // This happens if we reload the page or the url was pasted as the route should only be activated\n      // after the interaction context has become active.\n      return url.removeInteractionIds();\n    } else {\n      return then();\n    }\n  }\n\n}\n"]}

package/esm2015/lib/place/index.js

@@ -22,12 +22,11 @@ export { ListPlaceNavComponent } from "./components/list-place-nav/list-place-na
 export { PlaceOutletComponent } from "./components/place-outlet/place-outlet.component";
 export { leftRightPlaceAnimation, LEFT_RIGHT_PLACE_ANIMATION } from "./components/place-outlet/route-animations";
 export { TabbedPlaceNavigationComponent } from "./components/tabbed-place-navigation/tabbed-place-navigation.component";
-export { AbstractPlaceGuard } from "./guards/abstract-place.guard";
 export { ConsolidatedParameterMap } from "./guards/consolidated-param-map";
-export { InteractionGuard } from "./guards/interaction.guard";
 export { NavigationState } from "./guards/navigation-state";
 export { NoopAuthGuard } from "./guards/noop-auth-guard.service";
 export { PlaceComponentDeactivationHandler } from "./guards/place-component-deactivation-handler";
+export { PlaceGuard } from "./guards/place.guard";
 export { Formatter } from "./route/formatter";
 export {} from "./route/json-types";
 export { RouteId, VisitParameter, VisitParameterList } from "./route/parameter-decorators";
@@ -35,4 +34,4 @@ export { ParameterDefinition } from "./route/parameter-definition.class";
 export {} from "./route/parameter-sanitiser";
 export {} from "./route/parameter-snapshot";
 export { VisitSanitiser } from "./route/visit-sanitiser";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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