@ks89/angular-modal-gallery 10.0.1 → 11.0.0

package/esm2022/lib/directives/size.directive.mjs

@@ -0,0 +1,77 @@
+/*
+ The MIT License (MIT)
+
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive to change the size of an element.
+ */
+class SizeDirective {
+    constructor(renderer, el) {
+        this.renderer = renderer;
+        this.el = el;
+    }
+    /**
+     * Method ´ngOnInit´ to apply the style of this directive.
+     * This is an Angular lifecycle hook, so its called automatically by Angular itself.
+     * In particular, it's called only one time!!!
+     */
+    ngOnInit() {
+        this.applyStyle();
+    }
+    /**
+     * Method ´ngOnChanges´ to apply the style of this directive.
+     * This is an Angular lifecycle hook, so its called automatically by Angular itself.
+     * In particular, it's called when any data-bound property of a directive changes!!!
+     */
+    ngOnChanges() {
+        this.applyStyle();
+    }
+    /**
+     * Private method to change both width and height of an element.
+     */
+    applyStyle() {
+        if (!this.sizeConfig) {
+            return;
+        }
+        // apply [style.width]
+        if (this.sizeConfig.width) {
+            this.renderer.setStyle(this.el.nativeElement, 'width', this.sizeConfig.width);
+        }
+        if (this.sizeConfig.height) {
+            this.renderer.setStyle(this.el.nativeElement, 'height', this.sizeConfig.height);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SizeDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: SizeDirective, selector: "[ksSize]", inputs: { sizeConfig: "sizeConfig" }, usesOnChanges: true, ngImport: i0 }); }
+}
+export { SizeDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SizeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ksSize]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; }, propDecorators: { sizeConfig: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/swipe.directive.mjs

@@ -0,0 +1,115 @@
+/*
+ The MIT License (MIT)
+
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+import { Directive, EventEmitter, HostListener, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+// Inspired from https://stackblitz.com/edit/angular-swipe-events-with-hostlistner?file=src%2Fapp%2Fapp.component.ts
+/**
+ * Directive to close the modal gallery clicking on the semi-transparent background.
+ * In fact, it listens for a click on all elements that aren't 'inside' and it emits
+ * an event using `@Output clickOutside`.
+ */
+class SwipeDirective {
+    constructor() {
+        this.defaultTouch = { x: 0, y: 0, time: 0 };
+        /**
+         */
+        this.swipeLeft = new EventEmitter();
+        /**
+         */
+        this.swipeRight = new EventEmitter();
+        /**
+         */
+        this.swipeUp = new EventEmitter();
+        /**
+         */
+        this.swipeDown = new EventEmitter();
+    }
+    /**
+     * Method called by Angular itself every click thanks to `@HostListener`.
+     * @param event TouchEvent payload received on touch
+     */
+    handleTouch(event) {
+        let touch = event.touches[0] || event.changedTouches[0];
+        // check the events
+        if (event.type === 'touchstart') {
+            this.defaultTouch.x = touch.pageX;
+            this.defaultTouch.y = touch.pageY;
+            this.defaultTouch.time = event.timeStamp;
+        }
+        else if (event.type === 'touchend') {
+            let deltaX = touch.pageX - this.defaultTouch.x;
+            let deltaY = touch.pageY - this.defaultTouch.y;
+            let deltaTime = event.timeStamp - this.defaultTouch.time;
+            // simulate a swipe -> less than 500 ms and more than 60 px
+            if (deltaTime < 500) {
+                // touch movement lasted less than 500 ms
+                if (Math.abs(deltaX) > 60) {
+                    // delta x is at least 60 pixels
+                    if (deltaX > 0) {
+                        this.swipeRight.emit();
+                    }
+                    else {
+                        this.swipeLeft.emit();
+                    }
+                }
+                if (Math.abs(deltaY) > 60) {
+                    // delta y is at least 60 pixels
+                    if (deltaY > 0) {
+                        this.swipeDown.emit();
+                    }
+                    else {
+                        this.swipeUp.emit();
+                    }
+                }
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SwipeDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: SwipeDirective, selector: "[ksSwipe]", outputs: { swipeLeft: "swipeLeft", swipeRight: "swipeRight", swipeUp: "swipeUp", swipeDown: "swipeDown" }, host: { listeners: { "touchstart": "handleTouch($event)", "touchend": "handleTouch($event)", "touchcancel": "handleTouch($event)" } }, ngImport: i0 }); }
+}
+export { SwipeDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SwipeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ksSwipe]'
+                }]
+        }], propDecorators: { swipeLeft: [{
+                type: Output
+            }], swipeRight: [{
+                type: Output
+            }], swipeUp: [{
+                type: Output
+            }], swipeDown: [{
+                type: Output
+            }], handleTouch: [{
+                type: HostListener,
+                args: ['touchstart', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['touchend', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['touchcancel', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/wrap.directive.mjs

@@ -0,0 +1,75 @@
+/*
+ The MIT License (MIT)
+
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive to change the flex-wrap css property of an element.
+ */
+class WrapDirective {
+    constructor(renderer, el) {
+        this.renderer = renderer;
+        this.el = el;
+    }
+    /**
+     * Method ´ngOnInit´ to apply the style of this directive.
+     * This is an angular lifecycle hook, so its called automatically by Angular itself.
+     * In particular, it's called only one time!!!
+     */
+    ngOnInit() {
+        this.applyStyle();
+    }
+    /**
+     * Method ´ngOnChanges´ to apply the style of this directive.
+     * This is an angular lifecycle hook, so its called automatically by Angular itself.
+     * In particular, it's called when any data-bound property of a directive changes!!!
+     */
+    ngOnChanges() {
+        this.applyStyle();
+    }
+    /**
+     * Private method to change both width and flex-wrap css properties.
+     */
+    applyStyle() {
+        // TODO is this right???? If wrap is false I cannot apply width and flex-wrap
+        if (!this.wrap) {
+            return;
+        }
+        this.renderer.setStyle(this.el.nativeElement, 'width', this.width);
+        this.renderer.setStyle(this.el.nativeElement, 'flex-wrap', this.wrap ? 'wrap' : 'nowrap');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WrapDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: WrapDirective, selector: "[ksWrap]", inputs: { wrap: "wrap", width: "width" }, usesOnChanges: true, ngImport: i0 }); }
+}
+export { WrapDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WrapDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ksWrap]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; }, propDecorators: { wrap: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3JhcC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9rczg5L2FuZ3VsYXItbW9kYWwtZ2FsbGVyeS9zcmMvbGliL2RpcmVjdGl2ZXMvd3JhcC5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FzQkc7QUFFSCxPQUFPLEVBQUUsU0FBUyxFQUFjLEtBQUssRUFBZ0MsTUFBTSxlQUFlLENBQUM7O0FBRTNGOztHQUVHO0FBQ0gsTUFHYSxhQUFhO0lBWXhCLFlBQW9CLFFBQW1CLEVBQVUsRUFBYztRQUEzQyxhQUFRLEdBQVIsUUFBUSxDQUFXO1FBQVUsT0FBRSxHQUFGLEVBQUUsQ0FBWTtJQUFHLENBQUM7SUFFbkU7Ozs7T0FJRztJQUNILFFBQVE7UUFDTixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7SUFDcEIsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxXQUFXO1FBQ1QsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO0lBQ3BCLENBQUM7SUFFRDs7T0FFRztJQUNLLFVBQVU7UUFDaEIsNkVBQTZFO1FBQzdFLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFO1lBQ2QsT0FBTztTQUNSO1FBQ0QsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxhQUFhLEVBQUUsT0FBTyxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNuRSxJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsRUFBRSxXQUFXLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUM1RixDQUFDOzhHQTFDVSxhQUFhO2tHQUFiLGFBQWE7O1NBQWIsYUFBYTsyRkFBYixhQUFhO2tCQUh6QixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxVQUFVO2lCQUNyQjt5SEFNQyxJQUFJO3NCQURILEtBQUs7Z0JBTU4sS0FBSztzQkFESixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiBUaGUgTUlUIExpY2Vuc2UgKE1JVClcblxuIENvcHlyaWdodCAoQykgMjAxNy0yMDIzIFN0ZWZhbm8gQ2FwcGEgKEtzODkpXG5cbiBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBjb3B5XG4gb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgXCJTb2Z0d2FyZVwiKSwgdG8gZGVhbFxuIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uIHRoZSByaWdodHNcbiB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsXG4gY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzXG4gZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczpcblxuIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluIGFsbFxuIGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUgU29mdHdhcmUuXG5cbiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgXCJBUyBJU1wiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SXG4gSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksXG4gRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTiBJTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRVxuIEFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVJcbiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLFxuIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MgSU4gVEhFXG4gU09GVFdBUkUuXG4gKi9cblxuaW1wb3J0IHsgRGlyZWN0aXZlLCBFbGVtZW50UmVmLCBJbnB1dCwgT25DaGFuZ2VzLCBPbkluaXQsIFJlbmRlcmVyMiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIERpcmVjdGl2ZSB0byBjaGFuZ2UgdGhlIGZsZXgtd3JhcCBjc3MgcHJvcGVydHkgb2YgYW4gZWxlbWVudC5cbiAqL1xuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW2tzV3JhcF0nXG59KVxuZXhwb3J0IGNsYXNzIFdyYXBEaXJlY3RpdmUgaW1wbGVtZW50cyBPbkluaXQsIE9uQ2hhbmdlcyB7XG4gIC8qKlxuICAgKiBCb29sZWFuIGlucHV0IHRoYXQgaXQncyB0cnVlIHRvIGFkZCAnZmxleC13cmFwOiB3cmFwJywgJ2ZsZXgtd3JhcDogbm93cmFwJyBvdGhlcndpc2UuXG4gICAqL1xuICBASW5wdXQoKVxuICB3cmFwOiBib29sZWFuIHwgdW5kZWZpbmVkO1xuICAvKipcbiAgICogU3RyaW5nIGlucHV0IHRvIGZvcmNlIHRoZSB3aWR0aCBvZiB0aGUgZWxlbWVudCB0byBiZSBhYmxlIHRvIHNlZSB3cmFwcGluZy5cbiAgICovXG4gIEBJbnB1dCgpXG4gIHdpZHRoOiBzdHJpbmcgfCB1bmRlZmluZWQ7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZW5kZXJlcjogUmVuZGVyZXIyLCBwcml2YXRlIGVsOiBFbGVtZW50UmVmKSB7fVxuXG4gIC8qKlxuICAgKiBNZXRob2QgwrRuZ09uSW5pdMK0IHRvIGFwcGx5IHRoZSBzdHlsZSBvZiB0aGlzIGRpcmVjdGl2ZS5cbiAgICogVGhpcyBpcyBhbiBhbmd1bGFyIGxpZmVjeWNsZSBob29rLCBzbyBpdHMgY2FsbGVkIGF1dG9tYXRpY2FsbHkgYnkgQW5ndWxhciBpdHNlbGYuXG4gICAqIEluIHBhcnRpY3VsYXIsIGl0J3MgY2FsbGVkIG9ubHkgb25lIHRpbWUhISFcbiAgICovXG4gIG5nT25Jbml0KCk6IHZvaWQge1xuICAgIHRoaXMuYXBwbHlTdHlsZSgpO1xuICB9XG5cbiAgLyoqXG4gICAqIE1ldGhvZCDCtG5nT25DaGFuZ2VzwrQgdG8gYXBwbHkgdGhlIHN0eWxlIG9mIHRoaXMgZGlyZWN0aXZlLlxuICAgKiBUaGlzIGlzIGFuIGFuZ3VsYXIgbGlmZWN5Y2xlIGhvb2ssIHNvIGl0cyBjYWxsZWQgYXV0b21hdGljYWxseSBieSBBbmd1bGFyIGl0c2VsZi5cbiAgICogSW4gcGFydGljdWxhciwgaXQncyBjYWxsZWQgd2hlbiBhbnkgZGF0YS1ib3VuZCBwcm9wZXJ0eSBvZiBhIGRpcmVjdGl2ZSBjaGFuZ2VzISEhXG4gICAqL1xuICBuZ09uQ2hhbmdlcygpOiB2b2lkIHtcbiAgICB0aGlzLmFwcGx5U3R5bGUoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBQcml2YXRlIG1ldGhvZCB0byBjaGFuZ2UgYm90aCB3aWR0aCBhbmQgZmxleC13cmFwIGNzcyBwcm9wZXJ0aWVzLlxuICAgKi9cbiAgcHJpdmF0ZSBhcHBseVN0eWxlKCk6IHZvaWQge1xuICAgIC8vIFRPRE8gaXMgdGhpcyByaWdodD8/Pz8gSWYgd3JhcCBpcyBmYWxzZSBJIGNhbm5vdCBhcHBseSB3aWR0aCBhbmQgZmxleC13cmFwXG4gICAgaWYgKCF0aGlzLndyYXApIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG4gICAgdGhpcy5yZW5kZXJlci5zZXRTdHlsZSh0aGlzLmVsLm5hdGl2ZUVsZW1lbnQsICd3aWR0aCcsIHRoaXMud2lkdGgpO1xuICAgIHRoaXMucmVuZGVyZXIuc2V0U3R5bGUodGhpcy5lbC5uYXRpdmVFbGVtZW50LCAnZmxleC13cmFwJywgdGhpcy53cmFwID8gJ3dyYXAnIDogJ25vd3JhcCcpO1xuICB9XG59XG4iXX0=

package/esm2022/lib/modal-gallery.module.mjs

@@ -0,0 +1,69 @@
+/*
+ The MIT License (MIT)
+
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { COMPONENTS, CarouselComponent } from './components/components';
+import { PlainGalleryComponent } from './components/plain-gallery/plain-gallery.component';
+import { DIRECTIVES } from './directives/directives';
+import * as i0 from "@angular/core";
+import * as i1 from "./components/plain-gallery/plain-gallery.component";
+import * as i2 from "./components/carousel/carousel.component";
+import * as i3 from "./components/carousel/carousel-previews/carousel-previews.component";
+import * as i4 from "./components/upper-buttons/upper-buttons.component";
+import * as i5 from "./components/dots/dots.component";
+import * as i6 from "./components/previews/previews.component";
+import * as i7 from "./components/current-image/current-image.component";
+import * as i8 from "./components/current-image/loading-spinner/loading-spinner.component";
+import * as i9 from "./components/accessible.component";
+import * as i10 from "./components/modal-gallery/modal-gallery.component";
+import * as i11 from "./directives/click-outside.directive";
+import * as i12 from "./directives/size.directive";
+import * as i13 from "./directives/keyboard-navigation.directive";
+import * as i14 from "./directives/wrap.directive";
+import * as i15 from "./directives/direction.directive";
+import * as i16 from "./directives/a-tag-bg-image.directive";
+import * as i17 from "./directives/description.directive";
+import * as i18 from "./directives/margin.directive";
+import * as i19 from "./directives/max-size.directive";
+import * as i20 from "./directives/fallback-image.directive";
+import * as i21 from "./directives/swipe.directive";
+/**
+ * Module to import it in the root module of your application.
+ */
+class GalleryModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GalleryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: GalleryModule, declarations: [i1.PlainGalleryComponent, i2.CarouselComponent, i3.CarouselPreviewsComponent, i4.UpperButtonsComponent, i5.DotsComponent, i6.PreviewsComponent, i7.CurrentImageComponent, i8.LoadingSpinnerComponent, i9.AccessibleComponent, i10.ModalGalleryComponent, i11.ClickOutsideDirective, i12.SizeDirective, i13.KeyboardNavigationDirective, i14.WrapDirective, i15.DirectionDirective, i16.ATagBgImageDirective, i17.DescriptionDirective, i18.MarginDirective, i19.MaxSizeDirective, i20.FallbackImageDirective, i21.SwipeDirective], imports: [CommonModule, OverlayModule], exports: [PlainGalleryComponent, CarouselComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GalleryModule, imports: [CommonModule, OverlayModule] }); }
+}
+export { GalleryModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GalleryModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, OverlayModule],
+                    declarations: [COMPONENTS, DIRECTIVES],
+                    exports: [PlainGalleryComponent, CarouselComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/model/accessibility.interface.mjs

@@ -1,7 +1,7 @@
 /*
  The MIT License (MIT)
 
- Copyright (C) 2017-2022 Stefano Cappa (Ks89)
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
@@ -22,4 +22,4 @@
  SOFTWARE.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/model/action.enum.mjs

@@ -1,7 +1,7 @@
 /*
  The MIT License (MIT)
 
- Copyright (C) 2017-2022 Stefano Cappa (Ks89)
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
@@ -33,4 +33,4 @@ export var Action;
     Action[Action["LOAD"] = 4] = "LOAD";
     Action[Action["AUTOPLAY"] = 5] = "AUTOPLAY";
 })(Action || (Action = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/model/buttons-config.interface.mjs

@@ -1,7 +1,7 @@
 /*
  The MIT License (MIT)
 
- Copyright (C) 2017-2022 Stefano Cappa (Ks89)
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
@@ -59,4 +59,4 @@ export const WHITELIST_BUTTON_TYPES = [
     ButtonType.CLOSE,
     ButtonType.CUSTOM
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/model/carousel-config.interface.mjs

@@ -1,7 +1,7 @@
 /*
  The MIT License (MIT)
 
- Copyright (C) 2017-2022 Stefano Cappa (Ks89)
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
@@ -22,4 +22,4 @@
  SOFTWARE.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/model/carousel-image-config.interface.mjs

@@ -1,7 +1,7 @@
 /*
  The MIT License (MIT)
 
- Copyright (C) 2017-2022 Stefano Cappa (Ks89)
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
@@ -22,4 +22,4 @@
  SOFTWARE.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/model/carousel-preview-config.interface.mjs

@@ -1,7 +1,7 @@
 /*
  The MIT License (MIT)
 
- Copyright (C) 2017-2022 Stefano Cappa (Ks89)
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
@@ -22,4 +22,4 @@
  SOFTWARE.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwtcHJldmlldy1jb25maWcuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva3M4OS9hbmd1bGFyLW1vZGFsLWdhbGxlcnkvc3JjL2xpYi9tb2RlbC9jYXJvdXNlbC1wcmV2aWV3LWNvbmZpZy5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FzQkciLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuIFRoZSBNSVQgTGljZW5zZSAoTUlUKVxuXG4gQ29weXJpZ2h0IChDKSAyMDE3LTIwMjMgU3RlZmFubyBDYXBwYSAoS3M4OSlcblxuIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhIGNvcHlcbiBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSBcIlNvZnR3YXJlXCIpLCB0byBkZWFsXG4gaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0c1xuIHRvIHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwgYW5kL29yIHNlbGxcbiBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXNcbiBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOlxuXG4gVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW4gYWxsXG4gY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS5cblxuIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1JcbiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSxcbiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OIElORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFXG4gQVVUSE9SUyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUlxuIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HIEZST00sXG4gT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTiBUSEVcbiBTT0ZUV0FSRS5cbiAqL1xuXG4vKipcbiAqIEludGVyZmFjZSBgQnJlYWtwb2ludHNDb25maWdgIHRvIGNvbmZpZ3VyZSByZXNwb25zaXZlIGJyZWFrcG9pbnRzIGFzIG51bWJlcnMgdG8gZXhwcmVzcyBwaXhlbHNcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBCcmVha3BvaW50c0NvbmZpZyB7XG4gIHhTbWFsbDogbnVtYmVyO1xuICBzbWFsbDogbnVtYmVyO1xuICBtZWRpdW06IG51bWJlcjtcbiAgbGFyZ2U6IG51bWJlcjtcbiAgeExhcmdlOiBudW1iZXI7XG59XG5cbi8qKlxuICogSW50ZXJmYWNlIGBDYXJvdXNlbFByZXZpZXdDb25maWdgIHRvIGNvbmZpZ3VyZSBjYXJvdXNlbCdzIHByZXZpZXdzXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ2Fyb3VzZWxQcmV2aWV3Q29uZmlnIHtcbiAgdmlzaWJsZTogYm9vbGVhbjtcbiAgbnVtYmVyPzogbnVtYmVyO1xuICBhcnJvd3M/OiBib29sZWFuO1xuICBjbGlja2FibGU/OiBib29sZWFuO1xuICB3aWR0aD86IHN0cmluZztcbiAgLy8gbWF4SGVpZ2h0IGlzIGNhbGxlZCBpbiB0aGlzIHdheSBiZWNhdXNlIGl0IHJlcHJlc2VudHMgdGhlIG1heEhlaWdodCBmb3IgdXNlcnMsIGhvd2V2ZXIgaW5zaWRlIHRoZSBjb2RlIGl0J3MgdGhlIGhlaWdodFxuICAvLyBJIGNhbGxlZCBtYXhIZWlnaHQgYmVjYXVzZSBpdCdzIGhhbmRsZWQgaW4gYSBjb21wbGV4IHdheSBhbHNvIHdpdGggQnJlYWtwb2ludHMgYW5kIEknbSB1c2luZyBNYXRoLm1pbiBsaWtlIGlzIGl0J3MgdGhlIG1heEhlaWdodCBpbnN0ZWFkIG9mIHRoZSBoZWlnaHRcbiAgbWF4SGVpZ2h0Pzogc3RyaW5nO1xuICBicmVha3BvaW50cz86IEJyZWFrcG9pbnRzQ29uZmlnO1xufVxuIl19

package/{esm2020 → esm2022}/lib/model/current-image-config.interface.mjs

@@ -1,7 +1,7 @@
 /*
  The MIT License (MIT)
 
- Copyright (C) 2017-2022 Stefano Cappa (Ks89)
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
@@ -22,4 +22,4 @@
  SOFTWARE.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/model/description.interface.mjs

@@ -1,7 +1,7 @@
 /*
  The MIT License (MIT)
 
- Copyright (C) 2017-2022 Stefano Cappa (Ks89)
+ Copyright (C) 2017-2023 Stefano Cappa (Ks89)
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
@@ -30,4 +30,4 @@ export var DescriptionStrategy;
     DescriptionStrategy[DescriptionStrategy["ALWAYS_VISIBLE"] = 2] = "ALWAYS_VISIBLE";
     DescriptionStrategy[DescriptionStrategy["HIDE_IF_EMPTY"] = 3] = "HIDE_IF_EMPTY";
 })(DescriptionStrategy || (DescriptionStrategy = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzY3JpcHRpb24uaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva3M4OS9hbmd1bGFyLW1vZGFsLWdhbGxlcnkvc3JjL2xpYi9tb2RlbC9kZXNjcmlwdGlvbi5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FzQkc7QUFpQkg7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBWSxtQkFJWDtBQUpELFdBQVksbUJBQW1CO0lBQzdCLCtFQUFpQixDQUFBO0lBQ2pCLGlGQUFjLENBQUE7SUFDZCwrRUFBYSxDQUFBO0FBQ2YsQ0FBQyxFQUpXLG1CQUFtQixLQUFuQixtQkFBbUIsUUFJOUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuIFRoZSBNSVQgTGljZW5zZSAoTUlUKVxuXG4gQ29weXJpZ2h0IChDKSAyMDE3LTIwMjIgU3RlZmFubyBDYXBwYSAoS3M4OSlcblxuIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhIGNvcHlcbiBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSBcIlNvZnR3YXJlXCIpLCB0byBkZWFsXG4gaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0c1xuIHRvIHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwgYW5kL29yIHNlbGxcbiBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXNcbiBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOlxuXG4gVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW4gYWxsXG4gY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS5cblxuIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1JcbiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSxcbiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OIElORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFXG4gQVVUSE9SUyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUlxuIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HIEZST00sXG4gT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTiBUSEVcbiBTT0ZUV0FSRS5cbiAqL1xuXG4vKipcbiAqIEludGVyZmFjZSBgRGVzY3JpcHRpb25gIHRvIGNoYW5nZSB0aGUgZGVzY3JpcHRpb24sIGVpdGhlciB3aXRoIGEgZnVsbCBjdXN0b21cbiAqIGRlc2NyaXB0aW9uIG9yIHdpdGggYSBzbWFsbCBhbmQgc2ltcGxlIGN1c3RvbWl6YXRpb24uXG4gKiBBbHNvLCB5b3UgY291bGQgY2hhbmdlIG1hcmdpbnMsIGJhY2tncm91bmQgc3R5bGUgYW5kIHNvIG9uLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIERlc2NyaXB0aW9uIHtcbiAgc3RyYXRlZ3k6IERlc2NyaXB0aW9uU3RyYXRlZ3k7XG4gIGN1c3RvbUZ1bGxEZXNjcmlwdGlvbj86IHN0cmluZztcbiAgaW1hZ2VUZXh0Pzogc3RyaW5nO1xuICBudW1iZXJTZXBhcmF0b3I/OiBzdHJpbmc7XG4gIGJlZm9yZVRleHREZXNjcmlwdGlvbj86IHN0cmluZztcblxuICBzdHlsZT86IERlc2NyaXB0aW9uU3R5bGU7XG59XG5cbi8qKlxuICogRW51bSBgRGVzY3JpcHRpb25TdHJhdGVneWAgd2l0aCBrZXlzIGFuZCB0aGVpciByZWxhdGl2ZSBrZXkgY29kZXMuXG4gKi9cbmV4cG9ydCBlbnVtIERlc2NyaXB0aW9uU3RyYXRlZ3kge1xuICBBTFdBWVNfSElEREVOID0gMSxcbiAgQUxXQVlTX1ZJU0lCTEUsXG4gIEhJREVfSUZfRU1QVFlcbn1cblxuLyoqXG4gKiBJbnRlcmZhY2UgdG8gY2hhbmdlIGNzcyBwcm9wZXJ0aWVzLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIERlc2NyaXB0aW9uU3R5bGUge1xuICBiZ0NvbG9yPzogc3RyaW5nO1xuICB0ZXh0Q29sb3I/OiBzdHJpbmc7XG4gIHdpZHRoPzogc3RyaW5nO1xuICBoZWlnaHQ/OiBzdHJpbmc7XG4gIHBvc2l0aW9uPzogc3RyaW5nO1xuICB0b3A/OiBzdHJpbmc7XG4gIGJvdHRvbT86IHN0cmluZztcbiAgbGVmdD86IHN0cmluZztcbiAgcmlnaHQ/OiBzdHJpbmc7XG4gIG1hcmdpblRvcD86IHN0cmluZztcbiAgbWFyZ2luQm90dG9tPzogc3RyaW5nO1xuICBtYXJnaW5SaWdodD86IHN0cmluZztcbiAgbWFyZ2luTGVmdD86IHN0cmluZztcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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