@spartan-ng/brain 0.0.1-alpha.373 → 0.0.1-alpha.379

package/esm2022/tooltip/lib/brn-tooltip-content.component.mjs

@@ -0,0 +1,228 @@
+/**
+ * We are building on shoulders of giants here and adapt the implementation provided by the incredible Angular
+ * team: https://github.com/angular/components/blob/main/src/material/tooltip/tooltip.ts
+ * Check them out! Give them a try! Leave a star! Their work is incredible!
+ */
+import { NgTemplateOutlet, isPlatformBrowser } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, PLATFORM_ID, Renderer2, ViewChild, ViewEncapsulation, inject, signal, } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Internal component that wraps the tooltip's content.
+ * @docs-private
+ */
+export class BrnTooltipContentComponent {
+    _cdr = inject(ChangeDetectorRef);
+    _isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    _renderer2 = inject(Renderer2);
+    _contentHovered = signal(false);
+    _tooltipClasses = signal('');
+    side = signal('above');
+    /** Message to display in the tooltip */
+    content = null;
+    /** The timeout ID of any current timer set to show the tooltip */
+    _showTimeoutId;
+    /** The timeout ID of any current timer set to hide the tooltip */
+    _hideTimeoutId;
+    /** The timeout ID of any current timer set to animate the tooltip */
+    _animateTimeoutId;
+    /** Element that caused the tooltip to open. */
+    _triggerElement;
+    /** Amount of milliseconds to delay the closing sequence. */
+    _mouseLeaveHideDelay = 0;
+    /** Amount of milliseconds of closing animation. */
+    _exitAnimationDuration = 0;
+    /** Reference to the internal tooltip element. */
+    _tooltip;
+    /** Whether interactions on the page should close the tooltip */
+    _closeOnInteraction = false;
+    /** Whether the tooltip is currently visible. */
+    _isVisible = false;
+    /** Subject for notifying that the tooltip has been hidden from the view */
+    _onHide = new Subject();
+    afterHidden = this._onHide.asObservable();
+    /**
+     * Shows the tooltip with originating from the provided origin
+     * @param delay Amount of milliseconds to the delay showing the tooltip.
+     */
+    show(delay) {
+        // Cancel the delayed hide if it is scheduled
+        if (this._hideTimeoutId !== null) {
+            clearTimeout(this._hideTimeoutId);
+        }
+        if (this._animateTimeoutId !== null) {
+            clearTimeout(this._animateTimeoutId);
+        }
+        this._showTimeoutId = setTimeout(() => {
+            this._toggleDataAttributes(true, this.side());
+            this._toggleVisibility(true);
+            this._showTimeoutId = undefined;
+        }, delay);
+    }
+    /**
+     * Begins to hide the tooltip after the provided delay in ms.
+     * @param delay Amount of milliseconds to delay hiding the tooltip.
+     * @param exitAnimationDuration Time before hiding to finish animation
+     * */
+    hide(delay, exitAnimationDuration) {
+        // Cancel the delayed show if it is scheduled
+        if (this._showTimeoutId !== null) {
+            clearTimeout(this._showTimeoutId);
+        }
+        // start out animation at delay minus animation delay or immediately if possible
+        this._animateTimeoutId = setTimeout(() => {
+            this._animateTimeoutId = undefined;
+            if (this._contentHovered())
+                return;
+            this._toggleDataAttributes(false, this.side());
+        }, Math.max(delay, 0));
+        this._hideTimeoutId = setTimeout(() => {
+            this._hideTimeoutId = undefined;
+            if (this._contentHovered())
+                return;
+            this._toggleVisibility(false);
+        }, delay + exitAnimationDuration);
+    }
+    /** Whether the tooltip is being displayed. */
+    isVisible() {
+        return this._isVisible;
+    }
+    ngOnDestroy() {
+        this._cancelPendingAnimations();
+        this._onHide.complete();
+        this._triggerElement = undefined;
+    }
+    _isTypeOfString(content) {
+        return typeof content === 'string';
+    }
+    /**
+     * Interactions on the HTML body should close the tooltip immediately as defined in the
+     * material design spec.
+     * https://material.io/design/components/tooltips.html#behavior
+     */
+    _handleBodyInteraction() {
+        if (this._closeOnInteraction) {
+            this.hide(0, 0);
+        }
+    }
+    /**
+     * Marks that the tooltip needs to be checked in the next change detection run.
+     * Mainly used for rendering the initial text before positioning a tooltip, which
+     * can be problematic in components with OnPush change detection.
+     */
+    _markForCheck() {
+        this._cdr.markForCheck();
+    }
+    _handleMouseLeave({ relatedTarget }) {
+        if (!relatedTarget || !this._triggerElement?.contains(relatedTarget)) {
+            if (this.isVisible()) {
+                this.hide(this._mouseLeaveHideDelay, this._exitAnimationDuration);
+            }
+            else {
+                this._finalize(false);
+            }
+        }
+        this._contentHovered.set(false);
+    }
+    /** Cancels any pending animation sequences. */
+    _cancelPendingAnimations() {
+        if (this._showTimeoutId !== null) {
+            clearTimeout(this._showTimeoutId);
+        }
+        if (this._hideTimeoutId !== null) {
+            clearTimeout(this._hideTimeoutId);
+        }
+        this._showTimeoutId = this._hideTimeoutId = undefined;
+    }
+    _finalize(toVisible) {
+        if (toVisible) {
+            this._closeOnInteraction = true;
+        }
+        else if (!this.isVisible()) {
+            this._onHide.next();
+        }
+    }
+    /** Toggles the visibility of the tooltip element. */
+    _toggleVisibility(isVisible) {
+        // We set the classes directly here ourselves so that toggling the tooltip state
+        // isn't bound by change detection. This allows us to hide it even if the
+        // view ref has been detached from the CD tree.
+        const tooltip = this._tooltip?.nativeElement;
+        if (!tooltip || !this._isBrowser)
+            return;
+        this._renderer2.setStyle(tooltip, 'visibility', isVisible ? 'visible' : 'hidden');
+        if (isVisible) {
+            this._renderer2.removeStyle(tooltip, 'display');
+        }
+        else {
+            this._renderer2.setStyle(tooltip, 'display', 'none');
+        }
+        this._isVisible = isVisible;
+    }
+    _toggleDataAttributes(isVisible, side) {
+        // We set the classes directly here ourselves so that toggling the tooltip state
+        // isn't bound by change detection. This allows us to hide it even if the
+        // view ref has been detached from the CD tree.
+        const tooltip = this._tooltip?.nativeElement;
+        if (!tooltip || !this._isBrowser)
+            return;
+        this._renderer2.setAttribute(tooltip, 'data-side', side);
+        this._renderer2.setAttribute(tooltip, 'data-state', isVisible ? 'open' : 'closed');
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTooltipContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.5", type: BrnTooltipContentComponent, isStandalone: true, selector: "brn-tooltip-content", host: { attributes: { "aria-hidden": "true" }, listeners: { "mouseleave": "_handleMouseLeave($event)" }, properties: { "style.zoom": "isVisible() ? 1 : null" } }, viewQueries: [{ propertyName: "_tooltip", first: true, predicate: ["tooltip"], descendants: true, static: true }], ngImport: i0, template: `
+		<div
+			(mouseenter)="_contentHovered.set(true)"
+			(mouseleave)="_contentHovered.set(false)"
+			[class]="_tooltipClasses()"
+			[style.visibility]="'hidden'"
+			#tooltip
+		>
+			@if (_isTypeOfString(content)) {
+				{{ content }}
+			} @else {
+				<ng-container [ngTemplateOutlet]="content" />
+			}
+		</div>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTooltipContentComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'brn-tooltip-content',
+                    standalone: true,
+                    template: `
+		<div
+			(mouseenter)="_contentHovered.set(true)"
+			(mouseleave)="_contentHovered.set(false)"
+			[class]="_tooltipClasses()"
+			[style.visibility]="'hidden'"
+			#tooltip
+		>
+			@if (_isTypeOfString(content)) {
+				{{ content }}
+			} @else {
+				<ng-container [ngTemplateOutlet]="content" />
+			}
+		</div>
+	`,
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        // Forces the element to have a layout in IE and Edge. This fixes issues where the element
+                        // won't be rendered if the animations are disabled or there is no web animations polyfill.
+                        '[style.zoom]': 'isVisible() ? 1 : null',
+                        '(mouseleave)': '_handleMouseLeave($event)',
+                        'aria-hidden': 'true',
+                    },
+                    imports: [NgTemplateOutlet],
+                }]
+        }], propDecorators: { _tooltip: [{
+                type: ViewChild,
+                args: ['tooltip', {
+                        // Use a static query here since we interact directly with
+                        // the DOM which can happen before `ngAfterViewInit`.
+                        static: true,
+                    }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brn-tooltip-content.component.js","sourceRoot":"","sources":["../../../../../../libs/brain/tooltip/src/lib/brn-tooltip-content.component.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * We are building on shoulders of giants here and adapt the implementation provided by the incredible Angular\n * team: https://github.com/angular/components/blob/main/src/material/tooltip/tooltip.ts\n * Check them out! Give them a try! Leave a star! Their work is incredible!\n */\n\nimport { NgTemplateOutlet, isPlatformBrowser } from '@angular/common';\nimport {\n\tChangeDetectionStrategy,\n\tChangeDetectorRef,\n\tComponent,\n\ttype ElementRef,\n\ttype OnDestroy,\n\tPLATFORM_ID,\n\tRenderer2,\n\ttype TemplateRef,\n\tViewChild,\n\tViewEncapsulation,\n\tinject,\n\tsignal,\n} from '@angular/core';\nimport { Subject } from 'rxjs';\n\n/**\n * Internal component that wraps the tooltip's content.\n * @docs-private\n */\n@Component({\n\tselector: 'brn-tooltip-content',\n\tstandalone: true,\n\ttemplate: `\n\t\t<div\n\t\t\t(mouseenter)=\"_contentHovered.set(true)\"\n\t\t\t(mouseleave)=\"_contentHovered.set(false)\"\n\t\t\t[class]=\"_tooltipClasses()\"\n\t\t\t[style.visibility]=\"'hidden'\"\n\t\t\t#tooltip\n\t\t>\n\t\t\t@if (_isTypeOfString(content)) {\n\t\t\t\t{{ content }}\n\t\t\t} @else {\n\t\t\t\t<ng-container [ngTemplateOutlet]=\"content\" />\n\t\t\t}\n\t\t</div>\n\t`,\n\tencapsulation: ViewEncapsulation.None,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\thost: {\n\t\t// Forces the element to have a layout in IE and Edge. This fixes issues where the element\n\t\t// won't be rendered if the animations are disabled or there is no web animations polyfill.\n\t\t'[style.zoom]': 'isVisible() ? 1 : null',\n\t\t'(mouseleave)': '_handleMouseLeave($event)',\n\t\t'aria-hidden': 'true',\n\t},\n\timports: [NgTemplateOutlet],\n})\nexport class BrnTooltipContentComponent implements OnDestroy {\n\tprivate readonly _cdr = inject(ChangeDetectorRef);\n\tprivate readonly _isBrowser = isPlatformBrowser(inject(PLATFORM_ID));\n\tprivate readonly _renderer2 = inject(Renderer2);\n\n\tprotected readonly _contentHovered = signal(false);\n\n\tpublic readonly _tooltipClasses = signal('');\n\tpublic readonly side = signal('above');\n\t/** Message to display in the tooltip */\n\tpublic content: string | TemplateRef<unknown> | null = null;\n\n\t/** The timeout ID of any current timer set to show the tooltip */\n\tprivate _showTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\t/** The timeout ID of any current timer set to hide the tooltip */\n\tprivate _hideTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\t/** The timeout ID of any current timer set to animate the tooltip */\n\tprivate _animateTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n\t/** Element that caused the tooltip to open. */\n\tpublic _triggerElement?: HTMLElement;\n\n\t/** Amount of milliseconds to delay the closing sequence. */\n\tpublic _mouseLeaveHideDelay = 0;\n\t/** Amount of milliseconds of closing animation. */\n\tpublic _exitAnimationDuration = 0;\n\n\t/** Reference to the internal tooltip element. */\n\t@ViewChild('tooltip', {\n\t\t// Use a static query here since we interact directly with\n\t\t// the DOM which can happen before `ngAfterViewInit`.\n\t\tstatic: true,\n\t})\n\tpublic _tooltip?: ElementRef<HTMLElement>;\n\n\t/** Whether interactions on the page should close the tooltip */\n\tprivate _closeOnInteraction = false;\n\n\t/** Whether the tooltip is currently visible. */\n\tprivate _isVisible = false;\n\n\t/** Subject for notifying that the tooltip has been hidden from the view */\n\tprivate readonly _onHide: Subject<void> = new Subject();\n\tpublic readonly afterHidden = this._onHide.asObservable();\n\n\t/**\n\t * Shows the tooltip with originating from the provided origin\n\t * @param delay Amount of milliseconds to the delay showing the tooltip.\n\t */\n\tshow(delay: number): void {\n\t\t// Cancel the delayed hide if it is scheduled\n\t\tif (this._hideTimeoutId !== null) {\n\t\t\tclearTimeout(this._hideTimeoutId);\n\t\t}\n\t\tif (this._animateTimeoutId !== null) {\n\t\t\tclearTimeout(this._animateTimeoutId);\n\t\t}\n\t\tthis._showTimeoutId = setTimeout(() => {\n\t\t\tthis._toggleDataAttributes(true, this.side());\n\t\t\tthis._toggleVisibility(true);\n\t\t\tthis._showTimeoutId = undefined;\n\t\t}, delay);\n\t}\n\n\t/**\n\t * Begins to hide the tooltip after the provided delay in ms.\n\t * @param delay Amount of milliseconds to delay hiding the tooltip.\n\t * @param exitAnimationDuration Time before hiding to finish animation\n\t * */\n\thide(delay: number, exitAnimationDuration: number): void {\n\t\t// Cancel the delayed show if it is scheduled\n\t\tif (this._showTimeoutId !== null) {\n\t\t\tclearTimeout(this._showTimeoutId);\n\t\t}\n\t\t// start out animation at delay minus animation delay or immediately if possible\n\t\tthis._animateTimeoutId = setTimeout(\n\t\t\t() => {\n\t\t\t\tthis._animateTimeoutId = undefined;\n\t\t\t\tif (this._contentHovered()) return;\n\t\t\t\tthis._toggleDataAttributes(false, this.side());\n\t\t\t},\n\t\t\tMath.max(delay, 0),\n\t\t);\n\t\tthis._hideTimeoutId = setTimeout(() => {\n\t\t\tthis._hideTimeoutId = undefined;\n\t\t\tif (this._contentHovered()) return;\n\t\t\tthis._toggleVisibility(false);\n\t\t}, delay + exitAnimationDuration);\n\t}\n\n\t/** Whether the tooltip is being displayed. */\n\tisVisible(): boolean {\n\t\treturn this._isVisible;\n\t}\n\n\tngOnDestroy() {\n\t\tthis._cancelPendingAnimations();\n\t\tthis._onHide.complete();\n\t\tthis._triggerElement = undefined;\n\t}\n\n\t_isTypeOfString(content: unknown): content is string {\n\t\treturn typeof content === 'string';\n\t}\n\n\t/**\n\t * Interactions on the HTML body should close the tooltip immediately as defined in the\n\t * material design spec.\n\t * https://material.io/design/components/tooltips.html#behavior\n\t */\n\t_handleBodyInteraction(): void {\n\t\tif (this._closeOnInteraction) {\n\t\t\tthis.hide(0, 0);\n\t\t}\n\t}\n\n\t/**\n\t * Marks that the tooltip needs to be checked in the next change detection run.\n\t * Mainly used for rendering the initial text before positioning a tooltip, which\n\t * can be problematic in components with OnPush change detection.\n\t */\n\t_markForCheck(): void {\n\t\tthis._cdr.markForCheck();\n\t}\n\n\t_handleMouseLeave({ relatedTarget }: MouseEvent) {\n\t\tif (!relatedTarget || !this._triggerElement?.contains(relatedTarget as Node)) {\n\t\t\tif (this.isVisible()) {\n\t\t\t\tthis.hide(this._mouseLeaveHideDelay, this._exitAnimationDuration);\n\t\t\t} else {\n\t\t\t\tthis._finalize(false);\n\t\t\t}\n\t\t}\n\t\tthis._contentHovered.set(false);\n\t}\n\n\t/** Cancels any pending animation sequences. */\n\t_cancelPendingAnimations() {\n\t\tif (this._showTimeoutId !== null) {\n\t\t\tclearTimeout(this._showTimeoutId);\n\t\t}\n\n\t\tif (this._hideTimeoutId !== null) {\n\t\t\tclearTimeout(this._hideTimeoutId);\n\t\t}\n\n\t\tthis._showTimeoutId = this._hideTimeoutId = undefined;\n\t}\n\n\tprivate _finalize(toVisible: boolean) {\n\t\tif (toVisible) {\n\t\t\tthis._closeOnInteraction = true;\n\t\t} else if (!this.isVisible()) {\n\t\t\tthis._onHide.next();\n\t\t}\n\t}\n\n\t/** Toggles the visibility of the tooltip element. */\n\tprivate _toggleVisibility(isVisible: boolean) {\n\t\t// We set the classes directly here ourselves so that toggling the tooltip state\n\t\t// isn't bound by change detection. This allows us to hide it even if the\n\t\t// view ref has been detached from the CD tree.\n\t\tconst tooltip = this._tooltip?.nativeElement;\n\t\tif (!tooltip || !this._isBrowser) return;\n\t\tthis._renderer2.setStyle(tooltip, 'visibility', isVisible ? 'visible' : 'hidden');\n\t\tif (isVisible) {\n\t\t\tthis._renderer2.removeStyle(tooltip, 'display');\n\t\t} else {\n\t\t\tthis._renderer2.setStyle(tooltip, 'display', 'none');\n\t\t}\n\t\tthis._isVisible = isVisible;\n\t}\n\n\tprivate _toggleDataAttributes(isVisible: boolean, side: string) {\n\t\t// We set the classes directly here ourselves so that toggling the tooltip state\n\t\t// isn't bound by change detection. This allows us to hide it even if the\n\t\t// view ref has been detached from the CD tree.\n\t\tconst tooltip = this._tooltip?.nativeElement;\n\t\tif (!tooltip || !this._isBrowser) return;\n\t\tthis._renderer2.setAttribute(tooltip, 'data-side', side);\n\t\tthis._renderer2.setAttribute(tooltip, 'data-state', isVisible ? 'open' : 'closed');\n\t}\n}\n"]}

package/esm2022/tooltip/lib/brn-tooltip-content.directive.mjs

@@ -0,0 +1,22 @@
+import { Directive, TemplateRef, inject } from '@angular/core';
+import { BrnTooltipDirective } from './brn-tooltip.directive';
+import * as i0 from "@angular/core";
+export class BrnTooltipContentDirective {
+    _brnTooltipDirective = inject(BrnTooltipDirective, { optional: true });
+    _tpl = inject(TemplateRef);
+    constructor() {
+        if (!this._brnTooltipDirective || !this._tpl)
+            return;
+        this._brnTooltipDirective.tooltipTemplate.set(this._tpl);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTooltipContentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.5", type: BrnTooltipContentDirective, isStandalone: true, selector: "[brnTooltipContent]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTooltipContentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnTooltipContent]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJuLXRvb2x0aXAtY29udGVudC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2JyYWluL3Rvb2x0aXAvc3JjL2xpYi9icm4tdG9vbHRpcC1jb250ZW50LmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDL0QsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7O0FBTTlELE1BQU0sT0FBTywwQkFBMEI7SUFDckIsb0JBQW9CLEdBQUcsTUFBTSxDQUFDLG1CQUFtQixFQUFFLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7SUFDdkUsSUFBSSxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUU1QztRQUNDLElBQUksQ0FBQyxJQUFJLENBQUMsb0JBQW9CLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSTtZQUFFLE9BQU87UUFDckQsSUFBSSxDQUFDLG9CQUFvQixDQUFDLGVBQWUsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzFELENBQUM7MEhBUFcsMEJBQTBCOzhHQUExQiwwQkFBMEI7OzJGQUExQiwwQkFBMEI7a0JBSnRDLFNBQVM7bUJBQUM7b0JBQ1YsUUFBUSxFQUFFLHFCQUFxQjtvQkFDL0IsVUFBVSxFQUFFLElBQUk7aUJBQ2hCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBUZW1wbGF0ZVJlZiwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCcm5Ub29sdGlwRGlyZWN0aXZlIH0gZnJvbSAnLi9icm4tdG9vbHRpcC5kaXJlY3RpdmUnO1xuXG5ARGlyZWN0aXZlKHtcblx0c2VsZWN0b3I6ICdbYnJuVG9vbHRpcENvbnRlbnRdJyxcblx0c3RhbmRhbG9uZTogdHJ1ZSxcbn0pXG5leHBvcnQgY2xhc3MgQnJuVG9vbHRpcENvbnRlbnREaXJlY3RpdmUge1xuXHRwcml2YXRlIHJlYWRvbmx5IF9icm5Ub29sdGlwRGlyZWN0aXZlID0gaW5qZWN0KEJyblRvb2x0aXBEaXJlY3RpdmUsIHsgb3B0aW9uYWw6IHRydWUgfSk7XG5cdHByaXZhdGUgcmVhZG9ubHkgX3RwbCA9IGluamVjdChUZW1wbGF0ZVJlZik7XG5cblx0Y29uc3RydWN0b3IoKSB7XG5cdFx0aWYgKCF0aGlzLl9icm5Ub29sdGlwRGlyZWN0aXZlIHx8ICF0aGlzLl90cGwpIHJldHVybjtcblx0XHR0aGlzLl9icm5Ub29sdGlwRGlyZWN0aXZlLnRvb2x0aXBUZW1wbGF0ZS5zZXQodGhpcy5fdHBsKTtcblx0fVxufVxuIl19