@agorapulse/ui-components 2.5.1 → 13.0.2

package/esm2020/src/lib/directives/autosize-textarea.directive.mjs

@@ -0,0 +1,43 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * expand textarea to fit content. Doesn't shrink.
+ */
+export class AutosizeTextareaDirective {
+    constructor(element) {
+        this.element = element;
+    }
+    onInput() {
+        this.resize();
+    }
+    ngAfterContentChecked() {
+        this.resize();
+    }
+    resize() {
+        const style = this.element.nativeElement.style;
+        const scrollHeight = this.element.nativeElement.scrollHeight;
+        const actualHeight = this.element.nativeElement.offsetHeight;
+        if (AutosizeTextareaDirective.maxHeight < scrollHeight) {
+            // we arrived at the max
+            style.overflow = 'auto';
+            style.height = `${AutosizeTextareaDirective.maxHeight}px`;
+        }
+        else if (actualHeight < scrollHeight) {
+            style.overflow = 'hidden';
+            style.height = `${scrollHeight}px`;
+        }
+    }
+}
+AutosizeTextareaDirective.maxHeight = 200;
+/** @nocollapse */ /** @nocollapse */ AutosizeTextareaDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AutosizeTextareaDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ AutosizeTextareaDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.3", type: AutosizeTextareaDirective, selector: "textarea[ap-autosize]", host: { listeners: { "input": "onInput()" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AutosizeTextareaDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'textarea[ap-autosize]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { onInput: [{
+                type: HostListener,
+                args: ['input']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/directives/default-image.directive.mjs

@@ -0,0 +1,29 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DefaultImageDirective {
+    updateUrl() {
+        if (this.default) {
+            this.src = this.default;
+        }
+        else {
+            this.src = 'assets/lib-ui-components/img/default-avatar.png';
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DefaultImageDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultImageDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ DefaultImageDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.3", type: DefaultImageDirective, selector: "img[default]", inputs: { src: "src", default: "default" }, host: { listeners: { "error": "updateUrl()" }, properties: { "src": "src" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultImageDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'img[default]',
+                    host: {
+                        '(error)': 'updateUrl()',
+                        '[src]': 'src'
+                    }
+                }]
+        }], propDecorators: { src: [{
+                type: Input
+            }], default: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1pbWFnZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3VpLWNvbXBvbmVudHMvc3JjL2xpYi9kaXJlY3RpdmVzL2RlZmF1bHQtaW1hZ2UuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUUsS0FBSyxFQUFDLE1BQU0sZUFBZSxDQUFDOztBQVMvQyxNQUFNLE9BQU8scUJBQXFCO0lBSTlCLFNBQVM7UUFDTCxJQUFJLElBQUksQ0FBQyxPQUFPLEVBQUU7WUFDZCxJQUFJLENBQUMsR0FBRyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUM7U0FDM0I7YUFBTTtZQUNILElBQUksQ0FBQyxHQUFHLEdBQUcsaURBQWlELENBQUM7U0FDaEU7SUFDTCxDQUFDOzt3SkFWUSxxQkFBcUI7NElBQXJCLHFCQUFxQjsyRkFBckIscUJBQXFCO2tCQVBqQyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxjQUFjO29CQUN4QixJQUFJLEVBQUU7d0JBQ0YsU0FBUyxFQUFFLGFBQWE7d0JBQ3hCLE9BQU8sRUFBRSxLQUFLO3FCQUNqQjtpQkFDSjs4QkFFWSxHQUFHO3NCQUFYLEtBQUs7Z0JBQ0csT0FBTztzQkFBZixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtEaXJlY3RpdmUsIElucHV0fSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICdpbWdbZGVmYXVsdF0nLFxuICAgIGhvc3Q6IHtcbiAgICAgICAgJyhlcnJvciknOiAndXBkYXRlVXJsKCknLFxuICAgICAgICAnW3NyY10nOiAnc3JjJ1xuICAgIH1cbn0pXG5leHBvcnQgY2xhc3MgRGVmYXVsdEltYWdlRGlyZWN0aXZlIHtcbiAgICBASW5wdXQoKSBzcmM6IHN0cmluZztcbiAgICBASW5wdXQoKSBkZWZhdWx0OiBzdHJpbmc7XG5cbiAgICB1cGRhdGVVcmwoKSB7XG4gICAgICAgIGlmICh0aGlzLmRlZmF1bHQpIHtcbiAgICAgICAgICAgIHRoaXMuc3JjID0gdGhpcy5kZWZhdWx0O1xuICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgdGhpcy5zcmMgPSAnYXNzZXRzL2xpYi11aS1jb21wb25lbnRzL2ltZy9kZWZhdWx0LWF2YXRhci5wbmcnO1xuICAgICAgICB9XG4gICAgfVxufVxuIl19

package/esm2020/src/lib/directives/ellipsis.directive.mjs

@@ -0,0 +1,87 @@
+import { Directive, EventEmitter, Input, Output, } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Removes excess text from element until it fits in elements
+ * and appends a ellipsis symbol to end of text. This requires that
+ * the elements height be fixed
+ *
+ * @example
+ * ```html
+ * <p apEllipsis>Ullamco esse laborum</p>
+ * ```
+ *
+ */
+export class EllipsisDirective {
+    constructor(el) {
+        this.el = el;
+        this.apEllipsisClip = false;
+        this.apEllipsisChar = '...';
+        this.apEllipsisClickable = false;
+        this.apEllipsisRemovedElementsCount = new EventEmitter();
+        this.apEllipsisRemovedText = new EventEmitter();
+    }
+    get hasOverflow() {
+        const el = this.el.nativeElement;
+        return (el.scrollHeight > el.offsetHeight) || (el.scrollWidth > el.offsetWidth);
+    }
+    ngAfterContentChecked() {
+        this.clipText();
+    }
+    clipText() {
+        const el = this.el.nativeElement;
+        let text = el.innerText;
+        let removedText = '';
+        if (this.apEllipsisIndex > -1) {
+            removedText = text.substring(this.apEllipsisIndex, text.length - 1) + removedText;
+            text = text.substring(0, this.apEllipsisIndex);
+            el.innerText = `${text}${this.apEllipsisChar}`;
+            if (this.apEllipsisClickable) {
+                el.addEventListener('click', () => {
+                    el.innerText = `${text}${removedText}`;
+                });
+            }
+        }
+        else {
+            while (this.hasOverflow && text.length > 0) {
+                removedText = text[text.length - 1] + removedText;
+                text = text.substring(0, text.length - 1);
+                el.innerText = `${text}${this.apEllipsisChar}`;
+            }
+        }
+        if (this.apEllipsisSeparator) {
+            const removedElementsCount = removedText.split(this.apEllipsisSeparator)
+                .filter(element => !!element && element.length > 0).length;
+            if (removedElementsCount > 0) {
+                this.apEllipsisRemovedElementsCount.emit(removedElementsCount);
+            }
+        }
+        if (removedText && removedText.length > 0) {
+            this.apEllipsisRemovedText.emit(removedText);
+        }
+    }
+    handleReadmore() {
+    }
+}
+/** @nocollapse */ /** @nocollapse */ EllipsisDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: EllipsisDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ EllipsisDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.3", type: EllipsisDirective, selector: "[apEllipsis]", inputs: { apEllipsisSeparator: "apEllipsisSeparator", apEllipsisClip: "apEllipsisClip", apEllipsisIndex: "apEllipsisIndex", apEllipsisChar: "apEllipsisChar", apEllipsisClickable: "apEllipsisClickable" }, outputs: { apEllipsisRemovedElementsCount: "apEllipsisRemovedElementsCount", apEllipsisRemovedText: "apEllipsisRemovedText" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: EllipsisDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[apEllipsis]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { apEllipsisSeparator: [{
+                type: Input
+            }], apEllipsisClip: [{
+                type: Input
+            }], apEllipsisIndex: [{
+                type: Input
+            }], apEllipsisChar: [{
+                type: Input
+            }], apEllipsisClickable: [{
+                type: Input
+            }], apEllipsisRemovedElementsCount: [{
+                type: Output
+            }], apEllipsisRemovedText: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/directives/equal-validator.directive.mjs

