@ionic/angular 7.4.4-dev.11699475060.1eee2115 → 7.4.4-dev.11700515976.1ccd503d

package/esm2020/common/providers/menu-controller.mjs

@@ -0,0 +1,100 @@
+import { Injectable } from '@angular/core';
+import { menuController } from '@ionic/core/components';
+import * as i0 from "@angular/core";
+export class MenuController {
+    /**
+     * Programmatically open the Menu.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return returns a promise when the menu is fully opened
+     */
+    open(menuId) {
+        return menuController.open(menuId);
+    }
+    /**
+     * Programmatically close the Menu. If no `menuId` is given as the first
+     * argument then it'll close any menu which is open. If a `menuId`
+     * is given then it'll close that exact menu.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return returns a promise when the menu is fully closed
+     */
+    close(menuId) {
+        return menuController.close(menuId);
+    }
+    /**
+     * Toggle the menu. If it's closed, it will open, and if opened, it
+     * will close.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return returns a promise when the menu has been toggled
+     */
+    toggle(menuId) {
+        return menuController.toggle(menuId);
+    }
+    /**
+     * Used to enable or disable a menu. For example, there could be multiple
+     * left menus, but only one of them should be able to be opened at the same
+     * time. If there are multiple menus on the same side, then enabling one menu
+     * will also automatically disable all the others that are on the same side.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns the instance of the menu, which is useful for chaining.
+     */
+    enable(shouldEnable, menuId) {
+        return menuController.enable(shouldEnable, menuId);
+    }
+    /**
+     * Used to enable or disable the ability to swipe open the menu.
+     * @param shouldEnable  True if it should be swipe-able, false if not.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns the instance of the menu, which is useful for chaining.
+     */
+    swipeGesture(shouldEnable, menuId) {
+        return menuController.swipeGesture(shouldEnable, menuId);
+    }
+    /**
+     * @param [menuId] Optionally get the menu by its id, or side.
+     * @return Returns true if the specified menu is currently open, otherwise false.
+     * If the menuId is not specified, it returns true if ANY menu is currenly open.
+     */
+    isOpen(menuId) {
+        return menuController.isOpen(menuId);
+    }
+    /**
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns true if the menu is currently enabled, otherwise false.
+     */
+    isEnabled(menuId) {
+        return menuController.isEnabled(menuId);
+    }
+    /**
+     * Used to get a menu instance. If a `menuId` is not provided then it'll
+     * return the first menu found. If a `menuId` is `left` or `right`, then
+     * it'll return the enabled menu on that side. Otherwise, if a `menuId` is
+     * provided, then it'll try to find the menu using the menu's `id`
+     * property. If a menu is not found then it'll return `null`.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns the instance of the menu if found, otherwise `null`.
+     */
+    get(menuId) {
+        return menuController.get(menuId);
+    }
+    /**
+     * @return Returns the instance of the menu already opened, otherwise `null`.
+     */
+    getOpen() {
+        return menuController.getOpen();
+    }
+    /**
+     * @return Returns an array of all menu instances.
+     */
+    getMenus() {
+        return menuController.getMenus();
+    }
+}
+/** @nocollapse */ MenuController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MenuController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ MenuController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MenuController, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MenuController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/providers/modal-controller.mjs

@@ -0,0 +1,25 @@
+import { Injector, Injectable, EnvironmentInjector, inject } from '@angular/core';
+import { modalController } from '@ionic/core/components';
+import { OverlayBaseController } from '../utils/overlay';
+import { AngularDelegate } from './angular-delegate';
+import * as i0 from "@angular/core";
+export class ModalController extends OverlayBaseController {
+    constructor() {
+        super(modalController);
+        this.angularDelegate = inject(AngularDelegate);
+        this.injector = inject(Injector);
+        this.environmentInjector = inject(EnvironmentInjector);
+    }
+    create(opts) {
+        return super.create({
+            ...opts,
+            delegate: this.angularDelegate.create(this.environmentInjector, this.injector, 'modal'),
+        });
+    }
+}
+/** @nocollapse */ ModalController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ModalController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ ModalController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ModalController });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ModalController, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/providers/nav-controller.mjs

