@one-paragon/angular-utilities 0.3.11-beta.1 → 0.4.0

package/esm2022/utilities/directives/dialog.mjs

@@ -0,0 +1,139 @@
+import { Directive, Input, Component, Output, EventEmitter, ChangeDetectionStrategy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { switchAll } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "./dialog-service";
+export class DialogWrapper {
+    set template(tmpl) {
+        if (this.viewEmbedded) {
+            this.vcr.clear();
+        }
+        this.viewEmbedded = true;
+        this.vcr.createEmbeddedView(tmpl, this.viewContext);
+    }
+    set close(closeMethod) {
+        this.viewContext.close = closeMethod;
+    }
+    set data(value) {
+        this.viewContext.$implicit = value;
+        this.viewContext.opDialog = value;
+    }
+    constructor(vcr) {
+        this.vcr = vcr;
+        this.viewEmbedded = false;
+        this.viewContext = {
+            close: () => { },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: DialogWrapper, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.2", type: DialogWrapper, isStandalone: true, selector: "dialog-wrapper", ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: DialogWrapper, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dialog-wrapper',
+                    template: ``,
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [{ type: i0.ViewContainerRef }] });
+const defaultDialogConfig = {
+    maxHeight: '95vh',
+};
+export class DialogDirective {
+    set opDialogConfig(config) {
+        this._dialogConfig = { ...defaultDialogConfig, ...config };
+    }
+    get opDialogConfig() {
+        return this._dialogConfig;
+    }
+    set state(open_close) {
+        this._data.next(open_close);
+    }
+    constructor(templateRef, dialog, service) {
+        this.templateRef = templateRef;
+        this.dialog = dialog;
+        this.service = service;
+        this.opDialogClosed = new EventEmitter();
+        this._dialogConfig = defaultDialogConfig;
+        this.opDialogAddDialogClass = true;
+        this._data = new Subject();
+        this.subscription = this._data.pipe(switchAll()).subscribe(d => {
+            if (d) {
+                this.opDialogConfig.data = d;
+                this.setDialogState(true);
+            }
+            else {
+                this.setDialogState(false);
+            }
+        });
+    }
+    close() {
+        this.dialogRef?.close();
+    }
+    initDialog() {
+        if (this.nativeElement) {
+            const rect = this.nativeElement.getBoundingClientRect();
+            const position = { left: `${rect.left}px`, top: `${rect.bottom - 50}px` };
+            this.opDialogConfig = { ...this.opDialogConfig, position };
+        }
+        if (this.opDialogAddDialogClass) {
+            this.opDialogConfig.panelClass = [...(Array.isArray(this.opDialogConfig.panelClass) ? this.opDialogConfig.panelClass : this.opDialogConfig.panelClass ? [this.opDialogConfig.panelClass] : []), 'opDialog'];
+        }
+        this.dialogRef = this.dialog.open(DialogWrapper, this.opDialogConfig);
+        this.componentWrapper = this.dialogRef.componentInstance;
+        this.componentWrapper.close = () => this.dialogRef?.close();
+        this.componentWrapper.data = this.opDialogConfig.data;
+        this.componentWrapper.template = this.templateRef;
+        if (!this.opDialogConfig.disableClose) {
+            this.service.addDialogRef(this.dialogRef);
+        }
+        const sub = this.dialogRef.afterClosed().subscribe(() => {
+            this.opDialogClosed.emit(true);
+            this.service.removeDialogRef(this.dialogRef);
+            this.dialogRef = undefined;
+            sub.unsubscribe();
+        });
+    }
+    setDialogState(open) {
+        if (open) {
+            if (!this.dialogRef) {
+                this.initDialog();
+            }
+            else {
+                this.componentWrapper.data = this.opDialogConfig.data;
+            }
+        }
+        else if (!open && this.dialogRef) {
+            this.dialogRef.close();
+        }
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: DialogDirective, deps: [{ token: i0.TemplateRef }, { token: i1.MatDialog }, { token: i2.DialogService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.2", type: DialogDirective, isStandalone: true, selector: "[opDialog]", inputs: { opDialogAddDialogClass: "opDialogAddDialogClass", opDialogConfig: "opDialogConfig", state: ["opDialog", "state"], nativeElement: ["opDialogOrigin", "nativeElement"] }, outputs: { opDialogClosed: "opDialogClosed" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: DialogDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[opDialog]', standalone: true }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: i1.MatDialog }, { type: i2.DialogService }], propDecorators: { opDialogClosed: [{
+                type: Output
+            }], opDialogAddDialogClass: [{
+                type: Input
+            }], opDialogConfig: [{
+                type: Input
+            }], state: [{
+                type: Input,
+                args: ['opDialog']
+            }], nativeElement: [{
+                type: Input,
+                args: ['opDialogOrigin']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.js","sourceRoot":"","sources":["../../../../../projects/angular-utilities/src/utilities/directives/dialog.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, TemplateRef, Input, OnDestroy, Component, Output, EventEmitter, ViewContainerRef, Injector, ComponentFactoryResolver, ChangeDetectionStrategy } from '@angular/core';\r\nimport { MatDialog, MatDialogRef, MatDialogConfig } from '@angular/material/dialog';\r\nimport { Observable, Subscription, Subject } from 'rxjs';\r\nimport { switchAll } from 'rxjs/operators';\r\nimport { DialogService } from './dialog-service';\r\n\r\ninterface DialogViewContext<T> {\r\n  $implicit: T,\r\n  opDialog: T,\r\n  close: () => void,\r\n}\r\n\r\n@Component({\r\n  selector: 'dialog-wrapper',\r\n  template: ``,\r\n  standalone: true,\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class DialogWrapper<T = any> {\r\n  viewEmbedded = false;\r\n  viewContext = {\r\n    close: () => {},\r\n  } as DialogViewContext<T>;\r\n  set template(tmpl: TemplateRef<DialogViewContext<T>>) {\r\n    if (this.viewEmbedded) {\r\n      this.vcr.clear();\r\n    }\r\n    this.viewEmbedded = true;\r\n    this.vcr.createEmbeddedView(tmpl, this.viewContext);\r\n  }\r\n\r\n  set close(closeMethod: () => void ) {\r\n    this.viewContext.close = closeMethod;\r\n  }\r\n\r\n  set data(value: T) {\r\n    this.viewContext.$implicit = value;\r\n    this.viewContext.opDialog = value;\r\n  }\r\n  constructor(private vcr: ViewContainerRef ) {\r\n  }\r\n\r\n}\r\n\r\n\r\nconst defaultDialogConfig: MatDialogConfig = {\r\n  maxHeight: '95vh',\r\n}\r\n\r\n\r\n@Directive(\r\n  { selector: '[opDialog]', standalone: true }\r\n) export class DialogDirective<T> implements OnDestroy {\r\n  @Output() opDialogClosed: EventEmitter<boolean> = new EventEmitter();\r\n  _dialogConfig: MatDialogConfig<T> = defaultDialogConfig;\r\n  @Input() opDialogAddDialogClass = true;\r\n  @Input() set opDialogConfig(config: MatDialogConfig<T>) {\r\n    \r\n    this._dialogConfig = { ...defaultDialogConfig, ...config };\r\n  }\r\n\r\n  get opDialogConfig() : MatDialogConfig<T> {\r\n    return this._dialogConfig;\r\n  }\r\n  @Input('opDialog') set state(open_close: Observable<T>) {\r\n    this._data.next(open_close);\r\n  }\r\n  @Input('opDialogOrigin') nativeElement? : HTMLElement;\r\n  dialogRef?: MatDialogRef<any, boolean>;\r\n  subscription: Subscription;\r\n  componentWrapper?: DialogWrapper<T>;\r\n\r\n  constructor(\r\n    private templateRef: TemplateRef<DialogViewContext<T>>,\r\n    private dialog: MatDialog,\r\n    private service: DialogService) {\r\n    this.subscription = this._data.pipe(\r\n      switchAll()\r\n    ).subscribe(d => {\r\n      if (d) {\r\n        this.opDialogConfig.data = d;\r\n        this.setDialogState(true);\r\n      } else {\r\n        this.setDialogState(false);\r\n      }\r\n    });\r\n  }\r\n\r\n  _data = new Subject<Observable<T>>();\r\n\r\n  close() {\r\n    this.dialogRef?.close();\r\n  }\r\n\r\n  initDialog() {\r\n    if(this.nativeElement){\r\n      const rect = this.nativeElement.getBoundingClientRect();\r\n      const position = { left: `${rect.left}px`, top: `${rect.bottom - 50}px` };\r\n      this.opDialogConfig = {...this.opDialogConfig , position};\r\n    }\r\n    if (this.opDialogAddDialogClass) {\r\n      this.opDialogConfig.panelClass = [...(Array.isArray(this.opDialogConfig.panelClass) ? this.opDialogConfig.panelClass : this.opDialogConfig.panelClass ? [this.opDialogConfig.panelClass] : []), 'opDialog'];\r\n    }\r\n    this.dialogRef = this.dialog.open(DialogWrapper, this.opDialogConfig);\r\n    this.componentWrapper = this.dialogRef.componentInstance;\r\n    this.componentWrapper!.close = () => this.dialogRef?.close();\r\n    this.componentWrapper!.data = this.opDialogConfig.data as T;\r\n    this.componentWrapper!.template = this.templateRef;\r\n    if (!this.opDialogConfig.disableClose) {\r\n      this.service.addDialogRef(this.dialogRef);\r\n    }\r\n    const sub = this.dialogRef.afterClosed().subscribe(() => {\r\n      this.opDialogClosed.emit(true);\r\n      this.service.removeDialogRef(this.dialogRef!);\r\n      this.dialogRef = undefined;\r\n      sub.unsubscribe();\r\n    });\r\n  }\r\n\r\n  setDialogState(open: boolean) {\r\n    if (open) {\r\n      if (!this.dialogRef) {\r\n        this.initDialog();\r\n      } else {\r\n        this.componentWrapper!.data = this.opDialogConfig.data as T;\r\n      }\r\n    } else if (!open && this.dialogRef) {\r\n      this.dialogRef.close();\r\n    }\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    if (this.subscription) {\r\n      this.subscription.unsubscribe();\r\n    }\r\n  }\r\n\r\n  static ngTemplateContextGuard<T>(dir: DialogDirective<T>, ctx: any): ctx is DialogViewContext<Exclude<T, false | 0 | '' | null | undefined>> {\r\n    return true;\r\n  }\r\n\r\n}\r\n"]}

package/esm2022/utilities/directives/mat-toggle-group-directive.mjs

@@ -0,0 +1,60 @@
+import { ContentChildren, Directive, Input, Output } from "@angular/core";
+import { MatSlideToggle } from "@angular/material/slide-toggle";
+import { merge, ReplaySubject, scan, startWith, switchMap } from "rxjs";
+import * as i0 from "@angular/core";
+export class MatSlideToggleGroupDirective {
+    constructor() {
+        this.allowMultiple = false;
+        this._ready = new ReplaySubject(1);
+    }
+    set toggles(val) {
+        this._toggles = val;
+        this._ready.next(true);
+    }
+    get valueEmitter() {
+        return this._ready.pipe(switchMap(_ => this.getObs()));
+    }
+    getInitValue() {
+        const startValue = this._toggles.reduce((prev, cur) => {
+            if (!cur.name) {
+                throw new Error('toggle must have the name attribute set');
+            }
+            prev[cur.name] = cur.checked;
+            return prev;
+        }, {});
+        return startValue;
+    }
+    getObs() {
+        var toggleChanges = merge(...this._toggles.map(toggle => toggle.change));
+        const startValue = this.getInitValue();
+        return toggleChanges.pipe(scan((prev, cur) => {
+            const toggleName = cur.source.name;
+            const newVal = { ...prev, [toggleName]: cur.checked };
+            if (cur.checked && !this.allowMultiple) {
+                Object.keys(prev)
+                    .filter(key => key !== toggleName && prev[key])
+                    .forEach(key => {
+                    newVal[key] = false;
+                    this._toggles.find(toggle => toggle.name === key).toggle();
+                });
+            }
+            return newVal;
+        }, startValue), startWith(startValue));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: MatSlideToggleGroupDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.2", type: MatSlideToggleGroupDirective, isStandalone: true, selector: "[opMatSlideToggleGroup]", inputs: { allowMultiple: "allowMultiple" }, outputs: { valueEmitter: "valueEmitter" }, queries: [{ propertyName: "toggles", predicate: MatSlideToggle }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: MatSlideToggleGroupDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[opMatSlideToggleGroup]',
+                    standalone: true
+                }]
+        }], propDecorators: { allowMultiple: [{
+                type: Input
+            }], toggles: [{
+                type: ContentChildren,
+                args: [MatSlideToggle]
+            }], valueEmitter: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utilities/directives/prevent-enter.directive.mjs

@@ -0,0 +1,20 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PreventEnterDirective {
+    onKeyDown() {
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PreventEnterDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.2", type: PreventEnterDirective, isStandalone: true, selector: "preventEnter", host: { listeners: { "keydown.enter": "onKeyDown($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PreventEnterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'preventEnter',
+                    standalone: true
+                }]
+        }], propDecorators: { onKeyDown: [{
+                type: HostListener,
+                args: ['keydown.enter', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldmVudC1lbnRlci5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXV0aWxpdGllcy9zcmMvdXRpbGl0aWVzL2RpcmVjdGl2ZXMvcHJldmVudC1lbnRlci5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTXhELE1BQU0sT0FBTyxxQkFBcUI7SUFHaEMsU0FBUztRQUNMLE9BQU8sS0FBSyxDQUFBO0lBQ2hCLENBQUM7OEdBTFUscUJBQXFCO2tHQUFyQixxQkFBcUI7OzJGQUFyQixxQkFBcUI7a0JBSmpDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGNBQWM7b0JBQ3hCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQjs4QkFJQyxTQUFTO3NCQURSLFlBQVk7dUJBQUMsZUFBZSxFQUFFLENBQUMsUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBIb3N0TGlzdGVuZXIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gIHNlbGVjdG9yOiAncHJldmVudEVudGVyJyxcclxuICBzdGFuZGFsb25lOiB0cnVlXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBQcmV2ZW50RW50ZXJEaXJlY3RpdmUge1xyXG5cclxuICBASG9zdExpc3RlbmVyKCdrZXlkb3duLmVudGVyJywgWyckZXZlbnQnXSlcclxuICBvbktleURvd24oKSB7XHJcbiAgICAgIHJldHVybiBmYWxzZVxyXG4gIH1cclxufVxyXG4iXX0=

package/esm2022/utilities/directives/stop-propagation.directive.mjs

@@ -0,0 +1,26 @@
+import { Directive, HostListener } from "@angular/core";
+import * as i0 from "@angular/core";
+export class StopPropagationDirective {
+    onClick(event) {
+        event.stopPropagation();
+    }
+    onMousedown(event) {
+        event.stopPropagation();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: StopPropagationDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.2", type: StopPropagationDirective, isStandalone: true, selector: "[stop-propagation]", host: { listeners: { "click": "onClick($event)", "mousedown": "onMousedown($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: StopPropagationDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[stop-propagation]",
+                    standalone: true
+                }]
+        }], propDecorators: { onClick: [{
+                type: HostListener,
+                args: ["click", ["$event"]]
+            }], onMousedown: [{
+                type: HostListener,
+                args: ["mousedown", ["$event"]]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcC1wcm9wYWdhdGlvbi5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXV0aWxpdGllcy9zcmMvdXRpbGl0aWVzL2RpcmVjdGl2ZXMvc3RvcC1wcm9wYWdhdGlvbi5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSxZQUFZLEVBQUMsTUFBTSxlQUFlLENBQUM7O0FBTXRELE1BQU0sT0FBTyx3QkFBd0I7SUFHMUIsT0FBTyxDQUFDLEtBQVU7UUFFckIsS0FBSyxDQUFDLGVBQWUsRUFBRSxDQUFDO0lBQzVCLENBQUM7SUFHTSxXQUFXLENBQUMsS0FBVTtRQUV6QixLQUFLLENBQUMsZUFBZSxFQUFFLENBQUM7SUFDNUIsQ0FBQzs4R0FaUSx3QkFBd0I7a0dBQXhCLHdCQUF3Qjs7MkZBQXhCLHdCQUF3QjtrQkFKcEMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsb0JBQW9CO29CQUM5QixVQUFVLEVBQUUsSUFBSTtpQkFDbkI7OEJBSVUsT0FBTztzQkFEYixZQUFZO3VCQUFDLE9BQU8sRUFBRSxDQUFDLFFBQVEsQ0FBQztnQkFPMUIsV0FBVztzQkFEakIsWUFBWTt1QkFBQyxXQUFXLEVBQUUsQ0FBQyxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RpcmVjdGl2ZSwgSG9zdExpc3RlbmVyfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcbiAgICBzZWxlY3RvcjogXCJbc3RvcC1wcm9wYWdhdGlvbl1cIixcclxuICAgIHN0YW5kYWxvbmU6IHRydWVcclxufSlcclxuZXhwb3J0IGNsYXNzIFN0b3BQcm9wYWdhdGlvbkRpcmVjdGl2ZVxyXG57XHJcbiAgICBASG9zdExpc3RlbmVyKFwiY2xpY2tcIiwgW1wiJGV2ZW50XCJdKVxyXG4gICAgcHVibGljIG9uQ2xpY2soZXZlbnQ6IGFueSk6IHZvaWRcclxuICAgIHtcclxuICAgICAgICBldmVudC5zdG9wUHJvcGFnYXRpb24oKTtcclxuICAgIH1cclxuXHJcbiAgICBASG9zdExpc3RlbmVyKFwibW91c2Vkb3duXCIsIFtcIiRldmVudFwiXSlcclxuICAgIHB1YmxpYyBvbk1vdXNlZG93bihldmVudDogYW55KTogdm9pZFxyXG4gICAge1xyXG4gICAgICAgIGV2ZW50LnN0b3BQcm9wYWdhdGlvbigpO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2022/utilities/directives/styler.mjs

@@ -0,0 +1,42 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class StylerDirective {
+    set styler(styles) {
+        const toApply = Object.entries(styles ?? {}).reduce((acc, [key, val]) => {
+            if (typeof (val) === 'string') {
+                acc[key] = val;
+                this.el.nativeElement.style[key] = val;
+            }
+            else if (val?.condition === true || val?.condition(this.element)) {
+                const value = typeof (val.value) === 'string' ? val.value : val?.value(this.element);
+                acc[key] = value;
+                this.el.nativeElement.style[key] = value;
+            }
+            return acc;
+        }, {});
+        Object.keys(this.stylesApplied).filter(key => !Object.keys(toApply).includes(key)).forEach(key => {
+            this.renderer.removeStyle(this.el.nativeElement, key);
+        });
+        this.stylesApplied = toApply;
+    }
+    ;
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.stylesApplied = {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: StylerDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.2", type: StylerDirective, isStandalone: true, selector: "[styler]", inputs: { element: "element", styler: "styler" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: StylerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[styler]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { element: [{
+                type: Input
+            }], styler: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utilities/directives/trim-whitespace.directive.mjs

@@ -0,0 +1,30 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TrimWhitespaceDirective {
+    constructor(elem) {
+        this.elem = elem;
+    }
+    onBlur() {
+        const inputString = this.elem.nativeElement.value;
+        if (inputString) {
+            const newValue = inputString.trim().replace(/\t/g, '');
+            if (inputString !== newValue) {
+                this.elem.nativeElement.value = newValue;
+                this.elem.nativeElement.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TrimWhitespaceDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.2", type: TrimWhitespaceDirective, isStandalone: true, selector: "input[trimWhitespace]", host: { listeners: { "blur": "onBlur()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TrimWhitespaceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[trimWhitespace]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { onBlur: [{
+                type: HostListener,
+                args: ['blur']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utilities/index.mjs

@@ -0,0 +1,16 @@
+export * from './directives/prevent-enter.directive';
+export * from './directives/stop-propagation.directive';
+export * from './directives/auto-focus.directive';
+export * from './directives/clickSubject';
+export * from './directives/clickEmitterDirective';
+export * from './directives/dialog';
+export * from './directives/styler';
+export * from './directives/mat-toggle-group-directive';
+export * from './directives/trim-whitespace.directive';
+export * from './pipes/function.pipe';
+export * from './pipes/phone.pipe';
+export * from './pipes/space-case.pipes';
+export * from './directives/dialog-service';
+export * from './directives/conditional-classes.directive';
+export * from './module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXV0aWxpdGllcy9zcmMvdXRpbGl0aWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLHdDQUF3QyxDQUFDO0FBRXZELGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLDBCQUEwQixDQUFDO0FBRXpDLGNBQWMsNkJBQTZCLENBQUM7QUFFNUMsY0FBYyw0Q0FBNEMsQ0FBQTtBQUcxRCxjQUFjLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy9wcmV2ZW50LWVudGVyLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy9zdG9wLXByb3BhZ2F0aW9uLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy9hdXRvLWZvY3VzLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy9jbGlja1N1YmplY3QnO1xyXG5leHBvcnQgKiBmcm9tICcuL2RpcmVjdGl2ZXMvY2xpY2tFbWl0dGVyRGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3RpdmVzL2RpYWxvZyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy9zdHlsZXInO1xyXG5leHBvcnQgKiBmcm9tICcuL2RpcmVjdGl2ZXMvbWF0LXRvZ2dsZS1ncm91cC1kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2RpcmVjdGl2ZXMvdHJpbS13aGl0ZXNwYWNlLmRpcmVjdGl2ZSc7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL3BpcGVzL2Z1bmN0aW9uLnBpcGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL3BpcGVzL3Bob25lLnBpcGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL3BpcGVzL3NwYWNlLWNhc2UucGlwZXMnO1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3RpdmVzL2RpYWxvZy1zZXJ2aWNlJztcclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy9jb25kaXRpb25hbC1jbGFzc2VzLmRpcmVjdGl2ZSdcclxuXHJcblxyXG5leHBvcnQgKiBmcm9tICcuL21vZHVsZSc7XHJcblxyXG5cclxuIl19

package/esm2022/utilities/module.mjs

@@ -0,0 +1,90 @@
+import { NgModule } from "@angular/core";
+import { AutoFocusDirective } from "./directives/auto-focus.directive";
+import { ClickEmitterDirective } from "./directives/clickEmitterDirective";
+import { ClickSubjectDirective } from "./directives/clickSubject";
+import { ConditionalClassesDirective } from "./directives/conditional-classes.directive";
+import { DialogDirective } from "./directives/dialog";
+import { DialogService } from "./directives/dialog-service";
+import { MatSlideToggleGroupDirective } from "./directives/mat-toggle-group-directive";
+import { PreventEnterDirective } from "./directives/prevent-enter.directive";
+import { StopPropagationDirective } from "./directives/stop-propagation.directive";
+import { TrimWhitespaceDirective } from "./directives/trim-whitespace.directive";
+import { StylerDirective } from "./directives/styler";
+import { FunctionPipe } from "./pipes/function.pipe";
+import { PhoneNumberPipe } from "./pipes/phone.pipe";
+import { SpaceCasePipe } from "./pipes/space-case.pipes";
+import * as i0 from "@angular/core";
+export class UtilitiesModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: UtilitiesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: UtilitiesModule, imports: [SpaceCasePipe,
+            PhoneNumberPipe,
+            FunctionPipe,
+            StopPropagationDirective,
+            StylerDirective,
+            PreventEnterDirective,
+            AutoFocusDirective,
+            TrimWhitespaceDirective,
+            ClickSubjectDirective,
+            ClickEmitterDirective,
+            DialogDirective,
+            MatSlideToggleGroupDirective,
+            ConditionalClassesDirective], exports: [StopPropagationDirective,
+            PreventEnterDirective,
+            SpaceCasePipe,
+            PhoneNumberPipe,
+            FunctionPipe,
+            StopPropagationDirective,
+            TrimWhitespaceDirective,
+            StylerDirective,
+            PreventEnterDirective,
+            AutoFocusDirective,
+            ClickSubjectDirective,
+            ClickEmitterDirective,
+            DialogDirective,
+            MatSlideToggleGroupDirective,
+            ConditionalClassesDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: UtilitiesModule, providers: [
+            DialogService
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: UtilitiesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [
+                        StopPropagationDirective,
+                        PreventEnterDirective,
+                        SpaceCasePipe,
+                        PhoneNumberPipe,
+                        FunctionPipe,
+                        StopPropagationDirective,
+                        TrimWhitespaceDirective,
+                        StylerDirective,
+                        PreventEnterDirective,
+                        AutoFocusDirective,
+                        ClickSubjectDirective,
+                        ClickEmitterDirective,
+                        DialogDirective,
+                        MatSlideToggleGroupDirective,
+                        ConditionalClassesDirective,
+                    ],
+                    imports: [
+                        SpaceCasePipe,
+                        PhoneNumberPipe,
+                        FunctionPipe,
+                        StopPropagationDirective,
+                        StylerDirective,
+                        PreventEnterDirective,
+                        AutoFocusDirective,
+                        TrimWhitespaceDirective,
+                        ClickSubjectDirective,
+                        ClickEmitterDirective,
+                        DialogDirective,
+                        MatSlideToggleGroupDirective,
+                        ConditionalClassesDirective,
+                    ],
+                    providers: [
+                        DialogService
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utilities/pipes/function.pipe.mjs

@@ -0,0 +1,22 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FunctionPipe {
+    transform(func, ...args) {
+        if (typeof func === 'string') {
+            const [instance, ...tail] = args;
+            const method = instance[func].bind(instance);
+            return method(...tail);
+        }
+        return func(...args);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: FunctionPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: FunctionPipe, isStandalone: true, name: "func" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: FunctionPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'func',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb24ucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdXRpbGl0aWVzL3NyYy91dGlsaXRpZXMvcGlwZXMvZnVuY3Rpb24ucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFNcEQsTUFBTSxPQUFPLFlBQVk7SUFDdkIsU0FBUyxDQUFJLElBQXVDLEVBQUUsR0FBRyxJQUFXO1FBQ2xFLElBQUcsT0FBTyxJQUFJLEtBQUssUUFBUSxFQUFFO1lBQzNCLE1BQU0sQ0FBQyxRQUFRLEVBQUUsR0FBRyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUM7WUFDakMsTUFBTSxNQUFNLEdBQUcsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUM3QyxPQUFPLE1BQU0sQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDO1NBQ3hCO1FBQ0MsT0FBTyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQztJQUN6QixDQUFDOzhHQVJVLFlBQVk7NEdBQVosWUFBWTs7MkZBQVosWUFBWTtrQkFKeEIsSUFBSTttQkFBQztvQkFDSixJQUFJLEVBQUUsTUFBTTtvQkFDWixVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5AUGlwZSh7XHJcbiAgbmFtZTogJ2Z1bmMnLFxyXG4gIHN0YW5kYWxvbmU6IHRydWVcclxufSlcclxuZXhwb3J0IGNsYXNzIEZ1bmN0aW9uUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xyXG4gIHRyYW5zZm9ybTxUPihmdW5jOiAoICguLi5hcmdzOiBhbnlbXSk9PiBUICkgfCBzdHJpbmcsIC4uLmFyZ3M6IGFueVtdKTogVCB7XHJcbiAgICBpZih0eXBlb2YgZnVuYyA9PT0gJ3N0cmluZycpIHtcclxuICAgICAgY29uc3QgW2luc3RhbmNlLCAuLi50YWlsXSA9IGFyZ3M7XHJcbiAgICAgIGNvbnN0IG1ldGhvZCA9IGluc3RhbmNlW2Z1bmNdLmJpbmQoaW5zdGFuY2UpO1xyXG4gICAgICByZXR1cm4gbWV0aG9kKC4uLnRhaWwpO1xyXG4gICAgfVxyXG4gICAgICByZXR1cm4gZnVuYyguLi5hcmdzKTtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/utilities/pipes/phone.pipe.mjs

@@ -0,0 +1,20 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PhoneNumberPipe {
+    transform(phoneNum) {
+        if (phoneNum) {
+            phoneNum = phoneNum.replace(/\D/g, '');
+            if (phoneNum[0] === '1') {
+                phoneNum = phoneNum.substring(1);
+            }
+            return '(' + phoneNum.slice(0, 3) + ') ' + phoneNum.slice(3, 6) + '-' + phoneNum.slice(6, 10) + ' ' + phoneNum.slice(10);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PhoneNumberPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: PhoneNumberPipe, isStandalone: true, name: "phone" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PhoneNumberPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'phone', standalone: true }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGhvbmUucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdXRpbGl0aWVzL3NyYy91dGlsaXRpZXMvcGlwZXMvcGhvbmUucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFHcEQsTUFBTSxPQUFPLGVBQWU7SUFFMUIsU0FBUyxDQUFDLFFBQWdCO1FBQ3hCLElBQUksUUFBUSxFQUFFO1lBQ1osUUFBUSxHQUFHLFFBQVEsQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQ3RDLElBQUcsUUFBUSxDQUFDLENBQUMsQ0FBQyxLQUFLLEdBQUcsRUFBRTtnQkFDdEIsUUFBUSxHQUFHLFFBQVEsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUM7YUFDbEM7WUFDRCxPQUFPLEdBQUcsR0FBSSxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxJQUFJLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEdBQUcsR0FBRyxHQUFHLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxHQUFHLEdBQUcsR0FBRyxRQUFRLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1NBQzNIO0lBQ0gsQ0FBQzs4R0FWVSxlQUFlOzRHQUFmLGVBQWU7OzJGQUFmLGVBQWU7a0JBRDNCLElBQUk7bUJBQUMsRUFBQyxJQUFJLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5AUGlwZSh7bmFtZTogJ3Bob25lJywgc3RhbmRhbG9uZTogdHJ1ZX0pXHJcbmV4cG9ydCBjbGFzcyBQaG9uZU51bWJlclBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcclxuXHJcbiAgdHJhbnNmb3JtKHBob25lTnVtOiBzdHJpbmcpOiBhbnkge1xyXG4gICAgaWYgKHBob25lTnVtKSB7XHJcbiAgICAgIHBob25lTnVtID0gcGhvbmVOdW0ucmVwbGFjZSgvXFxEL2csJycpO1xyXG4gICAgICBpZihwaG9uZU51bVswXSA9PT0gJzEnKSB7XHJcbiAgICAgICAgcGhvbmVOdW0gPSBwaG9uZU51bS5zdWJzdHJpbmcoMSk7XHJcbiAgICAgIH1cclxuICAgICAgcmV0dXJuICcoJyArICBwaG9uZU51bS5zbGljZSgwLCAzKSArICcpICcgKyBwaG9uZU51bS5zbGljZSgzLCA2KSArICctJyArIHBob25lTnVtLnNsaWNlKDYsIDEwKSArICcgJyArIHBob25lTnVtLnNsaWNlKDEwKTtcclxuICAgIH1cclxuICB9XHJcbn1cclxuIl19

package/esm2022/utilities/pipes/space-case.pipes.mjs

@@ -0,0 +1,28 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SpaceCasePipe {
+    transform(value) {
+        return spaceCase(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: SpaceCasePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: SpaceCasePipe, isStandalone: true, name: "spaceCase" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: SpaceCasePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'spaceCase', standalone: true }]
+        }] });
+/**
+ * Adds a space before uppercase letters that either
+ * 1. follows a lowercase letter or digit
+ * 2. or precedes a lowercase letter and follows an alpha-numeric character
+ *
+ * Uppercases the first digit
+ *
+ * Turns underscores into spaces
+ */
+export function spaceCase(value) {
+    const phrase = value?.replace(/([a-z0-9])([A-Z])|([a-zA-Z0-9])([A-Z])(?=[a-z])|_/g, '$1$3 $2$4');
+    // uppercase the first character of every word
+    return phrase?.replace(/(^| )(\w)/g, x => x.toUpperCase());
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BhY2UtY2FzZS5waXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdXRpbGl0aWVzL3NyYy91dGlsaXRpZXMvcGlwZXMvc3BhY2UtY2FzZS5waXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFHcEQsTUFBTSxPQUFPLGFBQWE7SUFDeEIsU0FBUyxDQUFDLEtBQWE7UUFDckIsT0FBUSxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDM0IsQ0FBQzs4R0FIVSxhQUFhOzRHQUFiLGFBQWE7OzJGQUFiLGFBQWE7a0JBRHpCLElBQUk7bUJBQUMsRUFBQyxJQUFJLEVBQUUsV0FBVyxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUM7O0FBTzNDOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxVQUFVLFNBQVMsQ0FBQyxLQUFhO0lBQ3JDLE1BQU0sTUFBTSxHQUFHLEtBQUssRUFBRSxPQUFPLENBQUMsb0RBQW9ELEVBQUUsV0FBVyxDQUFDLENBQUE7SUFDaEcsOENBQThDO0lBQzlDLE9BQU8sTUFBTSxFQUFFLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQztBQUM3RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQFBpcGUoe25hbWU6ICdzcGFjZUNhc2UnLCBzdGFuZGFsb25lOiB0cnVlfSlcclxuZXhwb3J0IGNsYXNzIFNwYWNlQ2FzZVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcclxuICB0cmFuc2Zvcm0odmFsdWU6IHN0cmluZyk6IHN0cmluZyB7XHJcbiAgICByZXR1cm4gIHNwYWNlQ2FzZSh2YWx1ZSk7XHJcbiAgfVxyXG59XHJcblxyXG4vKipcclxuICogQWRkcyBhIHNwYWNlIGJlZm9yZSB1cHBlcmNhc2UgbGV0dGVycyB0aGF0IGVpdGhlclxyXG4gKiAxLiBmb2xsb3dzIGEgbG93ZXJjYXNlIGxldHRlciBvciBkaWdpdFxyXG4gKiAyLiBvciBwcmVjZWRlcyBhIGxvd2VyY2FzZSBsZXR0ZXIgYW5kIGZvbGxvd3MgYW4gYWxwaGEtbnVtZXJpYyBjaGFyYWN0ZXJcclxuICogXHJcbiAqIFVwcGVyY2FzZXMgdGhlIGZpcnN0IGRpZ2l0XHJcbiAqIFxyXG4gKiBUdXJucyB1bmRlcnNjb3JlcyBpbnRvIHNwYWNlc1xyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIHNwYWNlQ2FzZSh2YWx1ZTogc3RyaW5nKXtcclxuICBjb25zdCBwaHJhc2UgPSB2YWx1ZT8ucmVwbGFjZSgvKFthLXowLTldKShbQS1aXSl8KFthLXpBLVowLTldKShbQS1aXSkoPz1bYS16XSl8Xy9nLCAnJDEkMyAkMiQ0JylcclxuICAvLyB1cHBlcmNhc2UgdGhlIGZpcnN0IGNoYXJhY3RlciBvZiBldmVyeSB3b3JkXHJcbiAgcmV0dXJuIHBocmFzZT8ucmVwbGFjZSgvKF58ICkoXFx3KS9nLCB4ID0+IHgudG9VcHBlckNhc2UoKSk7XHJcbn1cclxuIl19