@@ -0,0 +1,64 @@
+// Based on https://scotch.io/tutorials/how-to-implement-a-custom-validator-directive-confirm-password-in-angular-2
+import { Directive, forwardRef, Attribute } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+export class EqualValidatorDirective {
+    constructor(validateEqual, validateEqualReference) {
+        this.validateEqual = validateEqual;
+        this.validateEqualReference = validateEqualReference;
+    }
+    validate(self) {
+        let other = self.root.get(this.validateEqual);
+        if (other) {
+            if (this.isReference()) {
+                if (self.value === other.value) {
+                    delete other.errors['validateEqual'];
+                    if (!Object.keys(other.errors).length) {
+                        other.setErrors(null);
+                    }
+                }
+                else {
+                    other.setErrors({ validateEqual: false });
+                }
+            }
+            else if (self.value !== other.value) {
+                return { validateEqual: false };
+            }
+        }
+        return null;
+    }
+    isReference() {
+        if (!this.validateEqualReference) {
+            return false;
+        }
+        return this.validateEqualReference === 'true';
+    }
+}
+/** @nocollapse */ /** @nocollapse */ EqualValidatorDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: EqualValidatorDirective, deps: [{ token: 'validateEqual', attribute: true }, { token: 'validateEqualReference', attribute: true }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ EqualValidatorDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.3", type: EqualValidatorDirective, selector: "[validateEqual][formControlName],[validateEqual][formControl],[validateEqual][ngModel]", providers: [
+        {
+            provide: NG_VALIDATORS,
+            useExisting: forwardRef((() => EqualValidatorDirective)),
+            multi: true
+        }
+    ], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: EqualValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[validateEqual][formControlName],[validateEqual][formControl],[validateEqual][ngModel]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef((() => EqualValidatorDirective)),
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['validateEqual']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['validateEqualReference']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/directives/frozen-gif.directive.mjs

