@one-paragon/angular-utilities 1.2.12 → 1.2.13

package/esm2022/utilities/directives/dialog.mjs

@@ -0,0 +1,145 @@
+import { Directive, TemplateRef, Input, Component, Output, EventEmitter, ViewContainerRef, Injector, ChangeDetectionStrategy, inject, untracked, isSignal } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { Subject } from 'rxjs';
+import { DialogService } from './dialog-service';
+import { subscriber } from '../../rxjs';
+import { toObservable } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+export class DialogWrapper {
+    vcr = inject(ViewContainerRef);
+    viewEmbedded = false;
+    viewContext = {
+        close: () => { },
+    };
+    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;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DialogWrapper, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.2", type: DialogWrapper, isStandalone: true, selector: "dialog-wrapper", ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DialogWrapper, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dialog-wrapper',
+                    template: ``,
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+const defaultDialogConfig = {
+    maxHeight: '95vh',
+};
+export class DialogDirective {
+    templateRef = inject(TemplateRef);
+    dialog = inject(MatDialog);
+    service = inject(DialogService);
+    opDialogClosed = new EventEmitter();
+    _dialogConfig = defaultDialogConfig;
+    opDialogAddDialogClass = true;
+    set opDialogConfig(config) {
+        this._dialogConfig = { ...defaultDialogConfig, ...config };
+    }
+    get opDialogConfig() {
+        return this._dialogConfig;
+    }
+    injector = inject(Injector);
+    subscriber = subscriber(this.injector);
+    set setControl(i) {
+        let o;
+        if (isSignal(i)) {
+            o = toObservable(i, { injector: this.injector });
+        }
+        else {
+            o = i;
+        }
+        untracked(() => {
+            this.subscriber.on(o, this.setDataAndState);
+        });
+    }
+    nativeElement;
+    dialogRef;
+    componentWrapper;
+    _data = new Subject();
+    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();
+        });
+    }
+    setDataAndState = (data) => {
+        if (data) {
+            this.opDialogConfig.data = data;
+            this.setDialogState(true);
+        }
+        else {
+            this.setDialogState(false);
+        }
+    };
+    setDialogState(open) {
+        if (open) {
+            if (!this.dialogRef) {
+                this.initDialog();
+            }
+            else {
+                this.componentWrapper.data = this.opDialogConfig.data;
+            }
+        }
+        else if (!open && this.dialogRef) {
+            this.dialogRef.close();
+        }
+    }
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DialogDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: DialogDirective, isStandalone: true, selector: "[opDialog]", inputs: { opDialogAddDialogClass: "opDialogAddDialogClass", opDialogConfig: "opDialogConfig", setControl: ["opDialog", "setControl"], nativeElement: ["opDialogOrigin", "nativeElement"] }, outputs: { opDialogClosed: "opDialogClosed" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DialogDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[opDialog]', standalone: true }]
+        }], propDecorators: { opDialogClosed: [{
+                type: Output
+            }], opDialogAddDialogClass: [{
+                type: Input
+            }], opDialogConfig: [{
+                type: Input
+            }], setControl: [{
+                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, input, inject, effect, untracked, Signal, isSignal, signal } from '@angular/core';\r\nimport { MatDialog, MatDialogRef, MatDialogConfig } from '@angular/material/dialog';\r\nimport { Observable, Subscription, Subject, isObservable } from 'rxjs';\r\nimport { switchAll } from 'rxjs/operators';\r\nimport { DialogService } from './dialog-service';\r\nimport { subscriber } from '../../rxjs';\r\nimport { toObservable } from '@angular/core/rxjs-interop';\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  private vcr = inject(ViewContainerRef);\r\n\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\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> {\r\n  private templateRef = inject<TemplateRef<DialogViewContext<T>>>(TemplateRef);\r\n  private dialog = inject(MatDialog);\r\n  private service = inject(DialogService);\r\n\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  injector = inject(Injector);\r\n  subscriber = subscriber(this.injector);\r\n  @Input('opDialog') set setControl(i: Observable<T> | Signal<T>){\r\n    let o: Observable<T>;\r\n    if(isSignal(i)){\r\n      o = toObservable<T>(i, { injector: this.injector })\r\n    } else {\r\n      o = i;\r\n    }\r\n    untracked(() => {\r\n      this.subscriber.on(o, this.setDataAndState);\r\n    });\r\n  } \r\n\r\n  @Input('opDialogOrigin') nativeElement? : HTMLElement;\r\n  dialogRef?: MatDialogRef<any, boolean>;\r\n  componentWrapper?: DialogWrapper<T>;\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  setDataAndState = (data: T) => {\r\n    if (data){\r\n      this.opDialogConfig.data = data;\r\n      this.setDialogState(true);\r\n    } else {\r\n      this.setDialogState(false);\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  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,59 @@
+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 {
+    allowMultiple = false;
+    _toggles;
+    set toggles(val) {
+        this._toggles = val;
+        this._ready.next(true);
+    }
+    _ready = new ReplaySubject(1);
+    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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: MatSlideToggleGroupDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.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: "18.2.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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: PreventEnterDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: PreventEnterDirective, isStandalone: true, selector: "preventEnter", host: { listeners: { "keydown.enter": "onKeyDown($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldmVudC1lbnRlci5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXV0aWxpdGllcy9zcmMvdXRpbGl0aWVzL2RpcmVjdGl2ZXMvcHJldmVudC1lbnRlci5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTXhELE1BQU0sT0FBTyxxQkFBcUI7SUFHaEMsU0FBUztRQUNMLE9BQU8sS0FBSyxDQUFBO0lBQ2hCLENBQUM7dUdBTFUscUJBQXFCOzJGQUFyQixxQkFBcUI7OzJGQUFyQixxQkFBcUI7a0JBSmpDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGNBQWM7b0JBQ3hCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQjs4QkFJQyxTQUFTO3NCQURSLFlBQVk7dUJBQUMsZUFBZSxFQUFFLENBQUMsUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBIb3N0TGlzdGVuZXIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gIHNlbGVjdG9yOiAncHJldmVudEVudGVyJyxcclxuICBzdGFuZGFsb25lOiB0cnVlXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBQcmV2ZW50RW50ZXJEaXJlY3RpdmUge1xyXG5cclxuICBASG9zdExpc3RlbmVyKCdrZXlkb3duLmVudGVyJywgWyckZXZlbnQnXSlcclxuICBvbktleURvd24oKSB7XHJcbiAgICAgIHJldHVybiBmYWxzZVxyXG4gIH1cclxufVxyXG4iXX0=

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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: StopPropagationDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.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: "18.2.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcC1wcm9wYWdhdGlvbi5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXV0aWxpdGllcy9zcmMvdXRpbGl0aWVzL2RpcmVjdGl2ZXMvc3RvcC1wcm9wYWdhdGlvbi5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSxZQUFZLEVBQUMsTUFBTSxlQUFlLENBQUM7O0FBTXRELE1BQU0sT0FBTyx3QkFBd0I7SUFHMUIsT0FBTyxDQUFDLEtBQVU7UUFFckIsS0FBSyxDQUFDLGVBQWUsRUFBRSxDQUFDO0lBQzVCLENBQUM7SUFHTSxXQUFXLENBQUMsS0FBVTtRQUV6QixLQUFLLENBQUMsZUFBZSxFQUFFLENBQUM7SUFDNUIsQ0FBQzt1R0FaUSx3QkFBd0I7MkZBQXhCLHdCQUF3Qjs7MkZBQXhCLHdCQUF3QjtrQkFKcEMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsb0JBQW9CO29CQUM5QixVQUFVLEVBQUUsSUFBSTtpQkFDbkI7OEJBSVUsT0FBTztzQkFEYixZQUFZO3VCQUFDLE9BQU8sRUFBRSxDQUFDLFFBQVEsQ0FBQztnQkFPMUIsV0FBVztzQkFEakIsWUFBWTt1QkFBQyxXQUFXLEVBQUUsQ0FBQyxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RpcmVjdGl2ZSwgSG9zdExpc3RlbmVyfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcbiAgICBzZWxlY3RvcjogXCJbc3RvcC1wcm9wYWdhdGlvbl1cIixcclxuICAgIHN0YW5kYWxvbmU6IHRydWVcclxufSlcclxuZXhwb3J0IGNsYXNzIFN0b3BQcm9wYWdhdGlvbkRpcmVjdGl2ZVxyXG57XHJcbiAgICBASG9zdExpc3RlbmVyKFwiY2xpY2tcIiwgW1wiJGV2ZW50XCJdKVxyXG4gICAgcHVibGljIG9uQ2xpY2soZXZlbnQ6IGFueSk6IHZvaWRcclxuICAgIHtcclxuICAgICAgICBldmVudC5zdG9wUHJvcGFnYXRpb24oKTtcclxuICAgIH1cclxuXHJcbiAgICBASG9zdExpc3RlbmVyKFwibW91c2Vkb3duXCIsIFtcIiRldmVudFwiXSlcclxuICAgIHB1YmxpYyBvbk1vdXNlZG93bihldmVudDogYW55KTogdm9pZFxyXG4gICAge1xyXG4gICAgICAgIGV2ZW50LnN0b3BQcm9wYWdhdGlvbigpO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2022/utilities/directives/styler.mjs

@@ -0,0 +1,41 @@
+import { Directive, Input, ElementRef, Renderer2, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+export class StylerDirective {
+    el = inject(ElementRef);
+    renderer = inject(Renderer2);
+    stylesApplied = {};
+    element;
+    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;
+    }
+    ;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: StylerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: StylerDirective, isStandalone: true, selector: "[styler]", inputs: { element: "element", styler: "styler" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: StylerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[styler]',
+                    standalone: true
+                }]
+        }], 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,28 @@
+import { Directive, ElementRef, HostListener, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TrimWhitespaceDirective {
+    elem = inject(ElementRef);
+    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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TrimWhitespaceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: TrimWhitespaceDirective, isStandalone: true, selector: "input[trimWhitespace]", host: { listeners: { "blur": "onBlur()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: TrimWhitespaceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[trimWhitespace]',
+                    standalone: true
+                }]
+        }], 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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: UtilitiesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.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 ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: UtilitiesModule, providers: [
+            DialogService
+        ] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: FunctionPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.2", ngImport: i0, type: FunctionPipe, isStandalone: true, name: "func" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: FunctionPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'func',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb24ucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdXRpbGl0aWVzL3NyYy91dGlsaXRpZXMvcGlwZXMvZnVuY3Rpb24ucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFNcEQsTUFBTSxPQUFPLFlBQVk7SUFDdkIsU0FBUyxDQUEwQixJQUE2QyxFQUFFLEdBQUcsSUFBaUI7UUFDcEcsSUFBRyxPQUFPLElBQUksS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUM1QixNQUFNLENBQUMsUUFBUSxFQUFFLEdBQUcsSUFBSSxDQUFDLEdBQUcsSUFBSSxDQUFDO1lBQ2pDLE1BQU0sTUFBTSxHQUFHLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7WUFDN0MsT0FBTyxNQUFNLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQztRQUN6QixDQUFDO1FBQ0MsT0FBTyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQztJQUN6QixDQUFDO3VHQVJVLFlBQVk7cUdBQVosWUFBWTs7MkZBQVosWUFBWTtrQkFKeEIsSUFBSTttQkFBQztvQkFDSixJQUFJLEVBQUUsTUFBTTtvQkFDWixVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5AUGlwZSh7XHJcbiAgbmFtZTogJ2Z1bmMnLFxyXG4gIHN0YW5kYWxvbmU6IHRydWVcclxufSlcclxuZXhwb3J0IGNsYXNzIEZ1bmN0aW9uUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xyXG4gIHRyYW5zZm9ybTxULCBUUGFyYW0gZXh0ZW5kcyBhbnlbXT4oZnVuYzogKCAoLi4uYXJnczogWy4uLlRQYXJhbV0pPT4gVCApIHwgc3RyaW5nLCAuLi5hcmdzOiBbLi4uVFBhcmFtXSk6IFQge1xyXG4gICAgaWYodHlwZW9mIGZ1bmMgPT09ICdzdHJpbmcnKSB7XHJcbiAgICAgIGNvbnN0IFtpbnN0YW5jZSwgLi4udGFpbF0gPSBhcmdzO1xyXG4gICAgICBjb25zdCBtZXRob2QgPSBpbnN0YW5jZVtmdW5jXS5iaW5kKGluc3RhbmNlKTtcclxuICAgICAgcmV0dXJuIG1ldGhvZCguLi50YWlsKTtcclxuICAgIH1cclxuICAgICAgcmV0dXJuIGZ1bmMoLi4uYXJncyk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: PhoneNumberPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.2", ngImport: i0, type: PhoneNumberPipe, isStandalone: true, name: "phone" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: PhoneNumberPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'phone', standalone: true }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGhvbmUucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdXRpbGl0aWVzL3NyYy91dGlsaXRpZXMvcGlwZXMvcGhvbmUucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFHcEQsTUFBTSxPQUFPLGVBQWU7SUFFMUIsU0FBUyxDQUFDLFFBQWdCO1FBQ3hCLElBQUksUUFBUSxFQUFFLENBQUM7WUFDYixRQUFRLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUMsRUFBRSxDQUFDLENBQUM7WUFDdEMsSUFBRyxRQUFRLENBQUMsQ0FBQyxDQUFDLEtBQUssR0FBRyxFQUFFLENBQUM7Z0JBQ3ZCLFFBQVEsR0FBRyxRQUFRLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ25DLENBQUM7WUFDRCxPQUFPLEdBQUcsR0FBSSxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxJQUFJLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEdBQUcsR0FBRyxHQUFHLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxHQUFHLEdBQUcsR0FBRyxRQUFRLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQzVILENBQUM7SUFDSCxDQUFDO3VHQVZVLGVBQWU7cUdBQWYsZUFBZTs7MkZBQWYsZUFBZTtrQkFEM0IsSUFBSTttQkFBQyxFQUFDLElBQUksRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBQaXBlKHtuYW1lOiAncGhvbmUnLCBzdGFuZGFsb25lOiB0cnVlfSlcclxuZXhwb3J0IGNsYXNzIFBob25lTnVtYmVyUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xyXG5cclxuICB0cmFuc2Zvcm0ocGhvbmVOdW06IHN0cmluZyk6IGFueSB7XHJcbiAgICBpZiAocGhvbmVOdW0pIHtcclxuICAgICAgcGhvbmVOdW0gPSBwaG9uZU51bS5yZXBsYWNlKC9cXEQvZywnJyk7XHJcbiAgICAgIGlmKHBob25lTnVtWzBdID09PSAnMScpIHtcclxuICAgICAgICBwaG9uZU51bSA9IHBob25lTnVtLnN1YnN0cmluZygxKTtcclxuICAgICAgfVxyXG4gICAgICByZXR1cm4gJygnICsgIHBob25lTnVtLnNsaWNlKDAsIDMpICsgJykgJyArIHBob25lTnVtLnNsaWNlKDMsIDYpICsgJy0nICsgcGhvbmVOdW0uc2xpY2UoNiwgMTApICsgJyAnICsgcGhvbmVOdW0uc2xpY2UoMTApO1xyXG4gICAgfVxyXG4gIH1cclxufVxyXG4iXX0=

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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: SpaceCasePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.2", ngImport: i0, type: SpaceCasePipe, isStandalone: true, name: "spaceCase" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BhY2UtY2FzZS5waXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdXRpbGl0aWVzL3NyYy91dGlsaXRpZXMvcGlwZXMvc3BhY2UtY2FzZS5waXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFHcEQsTUFBTSxPQUFPLGFBQWE7SUFDeEIsU0FBUyxDQUFDLEtBQWE7UUFDckIsT0FBUSxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDM0IsQ0FBQzt1R0FIVSxhQUFhO3FHQUFiLGFBQWE7OzJGQUFiLGFBQWE7a0JBRHpCLElBQUk7bUJBQUMsRUFBQyxJQUFJLEVBQUUsV0FBVyxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUM7O0FBTzNDOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxVQUFVLFNBQVMsQ0FBQyxLQUFhO0lBQ3JDLE1BQU0sTUFBTSxHQUFHLEtBQUssRUFBRSxPQUFPLENBQUMsb0RBQW9ELEVBQUUsV0FBVyxDQUFDLENBQUE7SUFDaEcsOENBQThDO0lBQzlDLE9BQU8sTUFBTSxFQUFFLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQztBQUM3RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQFBpcGUoe25hbWU6ICdzcGFjZUNhc2UnLCBzdGFuZGFsb25lOiB0cnVlfSlcclxuZXhwb3J0IGNsYXNzIFNwYWNlQ2FzZVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcclxuICB0cmFuc2Zvcm0odmFsdWU6IHN0cmluZyk6IHN0cmluZyB7XHJcbiAgICByZXR1cm4gIHNwYWNlQ2FzZSh2YWx1ZSk7XHJcbiAgfVxyXG59XHJcblxyXG4vKipcclxuICogQWRkcyBhIHNwYWNlIGJlZm9yZSB1cHBlcmNhc2UgbGV0dGVycyB0aGF0IGVpdGhlclxyXG4gKiAxLiBmb2xsb3dzIGEgbG93ZXJjYXNlIGxldHRlciBvciBkaWdpdFxyXG4gKiAyLiBvciBwcmVjZWRlcyBhIGxvd2VyY2FzZSBsZXR0ZXIgYW5kIGZvbGxvd3MgYW4gYWxwaGEtbnVtZXJpYyBjaGFyYWN0ZXJcclxuICogXHJcbiAqIFVwcGVyY2FzZXMgdGhlIGZpcnN0IGRpZ2l0XHJcbiAqIFxyXG4gKiBUdXJucyB1bmRlcnNjb3JlcyBpbnRvIHNwYWNlc1xyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIHNwYWNlQ2FzZSh2YWx1ZTogc3RyaW5nKXtcclxuICBjb25zdCBwaHJhc2UgPSB2YWx1ZT8ucmVwbGFjZSgvKFthLXowLTldKShbQS1aXSl8KFthLXpBLVowLTldKShbQS1aXSkoPz1bYS16XSl8Xy9nLCAnJDEkMyAkMiQ0JylcclxuICAvLyB1cHBlcmNhc2UgdGhlIGZpcnN0IGNoYXJhY3RlciBvZiBldmVyeSB3b3JkXHJcbiAgcmV0dXJuIHBocmFzZT8ucmVwbGFjZSgvKF58ICkoXFx3KS9nLCB4ID0+IHgudG9VcHBlckNhc2UoKSk7XHJcbn1cclxuIl19