@radix-ng/primitives 0.18.2 → 0.20.0

package/esm2022/popover/src/popover-arrow.directive.mjs

@@ -0,0 +1,112 @@
+import { computed, Directive, effect, ElementRef, forwardRef, inject, input, Renderer2, signal, untracked } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { RdxPopoverArrowToken } from './popover-arrow.token';
+import { injectPopoverRoot } from './popover-root.inject';
+import { getArrowPositionParams, getSideAndAlignFromAllPossibleConnectedPositions } from './popover.utils';
+import * as i0 from "@angular/core";
+export class RdxPopoverArrowDirective {
+    constructor() {
+        /** @ignore */
+        this.renderer = inject(Renderer2);
+        /** @ignore */
+        this.popoverRoot = injectPopoverRoot();
+        /** @ignore */
+        this.elementRef = inject(ElementRef);
+        /**
+         * The width of the arrow in pixels.
+         */
+        this.width = input(10);
+        /**
+         * The height of the arrow in pixels.
+         */
+        this.height = input(5);
+        /** @ignore */
+        this.arrowSvgElement = computed(() => {
+            const width = this.width();
+            const height = this.height();
+            const svgElement = this.renderer.createElement('svg', 'svg');
+            this.renderer.setAttribute(svgElement, 'viewBox', '0 0 30 10');
+            this.renderer.setAttribute(svgElement, 'width', String(width));
+            this.renderer.setAttribute(svgElement, 'height', String(height));
+            const polygonElement = this.renderer.createElement('polygon', 'svg');
+            this.renderer.setAttribute(polygonElement, 'points', '0,0 30,0 15,10');
+            this.renderer.setAttribute(svgElement, 'preserveAspectRatio', 'none');
+            this.renderer.appendChild(svgElement, polygonElement);
+            return svgElement;
+        });
+        /** @ignore */
+        this.currentArrowSvgElement = signal(void 0);
+        /** @ignore */
+        this.position = toSignal(this.popoverRoot.popoverContentDirective().positionChange());
+        this.onArrowSvgElementChangeEffect();
+        this.onContentPositionChangeEffect();
+    }
+    /** @ignore */
+    ngAfterViewInit() {
+        if (this.elementRef.nativeElement.parentElement) {
+            this.renderer.setStyle(this.elementRef.nativeElement.parentElement, 'position', 'relative');
+        }
+        this.renderer.setStyle(this.elementRef.nativeElement, 'position', 'absolute');
+        this.renderer.setStyle(this.elementRef.nativeElement, 'boxSizing', '');
+        this.renderer.setStyle(this.elementRef.nativeElement, 'fontSize', '0px');
+        this.triggerRect = this.popoverRoot.popoverTriggerDirective().elementRef.nativeElement.getBoundingClientRect();
+    }
+    /** @ignore */
+    setPosition(position) {
+        const posParams = getArrowPositionParams(getSideAndAlignFromAllPossibleConnectedPositions(position.connectionPair), { width: this.width(), height: this.height() }, { width: this.triggerRect.width, height: this.triggerRect.height });
+        this.renderer.setStyle(this.elementRef.nativeElement, 'top', posParams.top);
+        this.renderer.setStyle(this.elementRef.nativeElement, 'bottom', posParams.bottom);
+        this.renderer.setStyle(this.elementRef.nativeElement, 'left', posParams.left);
+        this.renderer.setStyle(this.elementRef.nativeElement, 'right', posParams.right);
+        this.renderer.setStyle(this.elementRef.nativeElement, 'transform', posParams.transform);
+    }
+    /** @ignore */
+    onArrowSvgElementChangeEffect() {
+        effect(() => {
+            const arrowElement = this.arrowSvgElement();
+            untracked(() => {
+                const currentArrowSvgElement = this.currentArrowSvgElement();
+                if (currentArrowSvgElement) {
+                    this.renderer.removeChild(this.elementRef.nativeElement, currentArrowSvgElement);
+                }
+                this.currentArrowSvgElement.set(arrowElement);
+                this.renderer.setStyle(this.elementRef.nativeElement, 'width', `${this.width()}px`);
+                this.renderer.setStyle(this.elementRef.nativeElement, 'height', `${this.height()}px`);
+                this.renderer.appendChild(this.elementRef.nativeElement, this.currentArrowSvgElement());
+            });
+        });
+    }
+    /** @ignore */
+    onContentPositionChangeEffect() {
+        effect(() => {
+            const position = this.position();
+            untracked(() => {
+                if (!position) {
+                    return;
+                }
+                this.setPosition(position);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxPopoverArrowDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.11", type: RdxPopoverArrowDirective, isStandalone: true, selector: "[rdxPopoverArrow]", inputs: { width: { classPropertyName: "width", publicName: "width", isSignal: true, isRequired: false, transformFunction: null }, height: { classPropertyName: "height", publicName: "height", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: RdxPopoverArrowToken,
+                useExisting: forwardRef(() => RdxPopoverArrowDirective)
+            }
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxPopoverArrowDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxPopoverArrow]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: RdxPopoverArrowToken,
+                            useExisting: forwardRef(() => RdxPopoverArrowDirective)
+                        }
+                    ]
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover-arrow.directive.js","sourceRoot":"","sources":["../../../../../packages/primitives/popover/src/popover-arrow.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { ConnectedOverlayPositionChange } from '@angular/cdk/overlay';\nimport {\n    AfterViewInit,\n    computed,\n    Directive,\n    effect,\n    ElementRef,\n    forwardRef,\n    inject,\n    input,\n    Renderer2,\n    signal,\n    untracked\n} from '@angular/core';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport { RdxPopoverArrowToken } from './popover-arrow.token';\nimport { injectPopoverRoot } from './popover-root.inject';\nimport { getArrowPositionParams, getSideAndAlignFromAllPossibleConnectedPositions } from './popover.utils';\n\n@Directive({\n    selector: '[rdxPopoverArrow]',\n    standalone: true,\n    providers: [\n        {\n            provide: RdxPopoverArrowToken,\n            useExisting: forwardRef(() => RdxPopoverArrowDirective)\n        }\n    ]\n})\nexport class RdxPopoverArrowDirective implements AfterViewInit {\n    /** @ignore */\n    private readonly renderer = inject(Renderer2);\n    /** @ignore */\n    private readonly popoverRoot = injectPopoverRoot();\n    /** @ignore */\n    private readonly elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n\n    /**\n     * The width of the arrow in pixels.\n     */\n    readonly width = input<number>(10);\n\n    /**\n     * The height of the arrow in pixels.\n     */\n    readonly height = input<number>(5);\n\n    /** @ignore */\n    readonly arrowSvgElement = computed<HTMLElement>(() => {\n        const width = this.width();\n        const height = this.height();\n\n        const svgElement = this.renderer.createElement('svg', 'svg');\n        this.renderer.setAttribute(svgElement, 'viewBox', '0 0 30 10');\n        this.renderer.setAttribute(svgElement, 'width', String(width));\n        this.renderer.setAttribute(svgElement, 'height', String(height));\n        const polygonElement = this.renderer.createElement('polygon', 'svg');\n        this.renderer.setAttribute(polygonElement, 'points', '0,0 30,0 15,10');\n        this.renderer.setAttribute(svgElement, 'preserveAspectRatio', 'none');\n        this.renderer.appendChild(svgElement, polygonElement);\n\n        return svgElement;\n    });\n\n    /** @ignore */\n    private readonly currentArrowSvgElement = signal<HTMLOrSVGElement | undefined>(void 0);\n    /** @ignore */\n    private readonly position = toSignal(this.popoverRoot.popoverContentDirective().positionChange());\n\n    /** @ignore */\n    private triggerRect: DOMRect;\n\n    constructor() {\n        this.onArrowSvgElementChangeEffect();\n        this.onContentPositionChangeEffect();\n    }\n\n    /** @ignore */\n    ngAfterViewInit() {\n        if (this.elementRef.nativeElement.parentElement) {\n            this.renderer.setStyle(this.elementRef.nativeElement.parentElement, 'position', 'relative');\n        }\n        this.renderer.setStyle(this.elementRef.nativeElement, 'position', 'absolute');\n        this.renderer.setStyle(this.elementRef.nativeElement, 'boxSizing', '');\n        this.renderer.setStyle(this.elementRef.nativeElement, 'fontSize', '0px');\n        this.triggerRect = this.popoverRoot.popoverTriggerDirective().elementRef.nativeElement.getBoundingClientRect();\n    }\n\n    /** @ignore */\n    private setPosition(position: ConnectedOverlayPositionChange) {\n        const posParams = getArrowPositionParams(\n            getSideAndAlignFromAllPossibleConnectedPositions(position.connectionPair),\n            { width: this.width(), height: this.height() },\n            { width: this.triggerRect.width, height: this.triggerRect.height }\n        );\n\n        this.renderer.setStyle(this.elementRef.nativeElement, 'top', posParams.top);\n        this.renderer.setStyle(this.elementRef.nativeElement, 'bottom', posParams.bottom);\n        this.renderer.setStyle(this.elementRef.nativeElement, 'left', posParams.left);\n        this.renderer.setStyle(this.elementRef.nativeElement, 'right', posParams.right);\n        this.renderer.setStyle(this.elementRef.nativeElement, 'transform', posParams.transform);\n    }\n\n    /** @ignore */\n    private onArrowSvgElementChangeEffect() {\n        effect(() => {\n            const arrowElement = this.arrowSvgElement();\n            untracked(() => {\n                const currentArrowSvgElement = this.currentArrowSvgElement();\n                if (currentArrowSvgElement) {\n                    this.renderer.removeChild(this.elementRef.nativeElement, currentArrowSvgElement);\n                }\n                this.currentArrowSvgElement.set(arrowElement);\n                this.renderer.setStyle(this.elementRef.nativeElement, 'width', `${this.width()}px`);\n                this.renderer.setStyle(this.elementRef.nativeElement, 'height', `${this.height()}px`);\n                this.renderer.appendChild(this.elementRef.nativeElement, this.currentArrowSvgElement());\n            });\n        });\n    }\n\n    /** @ignore */\n    private onContentPositionChangeEffect() {\n        effect(() => {\n            const position = this.position();\n            untracked(() => {\n                if (!position) {\n                    return;\n                }\n                this.setPosition(position);\n            });\n        });\n    }\n}\n"]}

package/esm2022/popover/src/popover-arrow.token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const RdxPopoverArrowToken = new InjectionToken('RdxPopoverArrowToken');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1hcnJvdy50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3ByaW1pdGl2ZXMvcG9wb3Zlci9zcmMvcG9wb3Zlci1hcnJvdy50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRy9DLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLElBQUksY0FBYyxDQUEyQixzQkFBc0IsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJkeFBvcG92ZXJBcnJvd0RpcmVjdGl2ZSB9IGZyb20gJy4vcG9wb3Zlci1hcnJvdy5kaXJlY3RpdmUnO1xuXG5leHBvcnQgY29uc3QgUmR4UG9wb3ZlckFycm93VG9rZW4gPSBuZXcgSW5qZWN0aW9uVG9rZW48UmR4UG9wb3ZlckFycm93RGlyZWN0aXZlPignUmR4UG9wb3ZlckFycm93VG9rZW4nKTtcbiJdfQ==

package/esm2022/popover/src/popover-close.directive.mjs

@@ -0,0 +1,37 @@
+import { Directive, effect, ElementRef, inject, Renderer2, untracked } from '@angular/core';
+import { injectPopoverRoot } from './popover-root.inject';
+import * as i0 from "@angular/core";
+export class RdxPopoverCloseDirective {
+    constructor() {
+        /** @ignore */
+        this.popoverRoot = injectPopoverRoot();
+        /** @ignore */
+        this.elementRef = inject((ElementRef));
+        /** @ignore */
+        this.renderer = inject(Renderer2);
+        this.onIsControlledExternallyEffect();
+    }
+    /** @ignore */
+    onIsControlledExternallyEffect() {
+        effect(() => {
+            const isControlledExternally = this.popoverRoot.controlledExternally()();
+            untracked(() => {
+                this.renderer.setStyle(this.elementRef.nativeElement, 'display', isControlledExternally ? 'none' : null);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxPopoverCloseDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.11", type: RdxPopoverCloseDirective, isStandalone: true, selector: "[rdxPopoverClose]", host: { attributes: { "type": "button" }, listeners: { "click": "popoverRoot.handleClose()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxPopoverCloseDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxPopoverClose]',
+                    standalone: true,
+                    host: {
+                        type: 'button',
+                        '(click)': 'popoverRoot.handleClose()'
+                    }
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/popover/src/popover-content.directive.mjs

@@ -0,0 +1,227 @@
+import { CdkConnectedOverlay, Overlay } from '@angular/cdk/overlay';
+import { computed, DestroyRef, Directive, effect, inject, input, output, SimpleChange, TemplateRef, untracked } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { filter, tap } from 'rxjs';
+import { injectPopoverRoot } from './popover-root.inject';
+import { DEFAULTS } from './popover.constants';
+import { RdxPopoverAlign, RdxPopoverSide } from './popover.types';
+import { getAllPossibleConnectedPositions, getContentPosition } from './popover.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export class RdxPopoverContentDirective {
+    constructor() {
+        /** @ignore */
+        this.popoverRoot = injectPopoverRoot();
+        /** @ignore */
+        this.templateRef = inject(TemplateRef);
+        /** @ignore */
+        this.overlay = inject(Overlay);
+        /** @ignore */
+        this.destroyRef = inject(DestroyRef);
+        /** @ignore */
+        this.connectedOverlay = inject(CdkConnectedOverlay);
+        /**
+         * The preferred side of the trigger to render against when open. Will be reversed when collisions occur and avoidCollisions is enabled.
+         */
+        this.side = input(RdxPopoverSide.Top);
+        /**
+         * The distance in pixels from the trigger.
+         */
+        this.sideOffset = input(void 0);
+        /**
+         * The preferred alignment against the trigger. May change when collisions occur.
+         */
+        this.align = input(RdxPopoverAlign.Center);
+        /**
+         * An offset in pixels from the "start" or "end" alignment options.
+         */
+        this.alignOffset = input(void 0);
+        /**
+         * Whether to add some alternate positions of the content.
+         */
+        this.disableAlternatePositions = input(false);
+        /** @ingore */
+        this.positions = computed(() => {
+            const greatestDimensionFromTheArrow = Math.max(this.popoverRoot.popoverArrowDirective()?.width() ?? 0, this.popoverRoot.popoverArrowDirective()?.height() ?? 0);
+            const offsets = {
+                sideOffset: this.sideOffset() ?? (greatestDimensionFromTheArrow || DEFAULTS.offsets.side),
+                alignOffset: this.alignOffset() ?? (greatestDimensionFromTheArrow || DEFAULTS.offsets.align)
+            };
+            const basePosition = getContentPosition({
+                side: this.side(),
+                align: this.align(),
+                sideOffset: offsets.sideOffset,
+                alignOffset: offsets.alignOffset
+            });
+            const positions = [basePosition];
+            if (!this.disableAlternatePositions()) {
+                /**
+                 * Alternate positions for better user experience along the X/Y axis (e.g. vertical/horizontal scrolling)
+                 */
+                const allPossibleConnectedPositions = getAllPossibleConnectedPositions();
+                allPossibleConnectedPositions.forEach((value, key) => {
+                    const sideAndAlignArray = key.split('|');
+                    if (sideAndAlignArray[0] !== this.side() ||
+                        sideAndAlignArray[1] !== this.align()) {
+                        positions.push(getContentPosition({
+                            side: sideAndAlignArray[0],
+                            align: sideAndAlignArray[1],
+                            sideOffset: offsets.sideOffset,
+                            alignOffset: offsets.alignOffset
+                        }));
+                    }
+                });
+            }
+            return positions;
+        });
+        /**
+         * Event handler called when the escape key is down. It can be prevented by calling event.preventDefault.
+         */
+        this.onEscapeKeyDown = output();
+        /**
+         * Event handler called when a pointer event occurs outside the bounds of the component. It can be prevented by calling event.preventDefault.
+         */
+        this.onPointerDownOutside = output();
+        /**
+         * Event handler called when the overlay is atached
+         */
+        this.onShow = output();
+        /**
+         * Event handler called when the overlay is detached
+         */
+        this.onHide = output();
+        this.onPositionChangeEffect();
+        this.onControlledExternallyChangeEffect();
+    }
+    /** @ignore */
+    ngOnInit() {
+        this.setOrigin();
+        this.setScrollStrategy();
+        this.onAttach();
+        this.onDetach();
+        this.connectKeydownEscape();
+        this.connectOutsideClick();
+    }
+    /** @ignore */
+    show() {
+        const prevOpen = this.connectedOverlay.open;
+        this.connectedOverlay.open = true;
+        if (!prevOpen) {
+            this.connectedOverlay.ngOnChanges({ open: new SimpleChange(prevOpen, true, false) });
+        }
+    }
+    /** @ignore */
+    hide() {
+        const prevOpen = this.connectedOverlay.open;
+        this.connectedOverlay.open = false;
+        if (prevOpen) {
+            this.connectedOverlay.ngOnChanges({ open: new SimpleChange(prevOpen, false, false) });
+        }
+    }
+    /** @ignore */
+    positionChange() {
+        return this.connectedOverlay.positionChange.asObservable();
+    }
+    /** @ignore */
+    connectKeydownEscape() {
+        this.connectedOverlay.overlayKeydown
+            .asObservable()
+            .pipe(filter((event) => event.key === 'Escape'), tap((event) => {
+            this.onEscapeKeyDown.emit(event);
+            if (!event.defaultPrevented) {
+                this.popoverRoot.handleClose();
+            }
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
+    }
+    /** @ignore */
+    connectOutsideClick() {
+        this.connectedOverlay.overlayOutsideClick
+            .asObservable()
+            .pipe(tap((event) => {
+            this.onPointerDownOutside.emit(event);
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
+    }
+    /** @ignore */
+    onAttach() {
+        this.connectedOverlay.attach
+            .asObservable()
+            .pipe(tap(() => {
+            this.onShow.emit();
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
+    }
+    /** @ignore */
+    onDetach() {
+        this.connectedOverlay.detach
+            .asObservable()
+            .pipe(tap(() => {
+            this.onHide.emit();
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
+    }
+    /** @ignore */
+    setScrollStrategy() {
+        const prevScrollStrategy = this.connectedOverlay.scrollStrategy;
+        this.connectedOverlay.scrollStrategy = this.overlay.scrollStrategies.reposition();
+        this.connectedOverlay.ngOnChanges({
+            scrollStrategy: new SimpleChange(prevScrollStrategy, this.connectedOverlay.scrollStrategy, false)
+        });
+    }
+    /** @ignore */
+    setDisableClose() {
+        const prevDisableClose = this.connectedOverlay.disableClose;
+        this.connectedOverlay.disableClose = this.popoverRoot.controlledExternally()();
+        this.connectedOverlay.ngOnChanges({
+            disableClose: new SimpleChange(prevDisableClose, this.connectedOverlay.disableClose, false)
+        });
+    }
+    /** @ignore */
+    setOrigin() {
+        const prevOrigin = this.connectedOverlay.origin;
+        this.connectedOverlay.origin = this.popoverRoot.popoverTriggerDirective().overlayOrigin;
+        this.connectedOverlay.ngOnChanges({
+            origin: new SimpleChange(prevOrigin, this.connectedOverlay.origin, false)
+        });
+    }
+    /** @ignore */
+    onPositionChangeEffect() {
+        effect(() => {
+            const positions = this.positions();
+            this.disableAlternatePositions();
+            untracked(() => {
+                const prevPositions = this.connectedOverlay.positions;
+                this.connectedOverlay.positions = positions;
+                this.connectedOverlay.ngOnChanges({
+                    positions: new SimpleChange(prevPositions, this.connectedOverlay.positions, false)
+                });
+                this.connectedOverlay.overlayRef?.updatePosition();
+            });
+        });
+    }
+    /** @ignore */
+    onControlledExternallyChangeEffect() {
+        effect(() => {
+            this.popoverRoot.controlledExternally()();
+            untracked(() => {
+                this.setDisableClose();
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxPopoverContentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.11", type: RdxPopoverContentDirective, isStandalone: true, selector: "[rdxPopoverContent]", inputs: { side: { classPropertyName: "side", publicName: "side", isSignal: true, isRequired: false, transformFunction: null }, sideOffset: { classPropertyName: "sideOffset", publicName: "sideOffset", isSignal: true, isRequired: false, transformFunction: null }, align: { classPropertyName: "align", publicName: "align", isSignal: true, isRequired: false, transformFunction: null }, alignOffset: { classPropertyName: "alignOffset", publicName: "alignOffset", isSignal: true, isRequired: false, transformFunction: null }, disableAlternatePositions: { classPropertyName: "disableAlternatePositions", publicName: "disableAlternatePositions", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onEscapeKeyDown: "onEscapeKeyDown", onPointerDownOutside: "onPointerDownOutside", onShow: "onShow", onHide: "onHide" }, hostDirectives: [{ directive: i1.CdkConnectedOverlay }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxPopoverContentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxPopoverContent]',
+                    standalone: true,
+                    hostDirectives: [
+                        {
+                            directive: CdkConnectedOverlay
+                        }
+                    ]
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover-content.directive.js","sourceRoot":"","sources":["../../../../../packages/primitives/popover/src/popover-content.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkConnectedOverlay, Overlay } from '@angular/cdk/overlay';\nimport {\n    computed,\n    DestroyRef,\n    Directive,\n    effect,\n    inject,\n    input,\n    OnInit,\n    output,\n    SimpleChange,\n    TemplateRef,\n    untracked\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { filter, tap } from 'rxjs';\nimport { injectPopoverRoot } from './popover-root.inject';\nimport { DEFAULTS } from './popover.constants';\nimport { RdxPopoverAlign, RdxPopoverSide, RdxSideAndAlignOffsets } from './popover.types';\nimport { getAllPossibleConnectedPositions, getContentPosition } from './popover.utils';\n\n@Directive({\n    selector: '[rdxPopoverContent]',\n    standalone: true,\n    hostDirectives: [\n        {\n            directive: CdkConnectedOverlay\n        }\n    ]\n})\nexport class RdxPopoverContentDirective implements OnInit {\n    /** @ignore */\n    readonly popoverRoot = injectPopoverRoot();\n    /** @ignore */\n    readonly templateRef = inject(TemplateRef);\n    /** @ignore */\n    readonly overlay = inject(Overlay);\n    /** @ignore */\n    readonly destroyRef = inject(DestroyRef);\n    /** @ignore */\n    private readonly connectedOverlay = inject(CdkConnectedOverlay);\n\n    /**\n     * The preferred side of the trigger to render against when open. Will be reversed when collisions occur and avoidCollisions is enabled.\n     */\n    readonly side = input<RdxPopoverSide>(RdxPopoverSide.Top);\n    /**\n     * The distance in pixels from the trigger.\n     */\n    readonly sideOffset = input<number | undefined>(void 0);\n\n    /**\n     * The preferred alignment against the trigger. May change when collisions occur.\n     */\n    readonly align = input<RdxPopoverAlign>(RdxPopoverAlign.Center);\n    /**\n     * An offset in pixels from the \"start\" or \"end\" alignment options.\n     */\n    readonly alignOffset = input<number | undefined>(void 0);\n\n    /**\n     * Whether to add some alternate positions of the content.\n     */\n    readonly disableAlternatePositions = input(false);\n\n    /** @ingore */\n    readonly positions = computed(() => {\n        const greatestDimensionFromTheArrow = Math.max(\n            this.popoverRoot.popoverArrowDirective()?.width() ?? 0,\n            this.popoverRoot.popoverArrowDirective()?.height() ?? 0\n        );\n        const offsets: RdxSideAndAlignOffsets = {\n            sideOffset: this.sideOffset() ?? (greatestDimensionFromTheArrow || DEFAULTS.offsets.side),\n            alignOffset: this.alignOffset() ?? (greatestDimensionFromTheArrow || DEFAULTS.offsets.align)\n        };\n        const basePosition = getContentPosition({\n            side: this.side(),\n            align: this.align(),\n            sideOffset: offsets.sideOffset,\n            alignOffset: offsets.alignOffset\n        });\n        const positions = [basePosition];\n        if (!this.disableAlternatePositions()) {\n            /**\n             * Alternate positions for better user experience along the X/Y axis (e.g. vertical/horizontal scrolling)\n             */\n            const allPossibleConnectedPositions = getAllPossibleConnectedPositions();\n            allPossibleConnectedPositions.forEach((value, key) => {\n                const sideAndAlignArray = key.split('|');\n                if (\n                    (sideAndAlignArray[0] as RdxPopoverSide) !== this.side() ||\n                    (sideAndAlignArray[1] as RdxPopoverAlign) !== this.align()\n                ) {\n                    positions.push(\n                        getContentPosition({\n                            side: sideAndAlignArray[0] as RdxPopoverSide,\n                            align: sideAndAlignArray[1] as RdxPopoverAlign,\n                            sideOffset: offsets.sideOffset,\n                            alignOffset: offsets.alignOffset\n                        })\n                    );\n                }\n            });\n        }\n        return positions;\n    });\n\n    /**\n     * Event handler called when the escape key is down. It can be prevented by calling event.preventDefault.\n     */\n    readonly onEscapeKeyDown = output<KeyboardEvent>();\n\n    /**\n     * Event handler called when a pointer event occurs outside the bounds of the component. It can be prevented by calling event.preventDefault.\n     */\n    readonly onPointerDownOutside = output<MouseEvent>();\n\n    /**\n     * Event handler called when the overlay is atached\n     */\n    readonly onShow = output<void>();\n    /**\n     * Event handler called when the overlay is detached\n     */\n    readonly onHide = output<void>();\n\n    constructor() {\n        this.onPositionChangeEffect();\n        this.onControlledExternallyChangeEffect();\n    }\n\n    /** @ignore */\n    ngOnInit() {\n        this.setOrigin();\n        this.setScrollStrategy();\n        this.onAttach();\n        this.onDetach();\n        this.connectKeydownEscape();\n        this.connectOutsideClick();\n    }\n\n    /** @ignore */\n    show() {\n        const prevOpen = this.connectedOverlay.open;\n        this.connectedOverlay.open = true;\n        if (!prevOpen) {\n            this.connectedOverlay.ngOnChanges({ open: new SimpleChange(prevOpen, true, false) });\n        }\n    }\n\n    /** @ignore */\n    hide() {\n        const prevOpen = this.connectedOverlay.open;\n        this.connectedOverlay.open = false;\n        if (prevOpen) {\n            this.connectedOverlay.ngOnChanges({ open: new SimpleChange(prevOpen, false, false) });\n        }\n    }\n\n    /** @ignore */\n    positionChange() {\n        return this.connectedOverlay.positionChange.asObservable();\n    }\n\n    /** @ignore */\n    private connectKeydownEscape() {\n        this.connectedOverlay.overlayKeydown\n            .asObservable()\n            .pipe(\n                filter((event) => event.key === 'Escape'),\n                tap((event) => {\n                    this.onEscapeKeyDown.emit(event);\n                    if (!event.defaultPrevented) {\n                        this.popoverRoot.handleClose();\n                    }\n                }),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe();\n    }\n\n    /** @ignore */\n    private connectOutsideClick() {\n        this.connectedOverlay.overlayOutsideClick\n            .asObservable()\n            .pipe(\n                tap((event) => {\n                    this.onPointerDownOutside.emit(event);\n                }),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe();\n    }\n\n    /** @ignore */\n    private onAttach() {\n        this.connectedOverlay.attach\n            .asObservable()\n            .pipe(\n                tap(() => {\n                    this.onShow.emit();\n                }),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe();\n    }\n\n    /** @ignore */\n    private onDetach() {\n        this.connectedOverlay.detach\n            .asObservable()\n            .pipe(\n                tap(() => {\n                    this.onHide.emit();\n                }),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe();\n    }\n\n    /** @ignore */\n    private setScrollStrategy() {\n        const prevScrollStrategy = this.connectedOverlay.scrollStrategy;\n        this.connectedOverlay.scrollStrategy = this.overlay.scrollStrategies.reposition();\n        this.connectedOverlay.ngOnChanges({\n            scrollStrategy: new SimpleChange(prevScrollStrategy, this.connectedOverlay.scrollStrategy, false)\n        });\n    }\n\n    /** @ignore */\n    private setDisableClose() {\n        const prevDisableClose = this.connectedOverlay.disableClose;\n        this.connectedOverlay.disableClose = this.popoverRoot.controlledExternally()();\n        this.connectedOverlay.ngOnChanges({\n            disableClose: new SimpleChange(prevDisableClose, this.connectedOverlay.disableClose, false)\n        });\n    }\n\n    /** @ignore */\n    private setOrigin() {\n        const prevOrigin = this.connectedOverlay.origin;\n        this.connectedOverlay.origin = this.popoverRoot.popoverTriggerDirective().overlayOrigin;\n        this.connectedOverlay.ngOnChanges({\n            origin: new SimpleChange(prevOrigin, this.connectedOverlay.origin, false)\n        });\n    }\n\n    /** @ignore */\n    private onPositionChangeEffect() {\n        effect(() => {\n            const positions = this.positions();\n            this.disableAlternatePositions();\n            untracked(() => {\n                const prevPositions = this.connectedOverlay.positions;\n                this.connectedOverlay.positions = positions;\n                this.connectedOverlay.ngOnChanges({\n                    positions: new SimpleChange(prevPositions, this.connectedOverlay.positions, false)\n                });\n                this.connectedOverlay.overlayRef?.updatePosition();\n            });\n        });\n    }\n\n    /** @ignore */\n    private onControlledExternallyChangeEffect() {\n        effect(() => {\n            this.popoverRoot.controlledExternally()();\n            untracked(() => {\n                this.setDisableClose();\n            });\n        });\n    }\n}\n"]}

package/esm2022/popover/src/popover-root.directive.mjs

@@ -0,0 +1,142 @@
+import { DOCUMENT } from '@angular/common';
+import { computed, contentChild, Directive, effect, forwardRef, inject, input, output, signal, untracked, ViewContainerRef } from '@angular/core';
+import { RdxPopoverArrowToken } from './popover-arrow.token';
+import { RdxPopoverContentDirective } from './popover-content.directive';
+import { RdxPopoverRootToken } from './popover-root.token';
+import { RdxPopoverTriggerDirective } from './popover-trigger.directive';
+import * as i0 from "@angular/core";
+export class RdxPopoverRootDirective {
+    constructor() {
+        /**
+         * The open state of the popover when it is initially rendered. Use when you do not need to control its open state.
+         */
+        this.defaultOpen = input(false);
+        /**
+         * The controlled open state of the popover. Must be used in conjunction with onOpenChange.
+         */
+        this.open = input();
+        /**
+         * Event handler called when the open state of the popover changes.
+         */
+        this.onOpenChange = output();
+        /** @ignore */
+        this.popoverContentDirective = contentChild.required(RdxPopoverContentDirective);
+        /** @ignore */
+        this.popoverTriggerDirective = contentChild.required(RdxPopoverTriggerDirective);
+        /** @ignore */
+        this.popoverArrowDirective = contentChild(RdxPopoverArrowToken);
+        /** @ignore */
+        this.viewContainerRef = inject(ViewContainerRef);
+        /** @ignore */
+        this.document = inject(DOCUMENT);
+        /** @ignore */
+        this.isOpen = signal(this.defaultOpen());
+        /** @ignore */
+        this.state = computed(() => {
+            const currentIsOpen = this.isOpen();
+            if (currentIsOpen) {
+                return 'open';
+            }
+            return 'closed';
+        });
+        /** @ignore */
+        this.isControlledExternally = computed(() => signal(this.open() !== void 0));
+        this.onOpenChangeEffect();
+        this.onIsOpenChangeEffect();
+    }
+    /** @ignore */
+    ngOnInit() {
+        if (this.defaultOpen()) {
+            this.handleOpen();
+        }
+    }
+    /** @ignore */
+    controlledExternally() {
+        return this.isControlledExternally().asReadonly();
+    }
+    /** @ignore */
+    handleOpen() {
+        if (this.isControlledExternally()()) {
+            return;
+        }
+        this.setOpen(true);
+    }
+    /** @ignore */
+    handleClose() {
+        if (this.isControlledExternally()()) {
+            return;
+        }
+        this.setOpen(false);
+    }
+    /** @ignore */
+    handleToggle() {
+        if (this.isControlledExternally()()) {
+            return;
+        }
+        this.isOpen() ? this.handleClose() : this.handleOpen();
+    }
+    /** @ignore */
+    setOpen(open = false) {
+        if (open) {
+            this.document.dispatchEvent(new CustomEvent('popover.open'));
+        }
+        this.isOpen.set(open);
+        this.onOpenChange.emit(open);
+    }
+    /** @ignore */
+    show() {
+        this.popoverContentDirective().show();
+    }
+    /** @ignore */
+    hide() {
+        this.popoverContentDirective().hide();
+    }
+    /** @ignore */
+    onIsOpenChangeEffect() {
+        effect(() => {
+            const isOpen = this.isOpen();
+            untracked(() => {
+                if (isOpen) {
+                    this.show();
+                }
+                else {
+                    this.hide();
+                }
+            });
+        });
+    }
+    /** @ignore */
+    onOpenChangeEffect() {
+        effect(() => {
+            const currentOpen = this.open();
+            untracked(() => {
+                this.isControlledExternally().set(currentOpen !== void 0);
+                if (this.isControlledExternally()()) {
+                    this.setOpen(currentOpen);
+                }
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxPopoverRootDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "18.2.11", type: RdxPopoverRootDirective, isStandalone: true, selector: "[rdxPopoverRoot]", inputs: { defaultOpen: { classPropertyName: "defaultOpen", publicName: "defaultOpen", isSignal: true, isRequired: false, transformFunction: null }, open: { classPropertyName: "open", publicName: "open", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onOpenChange: "onOpenChange" }, providers: [
+            {
+                provide: RdxPopoverRootToken,
+                useExisting: forwardRef(() => RdxPopoverRootDirective)
+            }
+        ], queries: [{ propertyName: "popoverContentDirective", first: true, predicate: RdxPopoverContentDirective, descendants: true, isSignal: true }, { propertyName: "popoverTriggerDirective", first: true, predicate: RdxPopoverTriggerDirective, descendants: true, isSignal: true }, { propertyName: "popoverArrowDirective", first: true, predicate: RdxPopoverArrowToken, descendants: true, isSignal: true }], exportAs: ["rdxPopoverRoot"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxPopoverRootDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxPopoverRoot]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: RdxPopoverRootToken,
+                            useExisting: forwardRef(() => RdxPopoverRootDirective)
+                        }
+                    ],
+                    exportAs: 'rdxPopoverRoot'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover-root.directive.js","sourceRoot":"","sources":["../../../../../packages/primitives/popover/src/popover-root.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n    computed,\n    contentChild,\n    Directive,\n    effect,\n    forwardRef,\n    inject,\n    input,\n    OnInit,\n    output,\n    signal,\n    untracked,\n    ViewContainerRef\n} from '@angular/core';\nimport { RdxPopoverArrowToken } from './popover-arrow.token';\nimport { RdxPopoverContentDirective } from './popover-content.directive';\nimport { RdxPopoverRootToken } from './popover-root.token';\nimport { RdxPopoverTriggerDirective } from './popover-trigger.directive';\nimport { RdxPopoverState } from './popover.types';\n\n@Directive({\n    selector: '[rdxPopoverRoot]',\n    standalone: true,\n    providers: [\n        {\n            provide: RdxPopoverRootToken,\n            useExisting: forwardRef(() => RdxPopoverRootDirective)\n        }\n    ],\n    exportAs: 'rdxPopoverRoot'\n})\nexport class RdxPopoverRootDirective implements OnInit {\n    /**\n     * The open state of the popover when it is initially rendered. Use when you do not need to control its open state.\n     */\n    readonly defaultOpen = input<boolean>(false);\n    /**\n     * The controlled open state of the popover. Must be used in conjunction with onOpenChange.\n     */\n    readonly open = input<boolean | undefined>();\n\n    /**\n     * Event handler called when the open state of the popover changes.\n     */\n    readonly onOpenChange = output<boolean>();\n\n    /** @ignore */\n    readonly popoverContentDirective = contentChild.required(RdxPopoverContentDirective);\n    /** @ignore */\n    readonly popoverTriggerDirective = contentChild.required(RdxPopoverTriggerDirective);\n    /** @ignore */\n    readonly popoverArrowDirective = contentChild(RdxPopoverArrowToken);\n\n    /** @ignore */\n    readonly viewContainerRef = inject(ViewContainerRef);\n    /** @ignore */\n    private readonly document = inject(DOCUMENT);\n\n    /** @ignore */\n    readonly isOpen = signal<boolean>(this.defaultOpen());\n    /** @ignore */\n    readonly state = computed<RdxPopoverState>(() => {\n        const currentIsOpen = this.isOpen();\n        if (currentIsOpen) {\n            return 'open';\n        }\n        return 'closed';\n    });\n\n    /** @ignore */\n    private isControlledExternally = computed(() => signal(this.open() !== void 0));\n\n    constructor() {\n        this.onOpenChangeEffect();\n        this.onIsOpenChangeEffect();\n    }\n\n    /** @ignore */\n    ngOnInit(): void {\n        if (this.defaultOpen()) {\n            this.handleOpen();\n        }\n    }\n\n    /** @ignore */\n    controlledExternally() {\n        return this.isControlledExternally().asReadonly();\n    }\n\n    /** @ignore */\n    handleOpen(): void {\n        if (this.isControlledExternally()()) {\n            return;\n        }\n        this.setOpen(true);\n    }\n\n    /** @ignore */\n    handleClose(): void {\n        if (this.isControlledExternally()()) {\n            return;\n        }\n        this.setOpen(false);\n    }\n\n    /** @ignore */\n    handleToggle(): void {\n        if (this.isControlledExternally()()) {\n            return;\n        }\n        this.isOpen() ? this.handleClose() : this.handleOpen();\n    }\n\n    /** @ignore */\n    private setOpen(open = false): void {\n        if (open) {\n            this.document.dispatchEvent(new CustomEvent('popover.open'));\n        }\n\n        this.isOpen.set(open);\n        this.onOpenChange.emit(open);\n    }\n\n    /** @ignore */\n    private show(): void {\n        this.popoverContentDirective().show();\n    }\n\n    /** @ignore */\n    private hide(): void {\n        this.popoverContentDirective().hide();\n    }\n\n    /** @ignore */\n    private onIsOpenChangeEffect() {\n        effect(() => {\n            const isOpen = this.isOpen();\n\n            untracked(() => {\n                if (isOpen) {\n                    this.show();\n                } else {\n                    this.hide();\n                }\n            });\n        });\n    }\n\n    /** @ignore */\n    private onOpenChangeEffect() {\n        effect(() => {\n            const currentOpen = this.open();\n\n            untracked(() => {\n                this.isControlledExternally().set(currentOpen !== void 0);\n                if (this.isControlledExternally()()) {\n                    this.setOpen(currentOpen);\n                }\n            });\n        });\n    }\n}\n"]}

package/esm2022/popover/src/popover-root.inject.mjs

@@ -0,0 +1,7 @@
+import { assertInInjectionContext, inject, isDevMode } from '@angular/core';
+import { RdxPopoverRootToken } from './popover-root.token';
+export function injectPopoverRoot() {
+    isDevMode() && assertInInjectionContext(injectPopoverRoot);
+    return inject(RdxPopoverRootToken);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1yb290LmluamVjdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3ByaW1pdGl2ZXMvcG9wb3Zlci9zcmMvcG9wb3Zlci1yb290LmluamVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUU1RSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUUzRCxNQUFNLFVBQVUsaUJBQWlCO0lBQzdCLFNBQVMsRUFBRSxJQUFJLHdCQUF3QixDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDM0QsT0FBTyxNQUFNLENBQUMsbUJBQW1CLENBQUMsQ0FBQztBQUN2QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYXNzZXJ0SW5JbmplY3Rpb25Db250ZXh0LCBpbmplY3QsIGlzRGV2TW9kZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUmR4UG9wb3ZlclJvb3REaXJlY3RpdmUgfSBmcm9tICcuL3BvcG92ZXItcm9vdC5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgUmR4UG9wb3ZlclJvb3RUb2tlbiB9IGZyb20gJy4vcG9wb3Zlci1yb290LnRva2VuJztcblxuZXhwb3J0IGZ1bmN0aW9uIGluamVjdFBvcG92ZXJSb290KCk6IFJkeFBvcG92ZXJSb290RGlyZWN0aXZlIHtcbiAgICBpc0Rldk1vZGUoKSAmJiBhc3NlcnRJbkluamVjdGlvbkNvbnRleHQoaW5qZWN0UG9wb3ZlclJvb3QpO1xuICAgIHJldHVybiBpbmplY3QoUmR4UG9wb3ZlclJvb3RUb2tlbik7XG59XG4iXX0=

package/esm2022/popover/src/popover-root.token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const RdxPopoverRootToken = new InjectionToken('RdxPopoverRootToken');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1yb290LnRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcHJpbWl0aXZlcy9wb3BvdmVyL3NyYy9wb3BvdmVyLXJvb3QudG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUcvQyxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLGNBQWMsQ0FBMEIscUJBQXFCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBSZHhQb3BvdmVyUm9vdERpcmVjdGl2ZSB9IGZyb20gJy4vcG9wb3Zlci1yb290LmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCBjb25zdCBSZHhQb3BvdmVyUm9vdFRva2VuID0gbmV3IEluamVjdGlvblRva2VuPFJkeFBvcG92ZXJSb290RGlyZWN0aXZlPignUmR4UG9wb3ZlclJvb3RUb2tlbicpO1xuIl19