ngx-color 7.2.0 → 7.3.3

package/esm2020/circle/circle-swatch.component.mjs

@@ -0,0 +1,85 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-color";
+export class CircleSwatchComponent {
+    constructor() {
+        this.circleSize = 28;
+        this.circleSpacing = 14;
+        this.focus = false;
+        this.onClick = new EventEmitter();
+        this.onSwatchHover = new EventEmitter();
+        this.focusStyle = {};
+        this.swatchStyle = {
+            borderRadius: '50%',
+            background: 'transparent',
+            transition: '100ms box-shadow ease 0s',
+        };
+    }
+    ngOnChanges() {
+        this.swatchStyle.boxShadow = `inset 0 0 0 ${this.circleSize / 2}px ${this.color}`;
+        this.focusStyle.boxShadow = `inset 0 0 0 ${this.circleSize / 2}px ${this.color}, 0 0 5px ${this.color}`;
+        if (this.focus) {
+            this.focusStyle.boxShadow = `inset 0 0 0 3px ${this.color}, 0 0 5px ${this.color}`;
+        }
+    }
+    handleClick({ hex, $event }) {
+        this.onClick.emit({ hex, $event });
+    }
+}
+CircleSwatchComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CircleSwatchComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CircleSwatchComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: CircleSwatchComponent, selector: "color-circle-swatch", inputs: { color: "color", circleSize: "circleSize", circleSpacing: "circleSpacing", focus: "focus" }, outputs: { onClick: "onClick", onSwatchHover: "onSwatchHover" }, usesOnChanges: true, ngImport: i0, template: `
+  <div class="circle-swatch"
+    [style.width.px]="circleSize" [style.height.px]="circleSize"
+    [style.margin-right.px]="circleSpacing" [style.margin-bottom.px]="circleSpacing"
+    >
+    <color-swatch
+      [color]="color" [style]="swatchStyle" [focus]="focus" [focusStyle]="focusStyle"
+      (onClick)="handleClick($event)" (onHover)="onSwatchHover.emit($event)">
+    </color-swatch>
+    <div class="clear"></div>
+  </div>
+  `, isInline: true, styles: [".circle-swatch{transform:scale(1);transition:transform .1s ease}.circle-swatch:hover{transform:scale(1.2)}\n"], components: [{ type: i1.SwatchComponent, selector: "color-swatch", inputs: ["color", "style", "focusStyle", "focus"], outputs: ["onClick", "onHover"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CircleSwatchComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'color-circle-swatch',
+                    template: `
+  <div class="circle-swatch"
+    [style.width.px]="circleSize" [style.height.px]="circleSize"
+    [style.margin-right.px]="circleSpacing" [style.margin-bottom.px]="circleSpacing"
+    >
+    <color-swatch
+      [color]="color" [style]="swatchStyle" [focus]="focus" [focusStyle]="focusStyle"
+      (onClick)="handleClick($event)" (onHover)="onSwatchHover.emit($event)">
+    </color-swatch>
+    <div class="clear"></div>
+  </div>
+  `,
+                    styles: [
+                        `
+  .circle-swatch {
+    transform: scale(1);
+    transition: transform 100ms ease;
+  }
+  .circle-swatch:hover {
+    transform: scale(1.2);
+  }
+  `,
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    preserveWhitespaces: false,
+                }]
+        }], propDecorators: { color: [{
+                type: Input
+            }], circleSize: [{
+                type: Input
+            }], circleSpacing: [{
+                type: Input
+            }], focus: [{
+                type: Input
+            }], onClick: [{
+                type: Output
+            }], onSwatchHover: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2lyY2xlLXN3YXRjaC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2NpcmNsZS9jaXJjbGUtc3dhdGNoLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsdUJBQXVCLEVBQ3ZCLFNBQVMsRUFDVCxZQUFZLEVBQ1osS0FBSyxFQUVMLE1BQU0sR0FDUCxNQUFNLGVBQWUsQ0FBQzs7O0FBOEJ2QixNQUFNLE9BQU8scUJBQXFCO0lBNUJsQztRQThCVyxlQUFVLEdBQUcsRUFBRSxDQUFDO1FBQ2hCLGtCQUFhLEdBQUcsRUFBRSxDQUFDO1FBQ25CLFVBQUssR0FBRyxLQUFLLENBQUM7UUFDYixZQUFPLEdBQUcsSUFBSSxZQUFZLEVBQU8sQ0FBQztRQUNsQyxrQkFBYSxHQUFHLElBQUksWUFBWSxFQUFPLENBQUM7UUFDbEQsZUFBVSxHQUEyQixFQUFFLENBQUM7UUFDeEMsZ0JBQVcsR0FBMkI7WUFDcEMsWUFBWSxFQUFFLEtBQUs7WUFDbkIsVUFBVSxFQUFFLGFBQWE7WUFDekIsVUFBVSxFQUFFLDBCQUEwQjtTQUN2QyxDQUFDO0tBWUg7SUFWQyxXQUFXO1FBQ1QsSUFBSSxDQUFDLFdBQVcsQ0FBQyxTQUFTLEdBQUcsZUFBZSxJQUFJLENBQUMsVUFBVSxHQUFHLENBQUMsTUFBTSxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDbEYsSUFBSSxDQUFDLFVBQVUsQ0FBQyxTQUFTLEdBQUcsZUFBZ0IsSUFBSSxDQUFDLFVBQVUsR0FBRyxDQUFFLE1BQU8sSUFBSSxDQUFDLEtBQU0sYUFBYyxJQUFJLENBQUMsS0FBTSxFQUFFLENBQUM7UUFDOUcsSUFBSSxJQUFJLENBQUMsS0FBSyxFQUFFO1lBQ2QsSUFBSSxDQUFDLFVBQVUsQ0FBQyxTQUFTLEdBQUcsbUJBQW9CLElBQUksQ0FBQyxLQUFNLGFBQWMsSUFBSSxDQUFDLEtBQU0sRUFBRSxDQUFDO1NBQ3hGO0lBQ0gsQ0FBQztJQUNELFdBQVcsQ0FBQyxFQUFFLEdBQUcsRUFBRSxNQUFNLEVBQUU7UUFDekIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxHQUFHLEVBQUUsTUFBTSxFQUFFLENBQUMsQ0FBQztJQUNyQyxDQUFDOztrSEF2QlUscUJBQXFCO3NHQUFyQixxQkFBcUIsdVBBMUJ0Qjs7Ozs7Ozs7Ozs7R0FXVDsyRkFlVSxxQkFBcUI7a0JBNUJqQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxxQkFBcUI7b0JBQy9CLFFBQVEsRUFBRTs7Ozs7Ozs7Ozs7R0FXVDtvQkFDRCxNQUFNLEVBQUU7d0JBQ047Ozs7Ozs7O0dBUUQ7cUJBQ0E7b0JBQ0QsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07b0JBQy9DLG1CQUFtQixFQUFFLEtBQUs7aUJBQzNCOzhCQUVVLEtBQUs7c0JBQWIsS0FBSztnQkFDRyxVQUFVO3NCQUFsQixLQUFLO2dCQUNHLGFBQWE7c0JBQXJCLEtBQUs7Z0JBQ0csS0FBSztzQkFBYixLQUFLO2dCQUNJLE9BQU87c0JBQWhCLE1BQU07Z0JBQ0csYUFBYTtzQkFBdEIsTUFBTSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIENoYW5nZURldGVjdGlvblN0cmF0ZWd5LFxuICBDb21wb25lbnQsXG4gIEV2ZW50RW1pdHRlcixcbiAgSW5wdXQsXG4gIE9uQ2hhbmdlcyxcbiAgT3V0cHV0LFxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnY29sb3ItY2lyY2xlLXN3YXRjaCcsXG4gIHRlbXBsYXRlOiBgXG4gIDxkaXYgY2xhc3M9XCJjaXJjbGUtc3dhdGNoXCJcbiAgICBbc3R5bGUud2lkdGgucHhdPVwiY2lyY2xlU2l6ZVwiIFtzdHlsZS5oZWlnaHQucHhdPVwiY2lyY2xlU2l6ZVwiXG4gICAgW3N0eWxlLm1hcmdpbi1yaWdodC5weF09XCJjaXJjbGVTcGFjaW5nXCIgW3N0eWxlLm1hcmdpbi1ib3R0b20ucHhdPVwiY2lyY2xlU3BhY2luZ1wiXG4gICAgPlxuICAgIDxjb2xvci1zd2F0Y2hcbiAgICAgIFtjb2xvcl09XCJjb2xvclwiIFtzdHlsZV09XCJzd2F0Y2hTdHlsZVwiIFtmb2N1c109XCJmb2N1c1wiIFtmb2N1c1N0eWxlXT1cImZvY3VzU3R5bGVcIlxuICAgICAgKG9uQ2xpY2spPVwiaGFuZGxlQ2xpY2soJGV2ZW50KVwiIChvbkhvdmVyKT1cIm9uU3dhdGNoSG92ZXIuZW1pdCgkZXZlbnQpXCI+XG4gICAgPC9jb2xvci1zd2F0Y2g+XG4gICAgPGRpdiBjbGFzcz1cImNsZWFyXCI+PC9kaXY+XG4gIDwvZGl2PlxuICBgLFxuICBzdHlsZXM6IFtcbiAgICBgXG4gIC5jaXJjbGUtc3dhdGNoIHtcbiAgICB0cmFuc2Zvcm06IHNjYWxlKDEpO1xuICAgIHRyYW5zaXRpb246IHRyYW5zZm9ybSAxMDBtcyBlYXNlO1xuICB9XG4gIC5jaXJjbGUtc3dhdGNoOmhvdmVyIHtcbiAgICB0cmFuc2Zvcm06IHNjYWxlKDEuMik7XG4gIH1cbiAgYCxcbiAgXSxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG4gIHByZXNlcnZlV2hpdGVzcGFjZXM6IGZhbHNlLFxufSlcbmV4cG9ydCBjbGFzcyBDaXJjbGVTd2F0Y2hDb21wb25lbnQgaW1wbGVtZW50cyBPbkNoYW5nZXMge1xuICBASW5wdXQoKSBjb2xvciE6IHN0cmluZztcbiAgQElucHV0KCkgY2lyY2xlU2l6ZSA9IDI4O1xuICBASW5wdXQoKSBjaXJjbGVTcGFjaW5nID0gMTQ7XG4gIEBJbnB1dCgpIGZvY3VzID0gZmFsc2U7XG4gIEBPdXRwdXQoKSBvbkNsaWNrID0gbmV3IEV2ZW50RW1pdHRlcjxhbnk+KCk7XG4gIEBPdXRwdXQoKSBvblN3YXRjaEhvdmVyID0gbmV3IEV2ZW50RW1pdHRlcjxhbnk+KCk7XG4gIGZvY3VzU3R5bGU6IFJlY29yZDxzdHJpbmcsIHN0cmluZz4gPSB7fTtcbiAgc3dhdGNoU3R5bGU6IFJlY29yZDxzdHJpbmcsIHN0cmluZz4gPSB7XG4gICAgYm9yZGVyUmFkaXVzOiAnNTAlJyxcbiAgICBiYWNrZ3JvdW5kOiAndHJhbnNwYXJlbnQnLFxuICAgIHRyYW5zaXRpb246ICcxMDBtcyBib3gtc2hhZG93IGVhc2UgMHMnLFxuICB9O1xuXG4gIG5nT25DaGFuZ2VzKCkge1xuICAgIHRoaXMuc3dhdGNoU3R5bGUuYm94U2hhZG93ID0gYGluc2V0IDAgMCAwICR7dGhpcy5jaXJjbGVTaXplIC8gMn1weCAke3RoaXMuY29sb3J9YDtcbiAgICB0aGlzLmZvY3VzU3R5bGUuYm94U2hhZG93ID0gYGluc2V0IDAgMCAwICR7IHRoaXMuY2lyY2xlU2l6ZSAvIDIgfXB4ICR7IHRoaXMuY29sb3IgfSwgMCAwIDVweCAkeyB0aGlzLmNvbG9yIH1gO1xuICAgIGlmICh0aGlzLmZvY3VzKSB7XG4gICAgICB0aGlzLmZvY3VzU3R5bGUuYm94U2hhZG93ID0gYGluc2V0IDAgMCAwIDNweCAkeyB0aGlzLmNvbG9yIH0sIDAgMCA1cHggJHsgdGhpcy5jb2xvciB9YDtcbiAgICB9XG4gIH1cbiAgaGFuZGxlQ2xpY2soeyBoZXgsICRldmVudCB9KSB7XG4gICAgdGhpcy5vbkNsaWNrLmVtaXQoeyBoZXgsICRldmVudCB9KTtcbiAgfVxufVxuIl19

package/esm2020/circle/circle.component.mjs

@@ -0,0 +1,148 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, forwardRef, Input, NgModule } from '@angular/core';
+import { amber, blue, blueGrey, brown, cyan, deepOrange, deepPurple, green, indigo, lightBlue, lightGreen, lime, orange, pink, purple, red, teal, yellow, } from 'material-colors';
+import { TinyColor } from '@ctrl/tinycolor';
+import { ColorWrap, isValidHex, SwatchModule } from 'ngx-color';
+import { CircleSwatchComponent } from './circle-swatch.component';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class CircleComponent extends ColorWrap {
+    constructor() {
+        super();
+        /** Pixel value for picker width */
+        this.width = 252;
+        /** Color squares to display */
+        this.colors = [
+            red['500'],
+            pink['500'],
+            purple['500'],
+            deepPurple['500'],
+            indigo['500'],
+            blue['500'],
+            lightBlue['500'],
+            cyan['500'],
+            teal['500'],
+            green['500'],
+            lightGreen['500'],
+            lime['500'],
+            yellow['500'],
+            amber['500'],
+            orange['500'],
+            deepOrange['500'],
+            brown['500'],
+            blueGrey['500'],
+        ];
+        /** Value for circle size */
+        this.circleSize = 28;
+        /** Value for spacing between circles */
+        this.circleSpacing = 14;
+    }
+    isActive(color) {
+        return new TinyColor(this.hex).equals(color);
+    }
+    handleBlockChange({ hex, $event }) {
+        if (isValidHex(hex)) {
+            this.handleChange({ hex, source: 'hex' }, $event);
+        }
+    }
+    handleValueChange({ data, $event }) {
+        this.handleChange(data, $event);
+    }
+}
+CircleComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CircleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CircleComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: CircleComponent, selector: "color-circle", inputs: { width: "width", colors: "colors", circleSize: "circleSize", circleSpacing: "circleSpacing" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => CircleComponent),
+            multi: true,
+        },
+        {
+            provide: ColorWrap,
+            useExisting: forwardRef(() => CircleComponent),
+        },
+    ], usesInheritance: true, ngImport: i0, template: `
+    <div
+      class="circle-picker {{ className }}"
+      [style.width.px]="width"
+      [style.margin-right.px]="-circleSpacing"
+      [style.margin-bottom.px]="-circleSpacing"
+    >
+      <color-circle-swatch
+        *ngFor="let color of colors"
+        [circleSize]="circleSize"
+        [circleSpacing]="circleSpacing"
+        [color]="color"
+        [focus]="isActive(color)"
+        (onClick)="handleBlockChange($event)"
+        (onSwatchHover)="onSwatchHover.emit($event)"
+      ></color-circle-swatch>
+    </div>
+  `, isInline: true, styles: [".circle-picker{display:flex;flex-wrap:wrap}\n"], components: [{ type: i0.forwardRef(function () { return CircleSwatchComponent; }), selector: "color-circle-swatch", inputs: ["color", "circleSize", "circleSpacing", "focus"], outputs: ["onClick", "onSwatchHover"] }], directives: [{ type: i0.forwardRef(function () { return i1.NgForOf; }), selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CircleComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'color-circle',
+                    template: `
+    <div
+      class="circle-picker {{ className }}"
+      [style.width.px]="width"
+      [style.margin-right.px]="-circleSpacing"
+      [style.margin-bottom.px]="-circleSpacing"
+    >
+      <color-circle-swatch
+        *ngFor="let color of colors"
+        [circleSize]="circleSize"
+        [circleSpacing]="circleSpacing"
+        [color]="color"
+        [focus]="isActive(color)"
+        (onClick)="handleBlockChange($event)"
+        (onSwatchHover)="onSwatchHover.emit($event)"
+      ></color-circle-swatch>
+    </div>
+  `,
+                    styles: [
+                        `
+      .circle-picker {
+        display: flex;
+        flex-wrap: wrap;
+      }
+    `,
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    preserveWhitespaces: false,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => CircleComponent),
+                            multi: true,
+                        },
+                        {
+                            provide: ColorWrap,
+                            useExisting: forwardRef(() => CircleComponent),
+                        },
+                    ]
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { width: [{
+                type: Input
+            }], colors: [{
+                type: Input
+            }], circleSize: [{
+                type: Input
+            }], circleSpacing: [{
+                type: Input
+            }] } });
+export class ColorCircleModule {
+}
+ColorCircleModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorCircleModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ColorCircleModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorCircleModule, declarations: [CircleComponent, CircleSwatchComponent], imports: [CommonModule, SwatchModule], exports: [CircleComponent, CircleSwatchComponent] });
+ColorCircleModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorCircleModule, imports: [[CommonModule, SwatchModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorCircleModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [CircleComponent, CircleSwatchComponent],
+                    exports: [CircleComponent, CircleSwatchComponent],
+                    imports: [CommonModule, SwatchModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/circle/ngx-color-circle.mjs

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

package/esm2020/circle/public_api.mjs

@@ -0,0 +1,3 @@
+export { CircleSwatchComponent } from './circle-swatch.component';
+export { CircleComponent, ColorCircleModule } from './circle.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvY2lyY2xlL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDbEUsT0FBTyxFQUFFLGVBQWUsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgQ2lyY2xlU3dhdGNoQ29tcG9uZW50IH0gZnJvbSAnLi9jaXJjbGUtc3dhdGNoLmNvbXBvbmVudCc7XG5leHBvcnQgeyBDaXJjbGVDb21wb25lbnQsIENvbG9yQ2lyY2xlTW9kdWxlIH0gZnJvbSAnLi9jaXJjbGUuY29tcG9uZW50JztcbiJdfQ==

package/esm2020/color-wrap.component.mjs

@@ -0,0 +1,163 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, forwardRef, Input, isDevMode, NgModule, Output, } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { debounceTime, tap } from 'rxjs/operators';
+import { simpleCheckForValidColor, toState } from './helpers/color';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+export var ColorMode;
+(function (ColorMode) {
+    ColorMode["HEX"] = "hex";
+    ColorMode["HSL"] = "hsl";
+    ColorMode["HSV"] = "hsv";
+    ColorMode["RGB"] = "rgb";
+})(ColorMode || (ColorMode = {}));
+export class ColorWrap {
+    constructor() {
+        /**
+         * Descriptors the return color format if the component is used with two-way binding
+         */
+        this.mode = ColorMode.HEX;
+        this.color = {
+            h: 250,
+            s: 0.5,
+            l: 0.2,
+            a: 1,
+        };
+        this.colorChange = new EventEmitter();
+        this.onChange = new EventEmitter();
+        this.onChangeComplete = new EventEmitter();
+        this.onSwatchHover = new EventEmitter();
+        this._onChangeCompleteSubscription = new Subscription();
+        this._onSwatchHoverSubscription = new Subscription();
+    }
+    ngOnInit() {
+        this.changes = this.onChange
+            .pipe(debounceTime(100), tap(event => {
+            this.onChangeComplete.emit(event);
+            switch (this.mode) {
+                case ColorMode.HEX:
+                    this.colorChange.emit(event.color.hex);
+                    break;
+                case ColorMode.HSL:
+                    this.colorChange.emit(event.color.hsl);
+                    break;
+                case ColorMode.HSV:
+                    this.colorChange.emit(event.color.hsv);
+                    break;
+                case ColorMode.RGB:
+                    this.colorChange.emit(event.color.rgb);
+                    break;
+                default:
+                    const msg = `The mode '${this.mode}' is not supported`;
+                    if (isDevMode()) {
+                        throw new Error(msg);
+                    }
+                    else {
+                        console.warn(msg);
+                    }
+                    break;
+            }
+        }))
+            .subscribe();
+        this.setState(toState(this.color, 0));
+        this.currentColor = this.hex;
+    }
+    ngOnChanges() {
+        this.setState(toState(this.color, this.oldHue));
+    }
+    ngOnDestroy() {
+        this.changes?.unsubscribe();
+        this._onChangeCompleteSubscription.unsubscribe();
+        this._onSwatchHoverSubscription.unsubscribe();
+    }
+    setState(data) {
+        this.oldHue = data.oldHue;
+        this.hsl = data.hsl;
+        this.hsv = data.hsv;
+        this.rgb = data.rgb;
+        this.hex = data.hex;
+        this.source = data.source;
+        this.afterValidChange();
+    }
+    handleChange(data, $event) {
+        const isValidColor = simpleCheckForValidColor(data);
+        if (isValidColor) {
+            const color = toState(data, data.h || this.oldHue, this.disableAlpha);
+            this.setState(color);
+            this.onChange.emit({ color, $event });
+            this.afterValidChange();
+        }
+    }
+    /** hook for components after a complete change */
+    afterValidChange() { }
+    handleSwatchHover(data, $event) {
+        const isValidColor = simpleCheckForValidColor(data);
+        if (isValidColor) {
+            const color = toState(data, data.h || this.oldHue);
+            this.setState(color);
+            this.onSwatchHover.emit({ color, $event });
+        }
+    }
+    registerOnChange(fn) {
+        this._onChangeCompleteSubscription.add(this.onChangeComplete.pipe(tap(event => fn(event.color.hex))).subscribe());
+    }
+    registerOnTouched(fn) {
+        this._onSwatchHoverSubscription.add(this.onSwatchHover.pipe(tap(() => fn())).subscribe());
+    }
+    setDisabledState(isDisabled) { }
+    writeValue(hex) {
+        this.color = hex;
+    }
+}
+ColorWrap.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrap, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ColorWrap.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ColorWrap, selector: "color-wrap", inputs: { className: "className", mode: "mode", color: "color" }, outputs: { colorChange: "colorChange", onChange: "onChange", onChangeComplete: "onChangeComplete", onSwatchHover: "onSwatchHover" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => ColorWrap),
+            multi: true,
+        }
+    ], usesOnChanges: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrap, decorators: [{
+            type: Component,
+            args: [{
+                    // create seletor base for test override property
+                    selector: 'color-wrap',
+                    template: ``,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => ColorWrap),
+                            multi: true,
+                        }
+                    ]
+                }]
+        }], propDecorators: { className: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], colorChange: [{
+                type: Output
+            }], onChange: [{
+                type: Output
+            }], onChangeComplete: [{
+                type: Output
+            }], onSwatchHover: [{
+                type: Output
+            }] } });
+export class ColorWrapModule {
+}
+ColorWrapModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrapModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ColorWrapModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrapModule, declarations: [ColorWrap], imports: [CommonModule], exports: [ColorWrap] });
+ColorWrapModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrapModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrapModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ColorWrap],
+                    exports: [ColorWrap],
+                    imports: [CommonModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"color-wrap.component.js","sourceRoot":"","sources":["../../src/lib/color-wrap.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  Component,\n  EventEmitter,\n  forwardRef,\n  Input,\n  isDevMode,\n  NgModule,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n} from '@angular/core';\n\nimport { Subscription } from 'rxjs';\nimport { debounceTime, tap } from 'rxjs/operators';\n\nimport { simpleCheckForValidColor, toState } from './helpers/color';\nimport { Color, HSLA, HSVA, RGBA } from './helpers/color.interfaces';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nexport interface ColorEvent {\n  $event: Event;\n  color: Color;\n}\n\nexport enum ColorMode {\n  HEX = 'hex',\n  HSL = 'hsl',\n  HSV = 'hsv',\n  RGB = 'rgb'\n}\n\n@Component({\n  // create seletor base for test override property\n  selector: 'color-wrap',\n  template: ``,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => ColorWrap),\n      multi: true,\n    }\n  ]\n})\nexport class ColorWrap implements OnInit, OnChanges, OnDestroy, ControlValueAccessor {\n  @Input() className?: string;\n\n  /**\n   * Descriptors the return color format if the component is used with two-way binding\n   */\n  @Input() mode: ColorMode = ColorMode.HEX;\n\n  @Input() color: HSLA | HSVA | RGBA | string = {\n    h: 250,\n    s: 0.5,\n    l: 0.2,\n    a: 1,\n  };\n  @Output() colorChange = new EventEmitter<HSLA | HSVA | RGBA | string>();\n  @Output() onChange = new EventEmitter<ColorEvent>();\n  @Output() onChangeComplete = new EventEmitter<ColorEvent>();\n  @Output() onSwatchHover = new EventEmitter<ColorEvent>();\n  oldHue!: number;\n  hsl!: HSLA;\n  hsv!: HSVA;\n  rgb!: RGBA;\n  hex!: string;\n  source!: string;\n  currentColor!: string;\n  changes?: Subscription;\n  disableAlpha?: boolean;\n\n  private _onChangeCompleteSubscription = new Subscription();\n  private _onSwatchHoverSubscription = new Subscription();\n\n  ngOnInit() {\n    this.changes = this.onChange\n      .pipe(\n        debounceTime(100),\n        tap(event => {\n          this.onChangeComplete.emit(event);\n          switch (this.mode) {\n            case ColorMode.HEX:\n              this.colorChange.emit(event.color.hex);\n              break;\n            case ColorMode.HSL:\n              this.colorChange.emit(event.color.hsl);\n              break;\n            case ColorMode.HSV:\n              this.colorChange.emit(event.color.hsv);\n              break;\n            case ColorMode.RGB:\n              this.colorChange.emit(event.color.rgb);\n              break;\n            default:\n              const msg = `The mode '${this.mode}' is not supported`;\n              if (isDevMode()) {\n                throw new Error(msg);\n              } else {\n                console.warn(msg);\n              }\n              break;\n          }\n        })\n      )\n      .subscribe();\n    this.setState(toState(this.color, 0));\n    this.currentColor = this.hex;\n  }\n  ngOnChanges() {\n    this.setState(toState(this.color, this.oldHue));\n  }\n  ngOnDestroy() {\n    this.changes?.unsubscribe();\n    this._onChangeCompleteSubscription.unsubscribe();\n    this._onSwatchHoverSubscription.unsubscribe();\n  }\n  setState(data) {\n    this.oldHue = data.oldHue;\n    this.hsl = data.hsl;\n    this.hsv = data.hsv;\n    this.rgb = data.rgb;\n    this.hex = data.hex;\n    this.source = data.source;\n    this.afterValidChange();\n  }\n  handleChange(data, $event) {\n    const isValidColor = simpleCheckForValidColor(data);\n    if (isValidColor) {\n      const color = toState(data, data.h || this.oldHue, this.disableAlpha);\n      this.setState(color);\n      this.onChange.emit({ color, $event });\n      this.afterValidChange();\n    }\n  }\n  /** hook for components after a complete change */\n  afterValidChange() {}\n\n  handleSwatchHover(data, $event) {\n    const isValidColor = simpleCheckForValidColor(data);\n    if (isValidColor) {\n      const color = toState(data, data.h || this.oldHue);\n      this.setState(color);\n      this.onSwatchHover.emit({ color, $event });\n    }\n  }\n\n  registerOnChange(fn: (hex: string) => void): void {\n    this._onChangeCompleteSubscription.add(this.onChangeComplete.pipe(\n      tap(event => fn(event.color.hex)),\n    ).subscribe());\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this._onSwatchHoverSubscription.add(this.onSwatchHover.pipe(\n      tap(() => fn()),\n    ).subscribe());\n  }\n\n  setDisabledState(isDisabled: boolean): void {}\n\n  writeValue(hex: string): void {\n    this.color = hex;\n  }\n\n}\n\n@NgModule({\n  declarations: [ColorWrap],\n  exports: [ColorWrap],\n  imports: [CommonModule],\n})\nexport class ColorWrapModule {}\n"]}