@@ -0,0 +1,221 @@
+import { Injectable, Optional } from '@angular/core';
+import { NavigationStart } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "./platform";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/router";
+export class NavController {
+    constructor(platform, location, serializer, router) {
+        this.location = location;
+        this.serializer = serializer;
+        this.router = router;
+        this.direction = DEFAULT_DIRECTION;
+        this.animated = DEFAULT_ANIMATED;
+        this.guessDirection = 'forward';
+        this.lastNavId = -1;
+        // Subscribe to router events to detect direction
+        if (router) {
+            router.events.subscribe((ev) => {
+                if (ev instanceof NavigationStart) {
+                    const id = ev.restoredState ? ev.restoredState.navigationId : ev.id;
+                    this.guessDirection = id < this.lastNavId ? 'back' : 'forward';
+                    this.guessAnimation = !ev.restoredState ? this.guessDirection : undefined;
+                    this.lastNavId = this.guessDirection === 'forward' ? ev.id : id;
+                }
+            });
+        }
+        // Subscribe to backButton events
+        platform.backButton.subscribeWithPriority(0, (processNextHandler) => {
+            this.pop();
+            processNextHandler();
+        });
+    }
+    /**
+     * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
+     * it's equivalent to calling `this.router.navigateByUrl()`, but it's explicit about the **direction** of the transition.
+     *
+     * Going **forward** means that a new page is going to be pushed to the stack of the outlet (ion-router-outlet),
+     * and that it will show a "forward" animation by default.
+     *
+     * Navigating forward can also be triggered in a declarative manner by using the `[routerDirection]` directive:
+     *
+     * ```html
+     * <a routerLink="/path/to/page" routerDirection="forward">Link</a>
+     * ```
+     */
+    navigateForward(url, options = {}) {
+        this.setDirection('forward', options.animated, options.animationDirection, options.animation);
+        return this.navigate(url, options);
+    }
+    /**
+     * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
+     * it's equivalent to calling:
+     *
+     * ```ts
+     * this.navController.setDirection('back');
+     * this.router.navigateByUrl(path);
+     * ```
+     *
+     * Going **back** means that all the pages in the stack until the navigated page is found will be popped,
+     * and that it will show a "back" animation by default.
+     *
+     * Navigating back can also be triggered in a declarative manner by using the `[routerDirection]` directive:
+     *
+     * ```html
+     * <a routerLink="/path/to/page" routerDirection="back">Link</a>
+     * ```
+     */
+    navigateBack(url, options = {}) {
+        this.setDirection('back', options.animated, options.animationDirection, options.animation);
+        return this.navigate(url, options);
+    }
+    /**
+     * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
+     * it's equivalent to calling:
+     *
+     * ```ts
+     * this.navController.setDirection('root');
+     * this.router.navigateByUrl(path);
+     * ```
+     *
+     * Going **root** means that all existing pages in the stack will be removed,
+     * and the navigated page will become the single page in the stack.
+     *
+     * Navigating root can also be triggered in a declarative manner by using the `[routerDirection]` directive:
+     *
+     * ```html
+     * <a routerLink="/path/to/page" routerDirection="root">Link</a>
+     * ```
+     */
+    navigateRoot(url, options = {}) {
+        this.setDirection('root', options.animated, options.animationDirection, options.animation);
+        return this.navigate(url, options);
+    }
+    /**
+     * Same as [Location](https://angular.io/api/common/Location)'s back() method.
+     * It will use the standard `window.history.back()` under the hood, but featuring a `back` animation
+     * by default.
+     */
+    back(options = { animated: true, animationDirection: 'back' }) {
+        this.setDirection('back', options.animated, options.animationDirection, options.animation);
+        return this.location.back();
+    }
+    /**
+     * This methods goes back in the context of Ionic's stack navigation.
+     *
+     * It recursively finds the top active `ion-router-outlet` and calls `pop()`.
+     * This is the recommended way to go back when you are using `ion-router-outlet`.
+     *
+     * Resolves to `true` if it was able to pop.
+     */
+    async pop() {
+        let outlet = this.topOutlet;
+        while (outlet) {
+            if (await outlet.pop()) {
+                return true;
+            }
+            else {
+                outlet = outlet.parentOutlet;
+            }
+        }
+        return false;
+    }
+    /**
+     * This methods specifies the direction of the next navigation performed by the Angular router.
+     *
+     * `setDirection()` does not trigger any transition, it just sets some flags to be consumed by `ion-router-outlet`.
+     *
+     * It's recommended to use `navigateForward()`, `navigateBack()` and `navigateRoot()` instead of `setDirection()`.
+     */
+    setDirection(direction, animated, animationDirection, animationBuilder) {
+        this.direction = direction;
+        this.animated = getAnimation(direction, animated, animationDirection);
+        this.animationBuilder = animationBuilder;
+    }
+    /**
+     * @internal
+     */
+    setTopOutlet(outlet) {
+        this.topOutlet = outlet;
+    }
+    /**
+     * @internal
+     */
+    consumeTransition() {
+        let direction = 'root';
+        let animation;
+        const animationBuilder = this.animationBuilder;
+        if (this.direction === 'auto') {
+            direction = this.guessDirection;
+            animation = this.guessAnimation;
+        }
+        else {
+            animation = this.animated;
+            direction = this.direction;
+        }
+        this.direction = DEFAULT_DIRECTION;
+        this.animated = DEFAULT_ANIMATED;
+        this.animationBuilder = undefined;
+        return {
+            direction,
+            animation,
+            animationBuilder,
+        };
+    }
+    navigate(url, options) {
+        if (Array.isArray(url)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return this.router.navigate(url, options);
+        }
+        else {
+            /**
+             * navigateByUrl ignores any properties that
+             * would change the url, so things like queryParams
+             * would be ignored unless we create a url tree
+             * More Info: https://github.com/angular/angular/issues/18798
+             */
+            const urlTree = this.serializer.parse(url.toString());
+            if (options.queryParams !== undefined) {
+                urlTree.queryParams = { ...options.queryParams };
+            }
+            if (options.fragment !== undefined) {
+                urlTree.fragment = options.fragment;
+            }
+            /**
+             * `navigateByUrl` will still apply `NavigationExtras` properties
+             * that do not modify the url, such as `replaceUrl` which is why
+             * `options` is passed in here.
+             */
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return this.router.navigateByUrl(urlTree, options);
+        }
+    }
+}
+/** @nocollapse */ NavController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: NavController, deps: [{ token: i1.Platform }, { token: i2.Location }, { token: i3.UrlSerializer }, { token: i3.Router, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ NavController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: NavController, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: NavController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: i2.Location }, { type: i3.UrlSerializer }, { type: i3.Router, decorators: [{
+                    type: Optional
+                }] }]; } });
+const getAnimation = (direction, animated, animationDirection) => {
+    if (animated === false) {
+        return undefined;
+    }
+    if (animationDirection !== undefined) {
+        return animationDirection;
+    }
+    if (direction === 'forward' || direction === 'back') {
+        return direction;
+    }
+    else if (direction === 'root' && animated === true) {
+        return 'forward';
+    }
+    return undefined;
+};
+const DEFAULT_DIRECTION = 'auto';
+const DEFAULT_ANIMATED = undefined;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-controller.js","sourceRoot":"","sources":["../../../../common/src/providers/nav-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\nimport { Injectable, Optional } from '@angular/core';\nimport { NavigationExtras, Router, UrlSerializer, UrlTree, NavigationStart } from '@angular/router';\nimport type { AnimationBuilder, NavDirection, RouterDirection } from '@ionic/core/components';\n\nimport { IonRouterOutlet } from '../directives/navigation/router-outlet';\n\nimport { Platform } from './platform';\n\nexport interface AnimationOptions {\n  animated?: boolean;\n  animation?: AnimationBuilder;\n  animationDirection?: 'forward' | 'back';\n}\n\nexport interface NavigationOptions extends NavigationExtras, AnimationOptions {}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class NavController {\n  private topOutlet?: IonRouterOutlet;\n  private direction: 'forward' | 'back' | 'root' | 'auto' = DEFAULT_DIRECTION;\n  private animated?: NavDirection = DEFAULT_ANIMATED;\n  private animationBuilder?: AnimationBuilder;\n  private guessDirection: RouterDirection = 'forward';\n  private guessAnimation?: NavDirection;\n  private lastNavId = -1;\n\n  constructor(\n    platform: Platform,\n    private location: Location,\n    private serializer: UrlSerializer,\n    @Optional() private router?: Router\n  ) {\n    // Subscribe to router events to detect direction\n    if (router) {\n      router.events.subscribe((ev) => {\n        if (ev instanceof NavigationStart) {\n          const id = ev.restoredState ? ev.restoredState.navigationId : ev.id;\n          this.guessDirection = id < this.lastNavId ? 'back' : 'forward';\n          this.guessAnimation = !ev.restoredState ? this.guessDirection : undefined;\n          this.lastNavId = this.guessDirection === 'forward' ? ev.id : id;\n        }\n      });\n    }\n\n    // Subscribe to backButton events\n    platform.backButton.subscribeWithPriority(0, (processNextHandler) => {\n      this.pop();\n      processNextHandler();\n    });\n  }\n\n  /**\n   * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,\n   * it's equivalent to calling `this.router.navigateByUrl()`, but it's explicit about the **direction** of the transition.\n   *\n   * Going **forward** means that a new page is going to be pushed to the stack of the outlet (ion-router-outlet),\n   * and that it will show a \"forward\" animation by default.\n   *\n   * Navigating forward can also be triggered in a declarative manner by using the `[routerDirection]` directive:\n   *\n   * ```html\n   * <a routerLink=\"/path/to/page\" routerDirection=\"forward\">Link</a>\n   * ```\n   */\n  navigateForward(url: string | UrlTree | any[], options: NavigationOptions = {}): Promise<boolean> {\n    this.setDirection('forward', options.animated, options.animationDirection, options.animation);\n    return this.navigate(url, options);\n  }\n\n  /**\n   * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,\n   * it's equivalent to calling:\n   *\n   * ```ts\n   * this.navController.setDirection('back');\n   * this.router.navigateByUrl(path);\n   * ```\n   *\n   * Going **back** means that all the pages in the stack until the navigated page is found will be popped,\n   * and that it will show a \"back\" animation by default.\n   *\n   * Navigating back can also be triggered in a declarative manner by using the `[routerDirection]` directive:\n   *\n   * ```html\n   * <a routerLink=\"/path/to/page\" routerDirection=\"back\">Link</a>\n   * ```\n   */\n  navigateBack(url: string | UrlTree | any[], options: NavigationOptions = {}): Promise<boolean> {\n    this.setDirection('back', options.animated, options.animationDirection, options.animation);\n    return this.navigate(url, options);\n  }\n\n  /**\n   * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,\n   * it's equivalent to calling:\n   *\n   * ```ts\n   * this.navController.setDirection('root');\n   * this.router.navigateByUrl(path);\n   * ```\n   *\n   * Going **root** means that all existing pages in the stack will be removed,\n   * and the navigated page will become the single page in the stack.\n   *\n   * Navigating root can also be triggered in a declarative manner by using the `[routerDirection]` directive:\n   *\n   * ```html\n   * <a routerLink=\"/path/to/page\" routerDirection=\"root\">Link</a>\n   * ```\n   */\n  navigateRoot(url: string | UrlTree | any[], options: NavigationOptions = {}): Promise<boolean> {\n    this.setDirection('root', options.animated, options.animationDirection, options.animation);\n    return this.navigate(url, options);\n  }\n\n  /**\n   * Same as [Location](https://angular.io/api/common/Location)'s back() method.\n   * It will use the standard `window.history.back()` under the hood, but featuring a `back` animation\n   * by default.\n   */\n  back(options: AnimationOptions = { animated: true, animationDirection: 'back' }): void {\n    this.setDirection('back', options.animated, options.animationDirection, options.animation);\n    return this.location.back();\n  }\n\n  /**\n   * This methods goes back in the context of Ionic's stack navigation.\n   *\n   * It recursively finds the top active `ion-router-outlet` and calls `pop()`.\n   * This is the recommended way to go back when you are using `ion-router-outlet`.\n   *\n   * Resolves to `true` if it was able to pop.\n   */\n  async pop(): Promise<boolean> {\n    let outlet = this.topOutlet;\n\n    while (outlet) {\n      if (await outlet.pop()) {\n        return true;\n      } else {\n        outlet = outlet.parentOutlet;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * This methods specifies the direction of the next navigation performed by the Angular router.\n   *\n   * `setDirection()` does not trigger any transition, it just sets some flags to be consumed by `ion-router-outlet`.\n   *\n   * It's recommended to use `navigateForward()`, `navigateBack()` and `navigateRoot()` instead of `setDirection()`.\n   */\n  setDirection(\n    direction: RouterDirection,\n    animated?: boolean,\n    animationDirection?: 'forward' | 'back',\n    animationBuilder?: AnimationBuilder\n  ): void {\n    this.direction = direction;\n    this.animated = getAnimation(direction, animated, animationDirection);\n    this.animationBuilder = animationBuilder;\n  }\n\n  /**\n   * @internal\n   */\n  setTopOutlet(outlet: IonRouterOutlet): void {\n    this.topOutlet = outlet;\n  }\n\n  /**\n   * @internal\n   */\n  consumeTransition(): {\n    direction: RouterDirection;\n    animation: NavDirection | undefined;\n    animationBuilder: AnimationBuilder | undefined;\n  } {\n    let direction: RouterDirection = 'root';\n    let animation: NavDirection | undefined;\n    const animationBuilder = this.animationBuilder;\n\n    if (this.direction === 'auto') {\n      direction = this.guessDirection;\n      animation = this.guessAnimation;\n    } else {\n      animation = this.animated;\n      direction = this.direction;\n    }\n    this.direction = DEFAULT_DIRECTION;\n    this.animated = DEFAULT_ANIMATED;\n    this.animationBuilder = undefined;\n\n    return {\n      direction,\n      animation,\n      animationBuilder,\n    };\n  }\n\n  private navigate(url: string | UrlTree | any[], options: NavigationOptions) {\n    if (Array.isArray(url)) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      return this.router!.navigate(url, options);\n    } else {\n      /**\n       * navigateByUrl ignores any properties that\n       * would change the url, so things like queryParams\n       * would be ignored unless we create a url tree\n       * More Info: https://github.com/angular/angular/issues/18798\n       */\n      const urlTree = this.serializer.parse(url.toString());\n\n      if (options.queryParams !== undefined) {\n        urlTree.queryParams = { ...options.queryParams };\n      }\n\n      if (options.fragment !== undefined) {\n        urlTree.fragment = options.fragment;\n      }\n\n      /**\n       * `navigateByUrl` will still apply `NavigationExtras` properties\n       * that do not modify the url, such as `replaceUrl` which is why\n       * `options` is passed in here.\n       */\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      return this.router!.navigateByUrl(urlTree, options);\n    }\n  }\n}\n\nconst getAnimation = (\n  direction: RouterDirection,\n  animated: boolean | undefined,\n  animationDirection: 'forward' | 'back' | undefined\n): NavDirection | undefined => {\n  if (animated === false) {\n    return undefined;\n  }\n  if (animationDirection !== undefined) {\n    return animationDirection;\n  }\n  if (direction === 'forward' || direction === 'back') {\n    return direction;\n  } else if (direction === 'root' && animated === true) {\n    return 'forward';\n  }\n  return undefined;\n};\n\nconst DEFAULT_DIRECTION = 'auto';\nconst DEFAULT_ANIMATED = undefined;\n"]}

package/esm2020/common/providers/picker-controller.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { pickerController } from '@ionic/core/components';
+import { OverlayBaseController } from '../utils/overlay';
+import * as i0 from "@angular/core";
+export class PickerController extends OverlayBaseController {
+    constructor() {
+        super(pickerController);
+    }
+}
+/** @nocollapse */ PickerController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: PickerController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ PickerController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: PickerController, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: PickerController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlja2VyLWNvbnRyb2xsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9jb21tb24vc3JjL3Byb3ZpZGVycy9waWNrZXItY29udHJvbGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRTFELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGtCQUFrQixDQUFDOztBQUt6RCxNQUFNLE9BQU8sZ0JBQWlCLFNBQVEscUJBQTBEO0lBQzlGO1FBQ0UsS0FBSyxDQUFDLGdCQUFnQixDQUFDLENBQUM7SUFDMUIsQ0FBQzs7aUlBSFUsZ0JBQWdCO3FJQUFoQixnQkFBZ0IsY0FGZixNQUFNOzRGQUVQLGdCQUFnQjtrQkFINUIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgdHlwZSB7IFBpY2tlck9wdGlvbnMgfSBmcm9tICdAaW9uaWMvY29yZS9jb21wb25lbnRzJztcbmltcG9ydCB7IHBpY2tlckNvbnRyb2xsZXIgfSBmcm9tICdAaW9uaWMvY29yZS9jb21wb25lbnRzJztcblxuaW1wb3J0IHsgT3ZlcmxheUJhc2VDb250cm9sbGVyIH0gZnJvbSAnLi4vdXRpbHMvb3ZlcmxheSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBQaWNrZXJDb250cm9sbGVyIGV4dGVuZHMgT3ZlcmxheUJhc2VDb250cm9sbGVyPFBpY2tlck9wdGlvbnMsIEhUTUxJb25QaWNrZXJFbGVtZW50PiB7XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKHBpY2tlckNvbnRyb2xsZXIpO1xuICB9XG59XG4iXX0=