@skyux/popovers 5.7.2 → 6.0.0-beta.2

package/esm2020/lib/modules/popover/popover.component.mjs

@@ -0,0 +1,198 @@
+import { Component, EventEmitter, Input, Output, TemplateRef, ViewChild, } from '@angular/core';
+import { SkyOverlayService } from '@skyux/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { SkyPopoverContentComponent } from './popover-content.component';
+import { SkyPopoverContext } from './popover-context';
+import * as i0 from "@angular/core";
+import * as i1 from "@skyux/core";
+export class SkyPopoverComponent {
+    constructor(overlayService) {
+        this.overlayService = overlayService;
+        /**
+         * Fires when users close the popover.
+         */
+        this.popoverClosed = new EventEmitter();
+        /**
+         * Fires when users open the popover.
+         */
+        this.popoverOpened = new EventEmitter();
+        /**
+         * Indicates that the popover is in the process of being opened or closed.
+         * @internal
+         */
+        this.isActive = false;
+        /**
+         * Used by unit tests to disable animations since the component is injected at the bottom of the
+         * document body.
+         * @internal
+         */
+        this.enableAnimations = true;
+        this.isMouseEnter = false;
+        this.isMarkedForCloseOnMouseLeave = false;
+        this.ngUnsubscribe = new Subject();
+    }
+    /**
+     * Specifies the horizontal alignment of the popover in relation to the trigger element.
+     * The `skyPopoverAlignment` property on the popover directive overwrites this property.
+     * Options include:`"center"`, `"right"`, and `'"left"`.
+     * @default "center"
+     */
+    set alignment(value) {
+        this._alignment = value;
+    }
+    get alignment() {
+        return this._alignment || 'center';
+    }
+    /**
+     * Indicates whether to close the popover when it loses focus.
+     * To require users to click a trigger button to close the popover, set this input to false.
+     * @default true
+     */
+    set dismissOnBlur(value) {
+        this._dismissOnBlur = value;
+    }
+    get dismissOnBlur() {
+        if (this._dismissOnBlur === undefined) {
+            return true;
+        }
+        return this._dismissOnBlur;
+    }
+    /**
+     * Specifies the placement of the popover in relation to the trigger element.
+     * The `skyPopoverPlacement` property on the popover directive overwrites this property.
+     * Options include:`"above"`, `"below"`, `"right"`, and `"left"`.
+     * @default "above"
+     */
+    set placement(value) {
+        this._placement = value;
+    }
+    get placement() {
+        return this._placement || 'above';
+    }
+    ngOnDestroy() {
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+        this.ngUnsubscribe = undefined;
+        if (this.overlay) {
+            this.overlayService.close(this.overlay);
+            this.overlay = undefined;
+        }
+    }
+    /**
+     * Positions the popover next to a given caller element.
+     * @param caller The element that opened the popover.
+     * @param placement The placement of the popover.
+     * @param alignment The horizontal alignment of the popover.
+     * @internal
+     */
+    positionNextTo(caller, placement, alignment) {
+        if (!this.overlay) {
+            this.setupOverlay();
+        }
+        this.placement = placement;
+        this.alignment = alignment;
+        this.isActive = true;
+        this.contentRef.open(caller, {
+            dismissOnBlur: this.dismissOnBlur,
+            enableAnimations: this.enableAnimations,
+            horizontalAlignment: this.alignment,
+            isStatic: false,
+            placement: this.placement,
+            popoverTitle: this.popoverTitle,
+            popoverType: this.popoverType,
+        });
+    }
+    /**
+     * Closes the popover.
+     * @internal
+     */
+    close() {
+        /*istanbul ignore next*/
+        this.contentRef?.close();
+    }
+    /**
+     * Brings focus to the popover element if its open.
+     * @internal
+     */
+    applyFocus() {
+        /*istanbul ignore next*/
+        this.contentRef?.applyFocus();
+    }
+    /**
+     * Adds a flag to the popover to close when the mouse leaves the popover's bounds.
+     * @internal
+     */
+    markForCloseOnMouseLeave() {
+        this.isMarkedForCloseOnMouseLeave = true;
+    }
+    setupOverlay() {
+        const overlay = this.overlayService.create({
+            enableScroll: true,
+            enablePointerEvents: true,
+        });
+        overlay.backdropClick.pipe(takeUntil(this.ngUnsubscribe)).subscribe(() => {
+            if (this.dismissOnBlur) {
+                this.close();
+            }
+        });
+        const contentRef = overlay.attachComponent(SkyPopoverContentComponent, [
+            {
+                provide: SkyPopoverContext,
+                useValue: new SkyPopoverContext({
+                    contentTemplateRef: this.templateRef,
+                }),
+            },
+        ]);
+        contentRef.opened.pipe(takeUntil(this.ngUnsubscribe)).subscribe(() => {
+            this.popoverOpened.emit(this);
+        });
+        contentRef.closed.pipe(takeUntil(this.ngUnsubscribe)).subscribe(() => {
+            /*istanbul ignore else*/
+            if (this.isActive) {
+                this.overlayService.close(this.overlay);
+                this.overlay = undefined;
+                this.isActive = false;
+                this.popoverClosed.emit(this);
+            }
+        });
+        contentRef.isMouseEnter
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe((isMouseEnter) => {
+            this.isMouseEnter = isMouseEnter;
+            if (this.isMarkedForCloseOnMouseLeave) {
+                this.isMarkedForCloseOnMouseLeave = false;
+                this.close();
+            }
+        });
+        this.overlay = overlay;
+        this.contentRef = contentRef;
+    }
+}
+SkyPopoverComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoverComponent, deps: [{ token: i1.SkyOverlayService }], target: i0.ɵɵFactoryTarget.Component });
+SkyPopoverComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", type: SkyPopoverComponent, selector: "sky-popover", inputs: { alignment: "alignment", dismissOnBlur: "dismissOnBlur", placement: "placement", popoverTitle: "popoverTitle", popoverType: "popoverType" }, outputs: { popoverClosed: "popoverClosed", popoverOpened: "popoverOpened" }, viewQueries: [{ propertyName: "templateRef", first: true, predicate: ["templateRef"], descendants: true, read: TemplateRef, static: true }], ngImport: i0, template: "<ng-template #templateRef>\n  <ng-content></ng-content>\n</ng-template>\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoverComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-popover', template: "<ng-template #templateRef>\n  <ng-content></ng-content>\n</ng-template>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.SkyOverlayService }]; }, propDecorators: { alignment: [{
+                type: Input
+            }], dismissOnBlur: [{
+                type: Input
+            }], placement: [{
+                type: Input
+            }], popoverTitle: [{
+                type: Input
+            }], popoverType: [{
+                type: Input
+            }], popoverClosed: [{
+                type: Output
+            }], popoverOpened: [{
+                type: Output
+            }], templateRef: [{
+                type: ViewChild,
+                args: ['templateRef', {
+                        read: TemplateRef,
+                        static: true,
+                    }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.component.js","sourceRoot":"","sources":["../../../../../../../../libs/components/popovers/src/lib/modules/popover/popover.component.ts","../../../../../../../../libs/components/popovers/src/lib/modules/popover/popover.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  TemplateRef,\n  ViewChild,\n} from '@angular/core';\nimport { SkyOverlayInstance, SkyOverlayService } from '@skyux/core';\n\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { SkyPopoverContentComponent } from './popover-content.component';\nimport { SkyPopoverContext } from './popover-context';\nimport { SkyPopoverAlignment } from './types/popover-alignment';\nimport { SkyPopoverPlacement } from './types/popover-placement';\n\n@Component({\n  selector: 'sky-popover',\n  templateUrl: './popover.component.html',\n})\nexport class SkyPopoverComponent implements OnDestroy {\n  /**\n   * Specifies the horizontal alignment of the popover in relation to the trigger element.\n   * The `skyPopoverAlignment` property on the popover directive overwrites this property.\n   * Options include:`\"center\"`, `\"right\"`, and `'\"left\"`.\n   * @default \"center\"\n   */\n  @Input()\n  public set alignment(value: SkyPopoverAlignment) {\n    this._alignment = value;\n  }\n\n  public get alignment(): SkyPopoverAlignment {\n    return this._alignment || 'center';\n  }\n\n  /**\n   * Indicates whether to close the popover when it loses focus.\n   * To require users to click a trigger button to close the popover, set this input to false.\n   * @default true\n   */\n  @Input()\n  public set dismissOnBlur(value: boolean) {\n    this._dismissOnBlur = value;\n  }\n\n  public get dismissOnBlur(): boolean {\n    if (this._dismissOnBlur === undefined) {\n      return true;\n    }\n\n    return this._dismissOnBlur;\n  }\n\n  /**\n   * Specifies the placement of the popover in relation to the trigger element.\n   * The `skyPopoverPlacement` property on the popover directive overwrites this property.\n   * Options include:`\"above\"`, `\"below\"`, `\"right\"`, and `\"left\"`.\n   * @default \"above\"\n   */\n  @Input()\n  public set placement(value: SkyPopoverPlacement) {\n    this._placement = value;\n  }\n\n  public get placement(): SkyPopoverPlacement {\n    return this._placement || 'above';\n  }\n\n  /**\n   * Specifies a title for the popover.\n   */\n  @Input()\n  public popoverTitle: string;\n\n  /**\n   * Specifies the type of popover.\n   * Options include `\"info\"` and `\"danger\"`.\n   * @default \"info\"\n   */\n  @Input()\n  public popoverType: 'danger' | 'info';\n\n  /**\n   * Fires when users close the popover.\n   */\n  @Output()\n  public popoverClosed = new EventEmitter<SkyPopoverComponent>();\n\n  /**\n   * Fires when users open the popover.\n   */\n  @Output()\n  public popoverOpened = new EventEmitter<SkyPopoverComponent>();\n\n  /**\n   * Indicates that the popover is in the process of being opened or closed.\n   * @internal\n   */\n  public isActive = false;\n\n  /**\n   * Used by unit tests to disable animations since the component is injected at the bottom of the\n   * document body.\n   * @internal\n   */\n  public enableAnimations = true;\n\n  public isMouseEnter = false;\n\n  @ViewChild('templateRef', {\n    read: TemplateRef,\n    static: true,\n  })\n  private templateRef: TemplateRef<any>;\n\n  private contentRef: SkyPopoverContentComponent;\n\n  private isMarkedForCloseOnMouseLeave = false;\n\n  private ngUnsubscribe = new Subject<void>();\n\n  private overlay: SkyOverlayInstance;\n\n  private _alignment: SkyPopoverAlignment;\n\n  private _dismissOnBlur: boolean;\n\n  private _placement: SkyPopoverPlacement;\n\n  constructor(private overlayService: SkyOverlayService) {}\n\n  public ngOnDestroy(): void {\n    this.ngUnsubscribe.next();\n    this.ngUnsubscribe.complete();\n    this.ngUnsubscribe = undefined;\n\n    if (this.overlay) {\n      this.overlayService.close(this.overlay);\n      this.overlay = undefined;\n    }\n  }\n\n  /**\n   * Positions the popover next to a given caller element.\n   * @param caller The element that opened the popover.\n   * @param placement The placement of the popover.\n   * @param alignment The horizontal alignment of the popover.\n   * @internal\n   */\n  public positionNextTo(\n    caller: ElementRef,\n    placement?: SkyPopoverPlacement,\n    alignment?: SkyPopoverAlignment\n  ): void {\n    if (!this.overlay) {\n      this.setupOverlay();\n    }\n\n    this.placement = placement;\n    this.alignment = alignment;\n    this.isActive = true;\n\n    this.contentRef.open(caller, {\n      dismissOnBlur: this.dismissOnBlur,\n      enableAnimations: this.enableAnimations,\n      horizontalAlignment: this.alignment,\n      isStatic: false,\n      placement: this.placement,\n      popoverTitle: this.popoverTitle,\n      popoverType: this.popoverType,\n    });\n  }\n\n  /**\n   * Closes the popover.\n   * @internal\n   */\n  public close(): void {\n    /*istanbul ignore next*/\n    this.contentRef?.close();\n  }\n\n  /**\n   * Brings focus to the popover element if its open.\n   * @internal\n   */\n  public applyFocus(): void {\n    /*istanbul ignore next*/\n    this.contentRef?.applyFocus();\n  }\n\n  /**\n   * Adds a flag to the popover to close when the mouse leaves the popover's bounds.\n   * @internal\n   */\n  public markForCloseOnMouseLeave(): void {\n    this.isMarkedForCloseOnMouseLeave = true;\n  }\n\n  private setupOverlay(): void {\n    const overlay = this.overlayService.create({\n      enableScroll: true,\n      enablePointerEvents: true,\n    });\n\n    overlay.backdropClick.pipe(takeUntil(this.ngUnsubscribe)).subscribe(() => {\n      if (this.dismissOnBlur) {\n        this.close();\n      }\n    });\n\n    const contentRef = overlay.attachComponent(SkyPopoverContentComponent, [\n      {\n        provide: SkyPopoverContext,\n        useValue: new SkyPopoverContext({\n          contentTemplateRef: this.templateRef,\n        }),\n      },\n    ]);\n\n    contentRef.opened.pipe(takeUntil(this.ngUnsubscribe)).subscribe(() => {\n      this.popoverOpened.emit(this);\n    });\n\n    contentRef.closed.pipe(takeUntil(this.ngUnsubscribe)).subscribe(() => {\n      /*istanbul ignore else*/\n      if (this.isActive) {\n        this.overlayService.close(this.overlay);\n        this.overlay = undefined;\n        this.isActive = false;\n        this.popoverClosed.emit(this);\n      }\n    });\n\n    contentRef.isMouseEnter\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe((isMouseEnter) => {\n        this.isMouseEnter = isMouseEnter;\n        if (this.isMarkedForCloseOnMouseLeave) {\n          this.isMarkedForCloseOnMouseLeave = false;\n          this.close();\n        }\n      });\n\n    this.overlay = overlay;\n    this.contentRef = contentRef;\n  }\n}\n","<ng-template #templateRef>\n  <ng-content></ng-content>\n</ng-template>\n"]}

package/esm2020/lib/modules/popover/popover.directive.mjs

@@ -0,0 +1,176 @@
+import { Directive, ElementRef, Input } from '@angular/core';
+import { Subject, fromEvent as observableFromEvent } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { SkyPopoverComponent } from './popover.component';
+import { SkyPopoverMessageType } from './types/popover-message-type';
+import * as i0 from "@angular/core";
+export class SkyPopoverDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        /**
+         * Provides an observable to send commands to the popover that respect the `SkyPopoverMessage` type.
+         */
+        this.skyPopoverMessageStream = new Subject();
+        this.ngUnsubscribe = new Subject();
+    }
+    /**
+     * Specifies the user action that displays the popover.
+     */
+    set skyPopoverTrigger(value) {
+        this._trigger = value;
+    }
+    get skyPopoverTrigger() {
+        return this._trigger || 'click';
+    }
+    ngOnInit() {
+        this.addEventListeners();
+    }
+    ngOnDestroy() {
+        this.removeEventListeners();
+    }
+    togglePopover() {
+        if (this.skyPopover.isActive) {
+            this.sendMessage(SkyPopoverMessageType.Close);
+            return;
+        }
+        this.sendMessage(SkyPopoverMessageType.Open);
+    }
+    positionPopover() {
+        this.skyPopover.positionNextTo(this.elementRef, this.skyPopoverPlacement, this.skyPopoverAlignment);
+    }
+    closePopover() {
+        this.skyPopover.close();
+    }
+    closePopoverOrMarkForClose() {
+        if (this.skyPopover.isMouseEnter) {
+            this.skyPopover.markForCloseOnMouseLeave();
+        }
+        else {
+            this.sendMessage(SkyPopoverMessageType.Close);
+        }
+    }
+    addEventListeners() {
+        const element = this.elementRef.nativeElement;
+        this.skyPopoverMessageStream
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe((message) => {
+            this.handleIncomingMessages(message);
+        });
+        observableFromEvent(element, 'keydown')
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe((event) => {
+            if (!this.skyPopover.isActive) {
+                return;
+            }
+            const key = event.key.toLowerCase();
+            /* tslint:disable-next-line:switch-default */
+            switch (key) {
+                case 'escape':
+                    this.sendMessage(SkyPopoverMessageType.Close);
+                    event.preventDefault();
+                    event.stopPropagation();
+                    break;
+                case 'tab':
+                    if (this.skyPopover.dismissOnBlur) {
+                        this.sendMessage(SkyPopoverMessageType.Close);
+                    }
+                    break;
+                case 'arrowdown':
+                case 'arrowleft':
+                case 'arrowright':
+                case 'arrowup':
+                case 'down':
+                case 'left':
+                case 'right':
+                case 'up':
+                    this.sendMessage(SkyPopoverMessageType.Focus);
+                    event.stopPropagation();
+                    event.preventDefault();
+                    break;
+            }
+        });
+        observableFromEvent(element, 'click')
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe(() => {
+            if (this.skyPopover) {
+                this.togglePopover();
+            }
+        });
+        observableFromEvent(element, 'mouseenter')
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe(() => {
+            if (this.skyPopover) {
+                this.skyPopover.isMouseEnter = true;
+                if (!this.skyPopover.isActive &&
+                    this.skyPopoverTrigger === 'mouseenter') {
+                    this.sendMessage(SkyPopoverMessageType.Open);
+                }
+            }
+        });
+        observableFromEvent(element, 'mouseleave')
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe(() => {
+            if (this.skyPopover) {
+                this.skyPopover.isMouseEnter = false;
+                if (this.skyPopover.isActive &&
+                    this.skyPopoverTrigger === 'mouseenter') {
+                    // Give the popover a chance to set its isMouseEnter flag before checking to see
+                    // if it should be closed.
+                    setTimeout(() => {
+                        this.closePopoverOrMarkForClose();
+                    });
+                }
+            }
+        });
+    }
+    removeEventListeners() {
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+        this.ngUnsubscribe = undefined;
+    }
+    handleIncomingMessages(message) {
+        /* tslint:disable-next-line:switch-default */
+        switch (message.type) {
+            case SkyPopoverMessageType.Open:
+                this.positionPopover();
+                break;
+            case SkyPopoverMessageType.Close:
+                /*istanbul ignore else*/
+                if (this.skyPopover.isActive) {
+                    this.closePopover();
+                }
+                break;
+            case SkyPopoverMessageType.Reposition:
+                // Only reposition the popover if it is already open.
+                if (this.skyPopover.isActive) {
+                    this.positionPopover();
+                }
+                break;
+            case SkyPopoverMessageType.Focus:
+                this.skyPopover.applyFocus();
+                break;
+        }
+    }
+    sendMessage(messageType) {
+        this.skyPopoverMessageStream.next({ type: messageType });
+    }
+}
+SkyPopoverDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoverDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+SkyPopoverDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.7", type: SkyPopoverDirective, selector: "[skyPopover]", inputs: { skyPopover: "skyPopover", skyPopoverAlignment: "skyPopoverAlignment", skyPopoverMessageStream: "skyPopoverMessageStream", skyPopoverPlacement: "skyPopoverPlacement", skyPopoverTrigger: "skyPopoverTrigger" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoverDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[skyPopover]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { skyPopover: [{
+                type: Input
+            }], skyPopoverAlignment: [{
+                type: Input
+            }], skyPopoverMessageStream: [{
+                type: Input
+            }], skyPopoverPlacement: [{
+                type: Input
+            }], skyPopoverTrigger: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.directive.js","sourceRoot":"","sources":["../../../../../../../../libs/components/popovers/src/lib/modules/popover/popover.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, Input, OnDestroy, OnInit } from '@angular/core';\n\nimport { Subject, fromEvent as observableFromEvent } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { SkyPopoverComponent } from './popover.component';\nimport { SkyPopoverAlignment } from './types/popover-alignment';\nimport { SkyPopoverMessage } from './types/popover-message';\nimport { SkyPopoverMessageType } from './types/popover-message-type';\nimport { SkyPopoverPlacement } from './types/popover-placement';\nimport { SkyPopoverTrigger } from './types/popover-trigger';\n\n@Directive({\n  selector: '[skyPopover]',\n})\nexport class SkyPopoverDirective implements OnInit, OnDestroy {\n  /**\n   * References the popover component to display. Add this directive to the trigger element that opens the popover.\n   * @required\n   */\n  @Input()\n  public skyPopover: SkyPopoverComponent;\n\n  /**\n   * Specifies the horizontal alignment of the popover in relation to the trigger element.\n   * Options include:`\"center\"`, `\"right\"`, and `\"left\"`.\n   * @default \"center\"\n   */\n  @Input()\n  public skyPopoverAlignment: SkyPopoverAlignment;\n\n  /**\n   * Provides an observable to send commands to the popover that respect the `SkyPopoverMessage` type.\n   */\n  @Input()\n  public skyPopoverMessageStream = new Subject<SkyPopoverMessage>();\n\n  /**\n   * Specifies the placement of the popover in relation to the trigger element.\n   * Options include:`\"above\"`, `\"below\"`, `\"right\"`, and `\"left\"`.\n   * @default \"above\"\n   */\n  @Input()\n  public skyPopoverPlacement: SkyPopoverPlacement;\n\n  /**\n   * Specifies the user action that displays the popover.\n   */\n  @Input()\n  public set skyPopoverTrigger(value: SkyPopoverTrigger) {\n    this._trigger = value;\n  }\n\n  public get skyPopoverTrigger(): SkyPopoverTrigger {\n    return this._trigger || 'click';\n  }\n\n  private ngUnsubscribe = new Subject<void>();\n\n  private _trigger: SkyPopoverTrigger;\n\n  constructor(private elementRef: ElementRef) {}\n\n  public ngOnInit(): void {\n    this.addEventListeners();\n  }\n\n  public ngOnDestroy(): void {\n    this.removeEventListeners();\n  }\n\n  public togglePopover(): void {\n    if (this.skyPopover.isActive) {\n      this.sendMessage(SkyPopoverMessageType.Close);\n      return;\n    }\n\n    this.sendMessage(SkyPopoverMessageType.Open);\n  }\n\n  private positionPopover(): void {\n    this.skyPopover.positionNextTo(\n      this.elementRef,\n      this.skyPopoverPlacement,\n      this.skyPopoverAlignment\n    );\n  }\n\n  private closePopover(): void {\n    this.skyPopover.close();\n  }\n\n  private closePopoverOrMarkForClose(): void {\n    if (this.skyPopover.isMouseEnter) {\n      this.skyPopover.markForCloseOnMouseLeave();\n    } else {\n      this.sendMessage(SkyPopoverMessageType.Close);\n    }\n  }\n\n  private addEventListeners(): void {\n    const element = this.elementRef.nativeElement;\n\n    this.skyPopoverMessageStream\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe((message) => {\n        this.handleIncomingMessages(message);\n      });\n\n    observableFromEvent(element, 'keydown')\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe((event: KeyboardEvent) => {\n        if (!this.skyPopover.isActive) {\n          return;\n        }\n\n        const key = event.key.toLowerCase();\n\n        /* tslint:disable-next-line:switch-default */\n        switch (key) {\n          case 'escape':\n            this.sendMessage(SkyPopoverMessageType.Close);\n            event.preventDefault();\n            event.stopPropagation();\n            break;\n\n          case 'tab':\n            if (this.skyPopover.dismissOnBlur) {\n              this.sendMessage(SkyPopoverMessageType.Close);\n            }\n            break;\n\n          case 'arrowdown':\n          case 'arrowleft':\n          case 'arrowright':\n          case 'arrowup':\n          case 'down':\n          case 'left':\n          case 'right':\n          case 'up':\n            this.sendMessage(SkyPopoverMessageType.Focus);\n            event.stopPropagation();\n            event.preventDefault();\n            break;\n        }\n      });\n\n    observableFromEvent(element, 'click')\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe(() => {\n        if (this.skyPopover) {\n          this.togglePopover();\n        }\n      });\n\n    observableFromEvent(element, 'mouseenter')\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe(() => {\n        if (this.skyPopover) {\n          this.skyPopover.isMouseEnter = true;\n          if (\n            !this.skyPopover.isActive &&\n            this.skyPopoverTrigger === 'mouseenter'\n          ) {\n            this.sendMessage(SkyPopoverMessageType.Open);\n          }\n        }\n      });\n\n    observableFromEvent(element, 'mouseleave')\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe(() => {\n        if (this.skyPopover) {\n          this.skyPopover.isMouseEnter = false;\n          if (\n            this.skyPopover.isActive &&\n            this.skyPopoverTrigger === 'mouseenter'\n          ) {\n            // Give the popover a chance to set its isMouseEnter flag before checking to see\n            // if it should be closed.\n            setTimeout(() => {\n              this.closePopoverOrMarkForClose();\n            });\n          }\n        }\n      });\n  }\n\n  private removeEventListeners(): void {\n    this.ngUnsubscribe.next();\n    this.ngUnsubscribe.complete();\n    this.ngUnsubscribe = undefined;\n  }\n\n  private handleIncomingMessages(message: SkyPopoverMessage): void {\n    /* tslint:disable-next-line:switch-default */\n    switch (message.type) {\n      case SkyPopoverMessageType.Open:\n        this.positionPopover();\n        break;\n\n      case SkyPopoverMessageType.Close:\n        /*istanbul ignore else*/\n        if (this.skyPopover.isActive) {\n          this.closePopover();\n        }\n        break;\n\n      case SkyPopoverMessageType.Reposition:\n        // Only reposition the popover if it is already open.\n        if (this.skyPopover.isActive) {\n          this.positionPopover();\n        }\n        break;\n\n      case SkyPopoverMessageType.Focus:\n        this.skyPopover.applyFocus();\n        break;\n    }\n  }\n\n  private sendMessage(messageType: SkyPopoverMessageType): void {\n    this.skyPopoverMessageStream.next({ type: messageType });\n  }\n}\n"]}

package/esm2020/lib/modules/popover/popover.module.mjs

@@ -0,0 +1,55 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { SkyAffixModule, SkyOverlayModule } from '@skyux/core';
+import { SkyIconModule } from '@skyux/indicators';
+import { SkyThemeModule } from '@skyux/theme';
+import { SkyPopoversResourcesModule } from '../shared/sky-popovers-resources.module';
+import { SkyPopoverContentComponent } from './popover-content.component';
+import { SkyPopoverComponent } from './popover.component';
+import { SkyPopoverDirective } from './popover.directive';
+import * as i0 from "@angular/core";
+export class SkyPopoverModule {
+}
+SkyPopoverModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoverModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SkyPopoverModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoverModule, declarations: [SkyPopoverComponent,
+        SkyPopoverContentComponent,
+        SkyPopoverDirective], imports: [CommonModule,
+        SkyAffixModule,
+        SkyIconModule,
+        SkyOverlayModule,
+        SkyPopoversResourcesModule,
+        SkyThemeModule], exports: [SkyPopoverComponent,
+        SkyPopoverContentComponent,
+        SkyPopoverDirective] });
+SkyPopoverModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoverModule, imports: [[
+            CommonModule,
+            SkyAffixModule,
+            SkyIconModule,
+            SkyOverlayModule,
+            SkyPopoversResourcesModule,
+            SkyThemeModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoverModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SkyPopoverComponent,
+                        SkyPopoverContentComponent,
+                        SkyPopoverDirective,
+                    ],
+                    imports: [
+                        CommonModule,
+                        SkyAffixModule,
+                        SkyIconModule,
+                        SkyOverlayModule,
+                        SkyPopoversResourcesModule,
+                        SkyThemeModule,
+                    ],
+                    exports: [
+                        SkyPopoverComponent,
+                        SkyPopoverContentComponent,
+                        SkyPopoverDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/popover/types/popover-adapter-arrow-coordinates.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1hZGFwdGVyLWFycm93LWNvb3JkaW5hdGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL3BvcG92ZXJzL3NyYy9saWIvbW9kdWxlcy9wb3BvdmVyL3R5cGVzL3BvcG92ZXItYWRhcHRlci1hcnJvdy1jb29yZGluYXRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTa3lQb3BvdmVyQWRhcHRlckFycm93Q29vcmRpbmF0ZXMge1xuICB0b3A6IG51bWJlcjtcbiAgbGVmdDogbnVtYmVyO1xufVxuIl19

package/esm2020/lib/modules/popover/types/popover-adapter-elements.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1hZGFwdGVyLWVsZW1lbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL3BvcG92ZXJzL3NyYy9saWIvbW9kdWxlcy9wb3BvdmVyL3R5cGVzL3BvcG92ZXItYWRhcHRlci1lbGVtZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRWxlbWVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNreVBvcG92ZXJBZGFwdGVyRWxlbWVudHMge1xuICBwb3BvdmVyOiBFbGVtZW50UmVmO1xuICBwb3BvdmVyQXJyb3c6IEVsZW1lbnRSZWY7XG4gIGNhbGxlcjogRWxlbWVudFJlZjtcbn1cbiJdfQ==

package/esm2020/lib/modules/popover/types/popover-alignment.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1hbGlnbm1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvcG9wb3ZlcnMvc3JjL2xpYi9tb2R1bGVzL3BvcG92ZXIvdHlwZXMvcG9wb3Zlci1hbGlnbm1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUmVwcmVzZW50cyB0aGUgaG9yaXpvbnRhbCBhbGlnbm1lbnQgb2YgdGhlIHBvcG92ZXIgaW4gcmVsYXRpb24gdG8gdGhlIHRyaWdnZXIgZWxlbWVudC5cbiAqL1xuZXhwb3J0IHR5cGUgU2t5UG9wb3ZlckFsaWdubWVudCA9ICdsZWZ0JyB8ICdjZW50ZXInIHwgJ3JpZ2h0JztcbiJdfQ==

package/esm2020/lib/modules/popover/types/popover-message-type.mjs

@@ -0,0 +1,24 @@
+/**
+ * Specifies the type of message to send to the popover component.
+ */
+export var SkyPopoverMessageType;
+(function (SkyPopoverMessageType) {
+    /**
+     * Opens the popover.
+     */
+    SkyPopoverMessageType[SkyPopoverMessageType["Open"] = 0] = "Open";
+    /**
+     * Closes the popover.
+     */
+    SkyPopoverMessageType[SkyPopoverMessageType["Close"] = 1] = "Close";
+    /**
+     * Repositions the popover to the appropriate position.
+     * This is useful for when the popover's width and height change while it is open.
+     */
+    SkyPopoverMessageType[SkyPopoverMessageType["Reposition"] = 2] = "Reposition";
+    /**
+     * Brings focus to the popover element.
+     */
+    SkyPopoverMessageType[SkyPopoverMessageType["Focus"] = 3] = "Focus";
+})(SkyPopoverMessageType || (SkyPopoverMessageType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1tZXNzYWdlLXR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvcG9wb3ZlcnMvc3JjL2xpYi9tb2R1bGVzL3BvcG92ZXIvdHlwZXMvcG9wb3Zlci1tZXNzYWdlLXR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBWSxxQkFxQlg7QUFyQkQsV0FBWSxxQkFBcUI7SUFDL0I7O09BRUc7SUFDSCxpRUFBUSxDQUFBO0lBRVI7O09BRUc7SUFDSCxtRUFBUyxDQUFBO0lBRVQ7OztPQUdHO0lBQ0gsNkVBQWMsQ0FBQTtJQUVkOztPQUVHO0lBQ0gsbUVBQVMsQ0FBQTtBQUNYLENBQUMsRUFyQlcscUJBQXFCLEtBQXJCLHFCQUFxQixRQXFCaEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFNwZWNpZmllcyB0aGUgdHlwZSBvZiBtZXNzYWdlIHRvIHNlbmQgdG8gdGhlIHBvcG92ZXIgY29tcG9uZW50LlxuICovXG5leHBvcnQgZW51bSBTa3lQb3BvdmVyTWVzc2FnZVR5cGUge1xuICAvKipcbiAgICogT3BlbnMgdGhlIHBvcG92ZXIuXG4gICAqL1xuICBPcGVuID0gMCxcblxuICAvKipcbiAgICogQ2xvc2VzIHRoZSBwb3BvdmVyLlxuICAgKi9cbiAgQ2xvc2UgPSAxLFxuXG4gIC8qKlxuICAgKiBSZXBvc2l0aW9ucyB0aGUgcG9wb3ZlciB0byB0aGUgYXBwcm9wcmlhdGUgcG9zaXRpb24uXG4gICAqIFRoaXMgaXMgdXNlZnVsIGZvciB3aGVuIHRoZSBwb3BvdmVyJ3Mgd2lkdGggYW5kIGhlaWdodCBjaGFuZ2Ugd2hpbGUgaXQgaXMgb3Blbi5cbiAgICovXG4gIFJlcG9zaXRpb24gPSAyLFxuXG4gIC8qKlxuICAgKiBCcmluZ3MgZm9jdXMgdG8gdGhlIHBvcG92ZXIgZWxlbWVudC5cbiAgICovXG4gIEZvY3VzID0gMyxcbn1cbiJdfQ==

package/esm2020/lib/modules/popover/types/popover-message.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1tZXNzYWdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL3BvcG92ZXJzL3NyYy9saWIvbW9kdWxlcy9wb3BvdmVyL3R5cGVzL3BvcG92ZXItbWVzc2FnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2t5UG9wb3Zlck1lc3NhZ2VUeXBlIH0gZnJvbSAnLi9wb3BvdmVyLW1lc3NhZ2UtdHlwZSc7XG5cbi8qKlxuICogU3BlY2lmaWVzIG1lc3NhZ2VzIHRvIGJlIHNlbnQgdG8gdGhlIHBvcG92ZXIgY29tcG9uZW50LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNreVBvcG92ZXJNZXNzYWdlIHtcbiAgLyoqXG4gICAqIFRoZSB0eXBlIG9mIG1lc3NhZ2UgdG8gc2VuZC5cbiAgICovXG4gIHR5cGU/OiBTa3lQb3BvdmVyTWVzc2FnZVR5cGU7XG59XG4iXX0=

package/esm2020/lib/modules/popover/types/popover-placement.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1wbGFjZW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvcG9wb3ZlcnMvc3JjL2xpYi9tb2R1bGVzL3BvcG92ZXIvdHlwZXMvcG9wb3Zlci1wbGFjZW1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUmVwcmVzZW50cyB0aGUgcGxhY2VtZW50IG9mIHRoZSBwb3BvdmVyIGluIHJlbGF0aW9uIHRvIHRoZSB0cmlnZ2VyIGVsZW1lbnQuXG4gKi9cbmV4cG9ydCB0eXBlIFNreVBvcG92ZXJQbGFjZW1lbnQgPSAnYWJvdmUnIHwgJ2JlbG93JyB8ICdyaWdodCcgfCAnbGVmdCc7XG4iXX0=

package/esm2020/lib/modules/popover/types/popover-position.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1wb3NpdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9wb3BvdmVycy9zcmMvbGliL21vZHVsZXMvcG9wb3Zlci90eXBlcy9wb3BvdmVyLXBvc2l0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTa3lQb3BvdmVyQWxpZ25tZW50IH0gZnJvbSAnLi9wb3BvdmVyLWFsaWdubWVudCc7XG5pbXBvcnQgeyBTa3lQb3BvdmVyUGxhY2VtZW50IH0gZnJvbSAnLi9wb3BvdmVyLXBsYWNlbWVudCc7XG5cbi8qKlxuICogQGludGVybmFsXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2t5UG9wb3ZlclBvc2l0aW9uIHtcbiAgdG9wPzogbnVtYmVyO1xuICBsZWZ0PzogbnVtYmVyO1xuICBhcnJvd1RvcD86IG51bWJlcjtcbiAgYXJyb3dMZWZ0PzogbnVtYmVyO1xuICBwbGFjZW1lbnQ6IFNreVBvcG92ZXJQbGFjZW1lbnQ7XG4gIGFsaWdubWVudD86IFNreVBvcG92ZXJBbGlnbm1lbnQ7XG59XG4iXX0=

package/esm2020/lib/modules/popover/types/popover-trigger.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci10cmlnZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL3BvcG92ZXJzL3NyYy9saWIvbW9kdWxlcy9wb3BvdmVyL3R5cGVzL3BvcG92ZXItdHJpZ2dlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTcGVjaWZpZXMgdGhlIHVzZXIgYWN0aW9uIHRoYXQgZGlzcGxheXMgdGhlIHBvcG92ZXIuXG4gKi9cbmV4cG9ydCB0eXBlIFNreVBvcG92ZXJUcmlnZ2VyID0gJ2NsaWNrJyB8ICdtb3VzZWVudGVyJztcbiJdfQ==

package/esm2020/lib/modules/shared/sky-popovers-resources.module.mjs

@@ -0,0 +1,47 @@
+/**
+ * NOTICE: DO NOT MODIFY THIS FILE!
+ * The contents of this file were automatically generated by
+ * the 'ng generate @skyux/i18n:lib-resources-module lib/modules/shared/sky-popovers' schematic.
+ * To update this file, simply rerun the command.
+ */
+import { NgModule } from '@angular/core';
+import { SKY_LIB_RESOURCES_PROVIDERS, SkyI18nModule, getLibStringForLocale, } from '@skyux/i18n';
+import * as i0 from "@angular/core";
+const RESOURCES = {
+    'EN-US': {
+        skyux_dropdown_context_menu_default_label: { message: 'Context menu' },
+    },
+};
+export class SkyPopoversResourcesProvider {
+    getString(localeInfo, name) {
+        return getLibStringForLocale(RESOURCES, localeInfo.locale, name);
+    }
+}
+/**
+ * Import into any component library module that needs to use resource strings.
+ */
+export class SkyPopoversResourcesModule {
+}
+SkyPopoversResourcesModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoversResourcesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SkyPopoversResourcesModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoversResourcesModule, exports: [SkyI18nModule] });
+SkyPopoversResourcesModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoversResourcesModule, providers: [
+        {
+            provide: SKY_LIB_RESOURCES_PROVIDERS,
+            useClass: SkyPopoversResourcesProvider,
+            multi: true,
+        },
+    ], imports: [SkyI18nModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyPopoversResourcesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [SkyI18nModule],
+                    providers: [
+                        {
+                            provide: SKY_LIB_RESOURCES_PROVIDERS,
+                            useClass: SkyPopoversResourcesProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/skyux-popovers.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2t5dXgtcG9wb3ZlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvcG9wb3ZlcnMvc3JjL3NreXV4LXBvcG92ZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19