package/esm2020/compact/compact-color.component.mjs

@@ -0,0 +1,91 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import { getContrastingColor } from 'ngx-color';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-color";
+export class CompactColorComponent {
+    constructor() {
+        this.onClick = new EventEmitter();
+        this.onSwatchHover = new EventEmitter();
+        this.swatchStyle = {
+            width: '15px',
+            height: '15px',
+            float: 'left',
+            marginRight: '5px',
+            marginBottom: '5px',
+            position: 'relative',
+            cursor: 'pointer',
+        };
+        this.swatchFocus = {};
+        this.getContrastingColor = getContrastingColor;
+    }
+    ngOnChanges() {
+        this.swatchStyle.background = this.color;
+        this.swatchFocus.boxShadow = `0 0 4px ${this.color}`;
+        if (this.color.toLowerCase() === '#ffffff') {
+            this.swatchStyle.boxShadow = 'inset 0 0 0 1px #ddd';
+        }
+    }
+    handleClick({ hex, $event }) {
+        this.onClick.emit({ hex, $event });
+    }
+}
+CompactColorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CompactColorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CompactColorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: CompactColorComponent, selector: "color-compact-color", inputs: { color: "color", active: "active" }, outputs: { onClick: "onClick", onSwatchHover: "onSwatchHover" }, usesOnChanges: true, ngImport: i0, template: `
+  <div class="compact-color">
+    <color-swatch class="swatch"
+      [color]="color" [style]="swatchStyle"
+      [focusStyle]="swatchFocus"
+      (onClick)="handleClick($event)" (onHover)="onSwatchHover.emit($event)"
+      >
+      <div class="compact-dot"
+        [class.active]="active" [style.background]="getContrastingColor(color)"
+      ></div>
+    </color-swatch>
+  </div>
+  `, isInline: true, styles: [".compact-dot{position:absolute;top:5px;right:5px;bottom:5px;left:5px;border-radius:50%;opacity:0}.compact-dot.active{opacity:1}\n"], components: [{ type: i1.SwatchComponent, selector: "color-swatch", inputs: ["color", "style", "focusStyle", "focus"], outputs: ["onClick", "onHover"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CompactColorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'color-compact-color',
+                    template: `
+  <div class="compact-color">
+    <color-swatch class="swatch"
+      [color]="color" [style]="swatchStyle"
+      [focusStyle]="swatchFocus"
+      (onClick)="handleClick($event)" (onHover)="onSwatchHover.emit($event)"
+      >
+      <div class="compact-dot"
+        [class.active]="active" [style.background]="getContrastingColor(color)"
+      ></div>
+    </color-swatch>
+  </div>
+  `,
+                    styles: [
+                        `
+  .compact-dot {
+    position: absolute;
+    top: 5px;
+    right: 5px;
+    bottom: 5px;
+    left: 5px;
+    border-radius: 50%;
+    opacity: 0;
+  }
+  .compact-dot.active {
+    opacity: 1;
+  }
+  `,
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    preserveWhitespaces: false,
+                }]
+        }], propDecorators: { color: [{
+                type: Input
+            }], active: [{
+                type: Input
+            }], onClick: [{
+                type: Output
+            }], onSwatchHover: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGFjdC1jb2xvci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2NvbXBhY3QvY29tcGFjdC1jb2xvci5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLHVCQUF1QixFQUN2QixTQUFTLEVBQ1QsWUFBWSxFQUNaLEtBQUssRUFFTCxNQUFNLEdBQ1AsTUFBTSxlQUFlLENBQUM7QUFFdkIsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sV0FBVyxDQUFDOzs7QUFvQ2hELE1BQU0sT0FBTyxxQkFBcUI7SUFsQ2xDO1FBcUNZLFlBQU8sR0FBRyxJQUFJLFlBQVksRUFBTyxDQUFDO1FBQ2xDLGtCQUFhLEdBQUcsSUFBSSxZQUFZLEVBQU8sQ0FBQztRQUNsRCxnQkFBVyxHQUEyQjtZQUNwQyxLQUFLLEVBQUUsTUFBTTtZQUNiLE1BQU0sRUFBRSxNQUFNO1lBQ2QsS0FBSyxFQUFFLE1BQU07WUFDYixXQUFXLEVBQUUsS0FBSztZQUNsQixZQUFZLEVBQUUsS0FBSztZQUNuQixRQUFRLEVBQUUsVUFBVTtZQUNwQixNQUFNLEVBQUUsU0FBUztTQUNsQixDQUFDO1FBQ0YsZ0JBQVcsR0FBMkIsRUFBRSxDQUFDO1FBQ3pDLHdCQUFtQixHQUFHLG1CQUFtQixDQUFDO0tBWTNDO0lBVkMsV0FBVztRQUNULElBQUksQ0FBQyxXQUFXLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUM7UUFDekMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxTQUFTLEdBQUcsV0FBVyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDckQsSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLFdBQVcsRUFBRSxLQUFLLFNBQVMsRUFBRTtZQUMxQyxJQUFJLENBQUMsV0FBVyxDQUFDLFNBQVMsR0FBRyxzQkFBc0IsQ0FBQztTQUNyRDtJQUNILENBQUM7SUFDRCxXQUFXLENBQUMsRUFBRSxHQUFHLEVBQUUsTUFBTSxFQUFFO1FBQ3pCLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLE1BQU0sRUFBRSxDQUFDLENBQUM7SUFDckMsQ0FBQzs7a0hBMUJVLHFCQUFxQjtzR0FBckIscUJBQXFCLCtMQWhDdEI7Ozs7Ozs7Ozs7OztHQVlUOzJGQW9CVSxxQkFBcUI7a0JBbENqQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxxQkFBcUI7b0JBQy9CLFFBQVEsRUFBRTs7Ozs7Ozs7Ozs7O0dBWVQ7b0JBQ0QsTUFBTSxFQUFFO3dCQUNOOzs7Ozs7Ozs7Ozs7O0dBYUQ7cUJBQ0E7b0JBQ0QsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07b0JBQy9DLG1CQUFtQixFQUFFLEtBQUs7aUJBQzNCOzhCQUVVLEtBQUs7c0JBQWIsS0FBSztnQkFDRyxNQUFNO3NCQUFkLEtBQUs7Z0JBQ0ksT0FBTztzQkFBaEIsTUFBTTtnQkFDRyxhQUFhO3NCQUF0QixNQUFNIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG4gIENvbXBvbmVudCxcbiAgRXZlbnRFbWl0dGVyLFxuICBJbnB1dCxcbiAgT25DaGFuZ2VzLFxuICBPdXRwdXQsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBnZXRDb250cmFzdGluZ0NvbG9yIH0gZnJvbSAnbmd4LWNvbG9yJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnY29sb3ItY29tcGFjdC1jb2xvcicsXG4gIHRlbXBsYXRlOiBgXG4gIDxkaXYgY2xhc3M9XCJjb21wYWN0LWNvbG9yXCI+XG4gICAgPGNvbG9yLXN3YXRjaCBjbGFzcz1cInN3YXRjaFwiXG4gICAgICBbY29sb3JdPVwiY29sb3JcIiBbc3R5bGVdPVwic3dhdGNoU3R5bGVcIlxuICAgICAgW2ZvY3VzU3R5bGVdPVwic3dhdGNoRm9jdXNcIlxuICAgICAgKG9uQ2xpY2spPVwiaGFuZGxlQ2xpY2soJGV2ZW50KVwiIChvbkhvdmVyKT1cIm9uU3dhdGNoSG92ZXIuZW1pdCgkZXZlbnQpXCJcbiAgICAgID5cbiAgICAgIDxkaXYgY2xhc3M9XCJjb21wYWN0LWRvdFwiXG4gICAgICAgIFtjbGFzcy5hY3RpdmVdPVwiYWN0aXZlXCIgW3N0eWxlLmJhY2tncm91bmRdPVwiZ2V0Q29udHJhc3RpbmdDb2xvcihjb2xvcilcIlxuICAgICAgPjwvZGl2PlxuICAgIDwvY29sb3Itc3dhdGNoPlxuICA8L2Rpdj5cbiAgYCxcbiAgc3R5bGVzOiBbXG4gICAgYFxuICAuY29tcGFjdC1kb3Qge1xuICAgIHBvc2l0aW9uOiBhYnNvbHV0ZTtcbiAgICB0b3A6IDVweDtcbiAgICByaWdodDogNXB4O1xuICAgIGJvdHRvbTogNXB4O1xuICAgIGxlZnQ6IDVweDtcbiAgICBib3JkZXItcmFkaXVzOiA1MCU7XG4gICAgb3BhY2l0eTogMDtcbiAgfVxuICAuY29tcGFjdC1kb3QuYWN0aXZlIHtcbiAgICBvcGFjaXR5OiAxO1xuICB9XG4gIGAsXG4gIF0sXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBwcmVzZXJ2ZVdoaXRlc3BhY2VzOiBmYWxzZSxcbn0pXG5leHBvcnQgY2xhc3MgQ29tcGFjdENvbG9yQ29tcG9uZW50IGltcGxlbWVudHMgT25DaGFuZ2VzIHtcbiAgQElucHV0KCkgY29sb3IhOiBzdHJpbmc7XG4gIEBJbnB1dCgpIGFjdGl2ZSE6IGJvb2xlYW47XG4gIEBPdXRwdXQoKSBvbkNsaWNrID0gbmV3IEV2ZW50RW1pdHRlcjxhbnk+KCk7XG4gIEBPdXRwdXQoKSBvblN3YXRjaEhvdmVyID0gbmV3IEV2ZW50RW1pdHRlcjxhbnk+KCk7XG4gIHN3YXRjaFN0eWxlOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+ID0ge1xuICAgIHdpZHRoOiAnMTVweCcsXG4gICAgaGVpZ2h0OiAnMTVweCcsXG4gICAgZmxvYXQ6ICdsZWZ0JyxcbiAgICBtYXJnaW5SaWdodDogJzVweCcsXG4gICAgbWFyZ2luQm90dG9tOiAnNXB4JyxcbiAgICBwb3NpdGlvbjogJ3JlbGF0aXZlJyxcbiAgICBjdXJzb3I6ICdwb2ludGVyJyxcbiAgfTtcbiAgc3dhdGNoRm9jdXM6IFJlY29yZDxzdHJpbmcsIHN0cmluZz4gPSB7fTtcbiAgZ2V0Q29udHJhc3RpbmdDb2xvciA9IGdldENvbnRyYXN0aW5nQ29sb3I7XG5cbiAgbmdPbkNoYW5nZXMoKSB7XG4gICAgdGhpcy5zd2F0Y2hTdHlsZS5iYWNrZ3JvdW5kID0gdGhpcy5jb2xvcjtcbiAgICB0aGlzLnN3YXRjaEZvY3VzLmJveFNoYWRvdyA9IGAwIDAgNHB4ICR7dGhpcy5jb2xvcn1gO1xuICAgIGlmICh0aGlzLmNvbG9yLnRvTG93ZXJDYXNlKCkgPT09ICcjZmZmZmZmJykge1xuICAgICAgdGhpcy5zd2F0Y2hTdHlsZS5ib3hTaGFkb3cgPSAnaW5zZXQgMCAwIDAgMXB4ICNkZGQnO1xuICAgIH1cbiAgfVxuICBoYW5kbGVDbGljayh7IGhleCwgJGV2ZW50IH0pIHtcbiAgICB0aGlzLm9uQ2xpY2suZW1pdCh7IGhleCwgJGV2ZW50IH0pO1xuICB9XG59XG4iXX0=