@@ -0,0 +1,116 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GifService {
+    static isGif(src) {
+        return src && src.split('?')[0].endsWith('.gif');
+    }
+}
+/**
+ * If the image is a GIF then replace the img element by a canvas containing a frozen gif.
+ * Note 1: if the image is displayed under a condition, the condition must be applied on the parent of the image, so the
+ * new canvas element will have the same condition.
+ * Note 2: the image must not have the properties "display" and "visibility" in its style. Since they are used to frozen
+ * the GIF. You need to apply this properties on the parent element.
+ * Note 3: If the GIF is frozen, all the event are propagated to the image. However, all events are dispatched
+ * with an Event instance. Ex: click event is not dispatched with a MouseEvent instance.
+ */
+export class FrozenGifDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.frozen = true;
+        // Add all the events that need to be propagated.
+        this.events = ['click'];
+        const element = this.elementRef.nativeElement;
+        if (!(element instanceof HTMLImageElement)) {
+            return;
+        }
+        this.element = element;
+    }
+    ngOnChanges(changes) {
+        let freeze = false;
+        if (changes.src) {
+            freeze = true;
+        }
+        if (changes.frozen) {
+            if (changes.frozen.currentValue) {
+                freeze = true;
+            }
+            else {
+                this.unfreeze();
+            }
+        }
+        if (freeze) {
+            this.freeze();
+        }
+    }
+    freeze() {
+        if (!GifService.isGif(this.src) || !this.frozen) {
+            this.unfreeze();
+            return;
+        }
+        // hack to avoid displaying the GIF before replacing it by the canvas
+        this.element.style.visibility = 'hidden';
+        this.element.addEventListener('load', () => this.addCanvas());
+    }
+    addCanvas() {
+        if (this.canvas) {
+            this.canvas.remove();
+        }
+        this.canvas = document.createElement('canvas');
+        this.canvas.width = this.element.width;
+        this.canvas.height = this.element.height;
+        this.canvas.getContext('2d').drawImage(this.element, 0, 0, this.canvas.width, this.canvas.height);
+        for (let i = 0; i < this.element.attributes.length; i++) {
+            const attr = this.element.attributes[i];
+            if (attr.name === 'id') { // avoid two elements with the same id
+                this.canvas.setAttribute('id', attr.value + '_frozenGif');
+            }
+            else if (attr.name === 'style' && attr.value.includes('visibility: hidden;') || attr.value.includes('display: none;')) {
+                // remove the added 'visibility: hidden' and 'display: none'
+                const styleValue = attr.value;
+                this.canvas.setAttribute('style', styleValue.replace('visibility: hidden;', '').replace('display: none;', ''));
+            }
+            else if (attr.name !== '"') { // test for invalid attributes
+                this.canvas.setAttribute(attr.name, attr.value);
+            }
+        }
+        this.addEvents();
+        this.element.parentNode.insertBefore(this.canvas, this.element);
+        this.element.style.display = 'none';
+    }
+    addEvents() {
+        this.events.forEach((eventName) => {
+            this.canvas.addEventListener(eventName, (ev) => this.element.dispatchEvent(
+            // wm: find a way to dispatch the right event type
+            new Event(ev.type, ev)));
+        });
+    }
+    unfreeze() {
+        if (this.canvas) {
+            this.canvas.remove();
+            this.canvas = null;
+        }
+        this.element.style.visibility = 'inherit';
+        this.element.style.display = 'inherit';
+    }
+}
+/** @nocollapse */ /** @nocollapse */ FrozenGifDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FrozenGifDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ FrozenGifDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.3", type: FrozenGifDirective, selector: "img[apFrozenGif]", inputs: { src: "src", frozen: ["apFrozen", "frozen"], events: ["apGifEvents", "events"] }, host: { properties: { "src": "src" } }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FrozenGifDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'img[apFrozenGif]',
+                    host: {
+                        '[src]': 'src'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { src: [{
+                type: Input
+            }], frozen: [{
+                type: Input,
+                args: ['apFrozen']
+            }], events: [{
+                type: Input,
+                args: ['apGifEvents']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frozen-gif.directive.js","sourceRoot":"","sources":["../../../../../../libs/ui-components/src/lib/directives/frozen-gif.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, ElementRef, Input, OnChanges} from '@angular/core';\n\nexport class GifService {\n    static isGif(src: String) {\n        return src && src.split('?')[0].endsWith('.gif');\n    }\n}\n\n/**\n * If the image is a GIF then replace the img element by a canvas containing a frozen gif.\n * Note 1: if the image is displayed under a condition, the condition must be applied on the parent of the image, so the\n * new canvas element will have the same condition.\n * Note 2: the image must not have the properties \"display\" and \"visibility\" in its style. Since they are used to frozen\n * the GIF. You need to apply this properties on the parent element.\n * Note 3: If the GIF is frozen, all the event are propagated to the image. However, all events are dispatched\n * with an Event instance. Ex: click event is not dispatched with a MouseEvent instance.\n */\n\n@Directive({\n    selector: 'img[apFrozenGif]',\n    host: {\n        '[src]': 'src'\n    }\n})\nexport class FrozenGifDirective implements OnChanges {\n    @Input() src: string;\n    @Input('apFrozen') frozen = true;\n    // Add all the events that need to be propagated.\n    @Input('apGifEvents') events: string[] = ['click'];\n\n    private readonly element: HTMLImageElement;\n    private canvas: HTMLCanvasElement;\n\n    constructor(private elementRef: ElementRef) {\n        const element = this.elementRef.nativeElement;\n        if (!(element instanceof HTMLImageElement)) {\n            return;\n        }\n\n        this.element = element;\n    }\n\n    ngOnChanges(changes: any): void {\n        let freeze = false;\n        if (changes.src) {\n            freeze = true;\n        }\n        if (changes.frozen) {\n            if (changes.frozen.currentValue) {\n                freeze = true;\n            } else {\n                this.unfreeze();\n            }\n        }\n\n        if (freeze) {\n            this.freeze();\n        }\n\n    }\n\n    private freeze() {\n        if (!GifService.isGif(this.src) || !this.frozen) {\n            this.unfreeze();\n            return;\n        }\n\n        // hack to avoid displaying the GIF before replacing it by the canvas\n        this.element.style.visibility = 'hidden';\n        this.element.addEventListener('load', () => this.addCanvas());\n    }\n\n    private addCanvas() {\n        if (this.canvas) {\n            this.canvas.remove();\n        }\n\n        this.canvas = document.createElement('canvas');\n        this.canvas.width = this.element.width;\n        this.canvas.height = this.element.height;\n        this.canvas.getContext('2d').drawImage(this.element, 0, 0, this.canvas.width, this.canvas.height);\n        for (let i = 0; i < this.element.attributes.length; i++) {\n            const attr = this.element.attributes[i];\n            if (attr.name === 'id') { // avoid two elements with the same id\n                this.canvas.setAttribute('id', attr.value + '_frozenGif');\n            } else if (attr.name === 'style' && attr.value.includes('visibility: hidden;') || attr.value.includes('display: none;')) {\n                // remove the added 'visibility: hidden' and 'display: none'\n                const styleValue = attr.value;\n                this.canvas.setAttribute('style', styleValue.replace('visibility: hidden;', '').replace('display: none;', ''));\n            } else if (attr.name !== '\"') { // test for invalid attributes\n                this.canvas.setAttribute(attr.name, attr.value);\n            }\n        }\n\n        this.addEvents();\n\n        this.element.parentNode.insertBefore(this.canvas, this.element);\n        this.element.style.display = 'none';\n    }\n\n    private addEvents() {\n        this.events.forEach((eventName: string) => {\n            this.canvas.addEventListener(eventName, (ev: Event) => this.element.dispatchEvent(\n                // wm: find a way to dispatch the right event type\n                new Event(ev.type, ev)\n            ));\n        });\n    }\n\n    private unfreeze() {\n        if (this.canvas) {\n            this.canvas.remove();\n            this.canvas = null;\n        }\n        this.element.style.visibility = 'inherit';\n        this.element.style.display = 'inherit';\n    }\n}\n"]}

package/esm2020/src/lib/directives/multi-style-text.directive.mjs

@@ -0,0 +1,101 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+const PART_START = '<ng-container data-mst="';
+const PARSE_MIDDLE = '">';
+const PARSE_END = '</ng-container>';
+const CLASS_SEPARATOR = ',';
+/**
+ * This directive aims to parse simple string to extract some specific tags and to turn them into SPAN with styling classes attributes.
+ * The specific tags must this schema: <ng-container data-mst="STYLING-CLASSES>TEXT</ng-container>.
+ * Example: 'Lorem <ng-container data-mst="my-style">ipsum</ng-container> dolor sit amet'.
+ */
+export class MultiStyleTextDirective {
+    constructor(elRef, renderer) {
+        this.elRef = elRef;
+        this.renderer = renderer;
+        this.childrenCreated = [];
+    }
+    set multiStyleText(fullText) {
+        // First remove previously added children (on update).
+        for (const child of this.childrenCreated) {
+            this.renderer.removeChild(this.elRef.nativeElement, child);
+        }
+        const parts = MultiStyleTextDirective.parse(fullText);
+        for (const part of parts) {
+            if (part.clazz) {
+                const span = this.renderer.createElement('span');
+                const text = this.renderer.createText(part.content);
+                this.renderer.appendChild(span, text);
+                part.clazz.forEach(clazz => this.renderer.addClass(span, clazz));
+                this.renderer.appendChild(this.elRef.nativeElement, span);
+                this.childrenCreated.push(span);
+            }
+            else {
+                const text = this.renderer.createText(part.content);
+                this.renderer.appendChild(this.elRef.nativeElement, text);
+                this.childrenCreated.push(text);
+            }
+        }
+    }
+    static parse(toParse) {
+        const parts = [];
+        let startIndex = toParse.indexOf(PART_START);
+        while (startIndex >= 0) {
+            if (startIndex > 0) {
+                // Optional start before parser start.
+                parts.push({ content: toParse.substr(0, startIndex) });
+            }
+            const elem = this.cutFirstGroup(toParse.substr(startIndex));
+            if (elem === 'invalid') {
+                return [];
+            }
+            else if (elem) {
+                parts.push({ content: elem.content, clazz: elem.classes });
+                toParse = elem.rest;
+                startIndex = toParse.indexOf(PART_START);
+            }
+            else {
+                parts.push({ content: toParse });
+            }
+        }
+        // Very end
+        if (toParse.length > 0) {
+            parts.push({ content: toParse });
+        }
+        return parts;
+    }
+    static cutFirstGroup(toCut) {
+        if (!toCut.startsWith(PART_START)) {
+            // String doesnt start with expected parser start.
+            return null;
+        }
+        const afterParserStart = toCut.substr(PART_START.length);
+        let index = afterParserStart.indexOf(PARSE_MIDDLE);
+        if (index <= 0) {
+            console.error('Not able to parse invalid string: ' + toCut);
+            return 'invalid';
+        }
+        const classes = afterParserStart.substr(0, index);
+        let rest = afterParserStart.substr(index + PARSE_MIDDLE.length);
+        index = rest.indexOf(PARSE_END);
+        if (index <= 0) {
+            console.error('Not able to parse invalid string: ' + toCut);
+            return 'invalid';
+        }
+        const content = rest.substr(0, index);
+        rest = rest.substr(index + PARSE_END.length);
+        return { content, classes: classes.split(CLASS_SEPARATOR), rest };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ MultiStyleTextDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: MultiStyleTextDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ MultiStyleTextDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.3", type: MultiStyleTextDirective, selector: "[multiStyleText]", inputs: { multiStyleText: "multiStyleText" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: MultiStyleTextDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // tslint:disable-next-line:directive-selector
+                    selector: '[multiStyleText]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { multiStyleText: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-style-text.directive.js","sourceRoot":"","sources":["../../../../../../libs/ui-components/src/lib/directives/multi-style-text.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, Input, Renderer2, ElementRef} from '@angular/core';\n\nconst PART_START = '<ng-container data-mst=\"';\nconst PARSE_MIDDLE = '\">';\nconst PARSE_END = '</ng-container>';\nconst CLASS_SEPARATOR = ',';\n\ninterface Part {\n    content: string;\n    clazz?: string[];\n}\n\n/**\n * This directive aims to parse simple string to extract some specific tags and to turn them into SPAN with styling classes attributes.\n * The specific tags must this schema: <ng-container data-mst=\"STYLING-CLASSES>TEXT</ng-container>.\n * Example: 'Lorem <ng-container data-mst=\"my-style\">ipsum</ng-container> dolor sit amet'.\n */\n@Directive({\n    // tslint:disable-next-line:directive-selector\n    selector: '[multiStyleText]'\n})\nexport class MultiStyleTextDirective {\n\n    private childrenCreated: any[] = [];\n\n    @Input() set multiStyleText(fullText: string) {\n        // First remove previously added children (on update).\n        for (const child of this.childrenCreated) {\n            this.renderer.removeChild(this.elRef.nativeElement, child);\n        }\n\n        const parts = MultiStyleTextDirective.parse(fullText);\n\n        for (const part of parts) {\n            if (part.clazz) {\n                const span = this.renderer.createElement('span');\n                const text = this.renderer.createText(part.content);\n                this.renderer.appendChild(span, text);\n                part.clazz.forEach(clazz => this.renderer.addClass(span, clazz));\n                this.renderer.appendChild(this.elRef.nativeElement, span);\n                this.childrenCreated.push(span);\n            } else {\n                const text = this.renderer.createText(part.content);\n                this.renderer.appendChild(this.elRef.nativeElement, text);\n                this.childrenCreated.push(text);\n            }\n        }\n    }\n\n    public constructor(\n        private elRef: ElementRef,\n        private renderer: Renderer2\n    ) {\n    }\n\n    private static parse(toParse: string): Part[] {\n        const parts: Part[] = [];\n\n        let startIndex = toParse.indexOf(PART_START);\n        while (startIndex >= 0) {\n            if (startIndex > 0) {\n                // Optional start before parser start.\n                parts.push({content: toParse.substr(0, startIndex)});\n            }\n            const elem = this.cutFirstGroup(toParse.substr(startIndex));\n            if (elem === 'invalid') {\n                return [];\n            } else if (elem) {\n                parts.push({content: elem.content, clazz: elem.classes});\n                toParse = elem.rest;\n                startIndex = toParse.indexOf(PART_START);\n            } else {\n                parts.push({content: toParse});\n            }\n        }\n        // Very end\n        if (toParse.length > 0) {\n            parts.push({content: toParse});\n        }\n        return parts;\n    }\n\n    private static cutFirstGroup(toCut: string): {content: string, classes: string[], rest: string} | 'invalid' | null {\n        if (!toCut.startsWith(PART_START)) {\n            // String doesnt start with expected parser start.\n            return null;\n        }\n\n        const afterParserStart = toCut.substr(PART_START.length);\n        let index = afterParserStart.indexOf(PARSE_MIDDLE);\n        if (index <= 0) {\n            console.error('Not able to parse invalid string: ' + toCut);\n            return 'invalid';\n        }\n        const classes = afterParserStart.substr(0, index);\n        let rest = afterParserStart.substr(index + PARSE_MIDDLE.length);\n        index = rest.indexOf(PARSE_END);\n        if (index <= 0) {\n            console.error('Not able to parse invalid string: ' + toCut);\n            return 'invalid';\n        }\n        const content = rest.substr(0, index);\n        rest = rest.substr(index + PARSE_END.length);\n\n        return {content, classes: classes.split(CLASS_SEPARATOR), rest};\n    }\n}\n"]}

package/esm2020/src/lib/directives/truncate-tooltip.directive.mjs

@@ -0,0 +1,33 @@
+// Angular
+import { Directive, Input } from '@angular/core';
+// Third-parties
+import { fromEvent } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "../tooltip-neo/tooltip-neo.directive";
+export class TruncateTooltipDirective {
+    constructor(tooltipNeo, elementRef) {
+        this.tooltipNeo = tooltipNeo;
+        this.elementRef = elementRef;
+    }
+    updateTruncateState() {
+        const element = this.elementRef.nativeElement;
+        const truncated = element.scrollWidth > element.clientWidth;
+        this.tooltipNeo.apTooltipNeo = truncated ? this.truncateTooltip : '';
+    }
+    ngOnInit() {
+        this.elementRefMouseOver$ = fromEvent(this.elementRef.nativeElement, 'mouseover')
+            .subscribe(() => this.updateTruncateState());
+    }
+    ngOnDestroy() {
+        this.elementRefMouseOver$.unsubscribe();
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TruncateTooltipDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TruncateTooltipDirective, deps: [{ token: i1.TooltipNeoDirective }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ TruncateTooltipDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.3", type: TruncateTooltipDirective, selector: "[apTooltipNeo][truncateTooltip]", inputs: { truncateTooltip: "truncateTooltip" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TruncateTooltipDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[apTooltipNeo][truncateTooltip]' }]
+        }], ctorParameters: function () { return [{ type: i1.TooltipNeoDirective }, { type: i0.ElementRef }]; }, propDecorators: { truncateTooltip: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/dots-stepper/dots-stepper.component.mjs

@@ -0,0 +1,43 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class DotsStepperComponent {
+    constructor() {
+        this.disabled = false;
+        this.forwardAllowed = true;
+        this.items = [];
+        this.size = '';
+        this.dotClick = new EventEmitter();
+    }
+    ngOnChanges() {
+        this.currentItem = this.items[this.index];
+    }
+    onDotClick(event, item, index) {
+        event.stopPropagation();
+        if (this.disabled || (!this.forwardAllowed && index > this.index)) {
+            return;
+        }
+        this.currentItem = item;
+        this.index = index;
+        this.dotClick.emit(this.index);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DotsStepperComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DotsStepperComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ DotsStepperComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: DotsStepperComponent, selector: "ap-dots-stepper", inputs: { disabled: "disabled", forwardAllowed: "forwardAllowed", index: "index", items: "items", size: "size" }, outputs: { dotClick: "dotClick" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"dots\"\n    [ngClass]=\"{'small-dots': size == 'small'}\">\n    <div class=\"dot\"\n         *ngFor=\"let item of items; let i = index\"\n         [ngClass]=\"{'active': item === currentItem, 'disabled': disabled || (!forwardAllowed  && i > index) }\"\n         (click)=\"onDotClick($event, item, i)\">\n    </div>\n</div>\n", styles: ["[color=facebook]{color:#1877f2}[bgcolor=facebook],[hcolor=facebook]:hover{background-color:#1877f2}[border=facebook]{border:1px solid #1877f2}[color=google]{color:#4e85e8}[bgcolor=google],[hcolor=google]:hover{background-color:#4e85e8}[border=google]{border:1px solid #4e85e8}[color=instagram]{color:#e1306c}[bgcolor=instagram],[hcolor=instagram]:hover{background-color:#e1306c}[border=instagram]{border:1px solid #e1306c}[color=instagrammagenta]{color:#c13584}[bgcolor=instagrammagenta],[hcolor=instagrammagenta]:hover{background-color:#c13584}[border=instagrammagenta]{border:1px solid #c13584}[color=instagramblue]{color:#5851db}[bgcolor=instagramblue],[hcolor=instagramblue]:hover{background-color:#5851db}[border=instagramblue]{border:1px solid #5851db}[color=instagrampurple]{color:#833ab4}[bgcolor=instagrampurple],[hcolor=instagrampurple]:hover{background-color:#833ab4}[border=instagrampurple]{border:1px solid #833ab4}[color=instagramorange]{color:#f56040}[bgcolor=instagramorange],[hcolor=instagramorange]:hover{background-color:#f56040}[border=instagramorange]{border:1px solid #f56040}[color=instagramyellow]{color:#ffdc80}[bgcolor=instagramyellow],[hcolor=instagramyellow]:hover{background-color:#ffdc80}[border=instagramyellow]{border:1px solid #ffdc80}[color=linkedin]{color:#2c67bc}[bgcolor=linkedin],[hcolor=linkedin]:hover{background-color:#2c67bc}[border=linkedin]{border:1px solid #2c67bc}[color=twitter]{color:#55acee}[bgcolor=twitter],[hcolor=twitter]:hover{background-color:#55acee}[border=twitter]{border:1px solid #55acee}[color=youtube]{color:red}[bgcolor=youtube],[hcolor=youtube]:hover{background-color:red}[border=youtube]{border:1px solid #ff0000}[color=blood-orange]{color:#ff4d00}[bgcolor=blood-orange],[hcolor=blood-orange]:hover{background-color:#ff4d00}[border=blood-orange]{border:1px solid #ff4d00}[color=pinkish-orange]{color:#ff7b49}[bgcolor=pinkish-orange],[hcolor=pinkish-orange]:hover{background-color:#ff7b49}[border=pinkish-orange]{border:1px solid #ff7b49}[color=charcoal-grey]{color:#2a2f34}[bgcolor=charcoal-grey],[hcolor=charcoal-grey]:hover{background-color:#2a2f34}[border=charcoal-grey]{border:1px solid #2a2f34}[color=azure]{color:#00aeef}[bgcolor=azure],[hcolor=azure]:hover{background-color:#00aeef}[border=azure]{border:1px solid #00aeef}[color=light-azure]{color:#eaf5fd}[bgcolor=light-azure],[hcolor=light-azure]:hover{background-color:#eaf5fd}[border=light-azure]{border:1px solid #eaf5fd}[color=blue-grey]{color:#8d98a9}[bgcolor=blue-grey],[hcolor=blue-grey]:hover{background-color:#8d98a9}[border=blue-grey]{border:1px solid #8d98a9}[color=silver]{color:#ced0da}[bgcolor=silver],[hcolor=silver]:hover{background-color:#ced0da}[border=silver]{border:1px solid #ced0da}[color=pale-grey]{color:#dfe3e9}[bgcolor=pale-grey],[hcolor=pale-grey]:hover{background-color:#dfe3e9}[border=pale-grey]{border:1px solid #dfe3e9}[color=grey-white]{color:#f5f7f8}[bgcolor=grey-white],[hcolor=grey-white]:hover{background-color:#f5f7f8}[border=grey-white]{border:1px solid #f5f7f8}[color=cool-grey]{color:#b4bbc6}[bgcolor=cool-grey],[hcolor=cool-grey]:hover{background-color:#b4bbc6}[border=cool-grey]{border:1px solid #b4bbc6}[color=black]{color:#344563}[bgcolor=black],[hcolor=black]:hover{background-color:#344563}[border=black]{border:1px solid #344563}[color=grey-blue]{color:#68768c}[bgcolor=grey-blue],[hcolor=grey-blue]:hover{background-color:#68768c}[border=grey-blue]{border:1px solid #68768c}[color=strawberry]{color:#f4282d}[bgcolor=strawberry],[hcolor=strawberry]:hover{background-color:#f4282d}[border=strawberry]{border:1px solid #f4282d}[color=light-strawberry]{color:#f8eded}[bgcolor=light-strawberry],[hcolor=light-strawberry]:hover{background-color:#f8eded}[border=light-strawberry]{border:1px solid #f8eded}[color=white]{color:#fff}[bgcolor=white],[hcolor=white]:hover{background-color:#fff}[border=white]{border:1px solid #ffffff}[color=cool-green]{color:#33c15d}[bgcolor=cool-green],[hcolor=cool-green]:hover{background-color:#33c15d}[border=cool-green]{border:1px solid #33c15d}[color=light-green]{color:#ebfaef}[bgcolor=light-green],[hcolor=light-green]:hover{background-color:#ebfaef}[border=light-green]{border:1px solid #ebfaef}[color=transparent]{color:transparent}[bgcolor=transparent],[hcolor=transparent]:hover{background-color:transparent}[border=transparent]{border:1px solid transparent}[color=c0]{color:#a566a5}[bgcolor=c0],[hcolor=c0]:hover{background-color:#a566a5}[border=c0]{border:1px solid #A566A5}[color=c1]{color:#c7ab82}[bgcolor=c1],[hcolor=c1]:hover{background-color:#c7ab82}[border=c1]{border:1px solid #C7AB82}[color=c2]{color:#f2713c}[bgcolor=c2],[hcolor=c2]:hover{background-color:#f2713c}[border=c2]{border:1px solid #F2713C}[color=c3]{color:#ffd006}[bgcolor=c3],[hcolor=c3]:hover{background-color:#ffd006}[border=c3]{border:1px solid #FFD006}[color=c4]{color:#94c5aa}[bgcolor=c4],[hcolor=c4]:hover{background-color:#94c5aa}[border=c4]{border:1px solid #94C5AA}[color=c5]{color:#2a9d8f}[bgcolor=c5],[hcolor=c5]:hover{background-color:#2a9d8f}[border=c5]{border:1px solid #2A9D8F}[color=c6]{color:#78acd8}[bgcolor=c6],[hcolor=c6]:hover{background-color:#78acd8}[border=c6]{border:1px solid #78ACD8}[color=c7]{color:#525a9e}[bgcolor=c7],[hcolor=c7]:hover{background-color:#525a9e}[border=c7]{border:1px solid #525A9E}[color=c8]{color:#6a2459}[bgcolor=c8],[hcolor=c8]:hover{background-color:#6a2459}[border=c8]{border:1px solid #6A2459}[color=c9]{color:#74729e}[bgcolor=c9],[hcolor=c9]:hover{background-color:#74729e}[border=c9]{border:1px solid #74729E}.dots{align-items:stretch;box-sizing:border-box;display:flex;flex-direction:row;place-content:stretch center;position:absolute}.dots .dot{-webkit-transition:all .2s ease-in-out;background:#d6dae0;border-radius:50%;cursor:pointer;height:8px;margin:16px 4px;transition:all .2s ease-in-out;width:8px}.dots .dot.active{background:#178dfe;cursor:initial}.dots .dot.disabled{background:#d6dae0;cursor:initial}.dots.small-dots .dot{height:6px;margin:16px 2px;width:6px}\n"], directives: [{ type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DotsStepperComponent, decorators: [{
+            type: Component,
+            args: [{ changeDetection: ChangeDetectionStrategy.OnPush, selector: 'ap-dots-stepper', template: "<div class=\"dots\"\n    [ngClass]=\"{'small-dots': size == 'small'}\">\n    <div class=\"dot\"\n         *ngFor=\"let item of items; let i = index\"\n         [ngClass]=\"{'active': item === currentItem, 'disabled': disabled || (!forwardAllowed  && i > index) }\"\n         (click)=\"onDotClick($event, item, i)\">\n    </div>\n</div>\n", styles: ["[color=facebook]{color:#1877f2}[bgcolor=facebook],[hcolor=facebook]:hover{background-color:#1877f2}[border=facebook]{border:1px solid #1877f2}[color=google]{color:#4e85e8}[bgcolor=google],[hcolor=google]:hover{background-color:#4e85e8}[border=google]{border:1px solid #4e85e8}[color=instagram]{color:#e1306c}[bgcolor=instagram],[hcolor=instagram]:hover{background-color:#e1306c}[border=instagram]{border:1px solid #e1306c}[color=instagrammagenta]{color:#c13584}[bgcolor=instagrammagenta],[hcolor=instagrammagenta]:hover{background-color:#c13584}[border=instagrammagenta]{border:1px solid #c13584}[color=instagramblue]{color:#5851db}[bgcolor=instagramblue],[hcolor=instagramblue]:hover{background-color:#5851db}[border=instagramblue]{border:1px solid #5851db}[color=instagrampurple]{color:#833ab4}[bgcolor=instagrampurple],[hcolor=instagrampurple]:hover{background-color:#833ab4}[border=instagrampurple]{border:1px solid #833ab4}[color=instagramorange]{color:#f56040}[bgcolor=instagramorange],[hcolor=instagramorange]:hover{background-color:#f56040}[border=instagramorange]{border:1px solid #f56040}[color=instagramyellow]{color:#ffdc80}[bgcolor=instagramyellow],[hcolor=instagramyellow]:hover{background-color:#ffdc80}[border=instagramyellow]{border:1px solid #ffdc80}[color=linkedin]{color:#2c67bc}[bgcolor=linkedin],[hcolor=linkedin]:hover{background-color:#2c67bc}[border=linkedin]{border:1px solid #2c67bc}[color=twitter]{color:#55acee}[bgcolor=twitter],[hcolor=twitter]:hover{background-color:#55acee}[border=twitter]{border:1px solid #55acee}[color=youtube]{color:red}[bgcolor=youtube],[hcolor=youtube]:hover{background-color:red}[border=youtube]{border:1px solid #ff0000}[color=blood-orange]{color:#ff4d00}[bgcolor=blood-orange],[hcolor=blood-orange]:hover{background-color:#ff4d00}[border=blood-orange]{border:1px solid #ff4d00}[color=pinkish-orange]{color:#ff7b49}[bgcolor=pinkish-orange],[hcolor=pinkish-orange]:hover{background-color:#ff7b49}[border=pinkish-orange]{border:1px solid #ff7b49}[color=charcoal-grey]{color:#2a2f34}[bgcolor=charcoal-grey],[hcolor=charcoal-grey]:hover{background-color:#2a2f34}[border=charcoal-grey]{border:1px solid #2a2f34}[color=azure]{color:#00aeef}[bgcolor=azure],[hcolor=azure]:hover{background-color:#00aeef}[border=azure]{border:1px solid #00aeef}[color=light-azure]{color:#eaf5fd}[bgcolor=light-azure],[hcolor=light-azure]:hover{background-color:#eaf5fd}[border=light-azure]{border:1px solid #eaf5fd}[color=blue-grey]{color:#8d98a9}[bgcolor=blue-grey],[hcolor=blue-grey]:hover{background-color:#8d98a9}[border=blue-grey]{border:1px solid #8d98a9}[color=silver]{color:#ced0da}[bgcolor=silver],[hcolor=silver]:hover{background-color:#ced0da}[border=silver]{border:1px solid #ced0da}[color=pale-grey]{color:#dfe3e9}[bgcolor=pale-grey],[hcolor=pale-grey]:hover{background-color:#dfe3e9}[border=pale-grey]{border:1px solid #dfe3e9}[color=grey-white]{color:#f5f7f8}[bgcolor=grey-white],[hcolor=grey-white]:hover{background-color:#f5f7f8}[border=grey-white]{border:1px solid #f5f7f8}[color=cool-grey]{color:#b4bbc6}[bgcolor=cool-grey],[hcolor=cool-grey]:hover{background-color:#b4bbc6}[border=cool-grey]{border:1px solid #b4bbc6}[color=black]{color:#344563}[bgcolor=black],[hcolor=black]:hover{background-color:#344563}[border=black]{border:1px solid #344563}[color=grey-blue]{color:#68768c}[bgcolor=grey-blue],[hcolor=grey-blue]:hover{background-color:#68768c}[border=grey-blue]{border:1px solid #68768c}[color=strawberry]{color:#f4282d}[bgcolor=strawberry],[hcolor=strawberry]:hover{background-color:#f4282d}[border=strawberry]{border:1px solid #f4282d}[color=light-strawberry]{color:#f8eded}[bgcolor=light-strawberry],[hcolor=light-strawberry]:hover{background-color:#f8eded}[border=light-strawberry]{border:1px solid #f8eded}[color=white]{color:#fff}[bgcolor=white],[hcolor=white]:hover{background-color:#fff}[border=white]{border:1px solid #ffffff}[color=cool-green]{color:#33c15d}[bgcolor=cool-green],[hcolor=cool-green]:hover{background-color:#33c15d}[border=cool-green]{border:1px solid #33c15d}[color=light-green]{color:#ebfaef}[bgcolor=light-green],[hcolor=light-green]:hover{background-color:#ebfaef}[border=light-green]{border:1px solid #ebfaef}[color=transparent]{color:transparent}[bgcolor=transparent],[hcolor=transparent]:hover{background-color:transparent}[border=transparent]{border:1px solid transparent}[color=c0]{color:#a566a5}[bgcolor=c0],[hcolor=c0]:hover{background-color:#a566a5}[border=c0]{border:1px solid #A566A5}[color=c1]{color:#c7ab82}[bgcolor=c1],[hcolor=c1]:hover{background-color:#c7ab82}[border=c1]{border:1px solid #C7AB82}[color=c2]{color:#f2713c}[bgcolor=c2],[hcolor=c2]:hover{background-color:#f2713c}[border=c2]{border:1px solid #F2713C}[color=c3]{color:#ffd006}[bgcolor=c3],[hcolor=c3]:hover{background-color:#ffd006}[border=c3]{border:1px solid #FFD006}[color=c4]{color:#94c5aa}[bgcolor=c4],[hcolor=c4]:hover{background-color:#94c5aa}[border=c4]{border:1px solid #94C5AA}[color=c5]{color:#2a9d8f}[bgcolor=c5],[hcolor=c5]:hover{background-color:#2a9d8f}[border=c5]{border:1px solid #2A9D8F}[color=c6]{color:#78acd8}[bgcolor=c6],[hcolor=c6]:hover{background-color:#78acd8}[border=c6]{border:1px solid #78ACD8}[color=c7]{color:#525a9e}[bgcolor=c7],[hcolor=c7]:hover{background-color:#525a9e}[border=c7]{border:1px solid #525A9E}[color=c8]{color:#6a2459}[bgcolor=c8],[hcolor=c8]:hover{background-color:#6a2459}[border=c8]{border:1px solid #6A2459}[color=c9]{color:#74729e}[bgcolor=c9],[hcolor=c9]:hover{background-color:#74729e}[border=c9]{border:1px solid #74729E}.dots{align-items:stretch;box-sizing:border-box;display:flex;flex-direction:row;place-content:stretch center;position:absolute}.dots .dot{-webkit-transition:all .2s ease-in-out;background:#d6dae0;border-radius:50%;cursor:pointer;height:8px;margin:16px 4px;transition:all .2s ease-in-out;width:8px}.dots .dot.active{background:#178dfe;cursor:initial}.dots .dot.disabled{background:#d6dae0;cursor:initial}.dots.small-dots .dot{height:6px;margin:16px 2px;width:6px}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { disabled: [{
+                type: Input
+            }], forwardAllowed: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], dotClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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