@recursyve/nice-ui-kit.v2 15.0.0-beta.131 → 16.0.0-beta.134

package/esm2022/lib/components/image-cropper/image-cropper.component.mjs

@@ -0,0 +1,1269 @@
+/**
+ * Adapted from https://github.com/A-l-y-l-e/Alyle-UI/tree/10.5.3/src/lib/image-cropper
+ */
+import { normalizePassiveListenerOptions } from "@angular/cdk/platform";
+import { ViewportRuler } from "@angular/cdk/scrolling";
+import { DOCUMENT } from "@angular/common";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, HostBinding, Inject, Input, NgZone, Output, Renderer2, ViewChild, ViewEncapsulation } from "@angular/core";
+import { Observable, Subject } from "rxjs";
+import { take, takeUntil } from "rxjs/operators";
+import { resizeCanvas } from "./resize-canvas";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/scrolling";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/icon";
+const activeEventOptions = normalizePassiveListenerOptions({ passive: false });
+/** Image Cropper Config */
+export class ImgCropperConfig {
+    constructor() {
+        /** Cropper area width */
+        this.width = 250;
+        /** Cropper area height */
+        this.height = 200;
+        this.minWidth = 40;
+        this.minHeight = 40;
+        /**
+         * Set anti-aliased (default: true)
+         * @deprecated this is not necessary as the cropper will automatically resize the image
+         * to the best quality
+         */
+        this.antiAliased = true;
+        this.output = ImgResolution.Default;
+    }
+}
+/** Image output */
+export var ImgResolution;
+(function (ImgResolution) {
+    /**
+     * The output image will be equal to the initial size of the cropper area.
+     */
+    ImgResolution[ImgResolution["Default"] = 0] = "Default";
+    /** Just crop the image without resizing */
+    ImgResolution[ImgResolution["OriginalImage"] = 1] = "OriginalImage";
+})(ImgResolution || (ImgResolution = {}));
+/** Image output */
+export var ImgCropperError;
+(function (ImgCropperError) {
+    /** The loaded image exceeds the size limit set. */
+    ImgCropperError[ImgCropperError["Size"] = 0] = "Size";
+    /** The file loaded is not image. */
+    ImgCropperError[ImgCropperError["Type"] = 1] = "Type";
+    /** When the image has not been loaded. */
+    ImgCropperError[ImgCropperError["Other"] = 2] = "Other";
+})(ImgCropperError || (ImgCropperError = {}));
+export class NiceImageCropperComponent {
+    static { this.и = "NiceImageCropper"; }
+    set config(val) {
+        this._config = mergeDeep({}, new ImgCropperConfig(), val);
+        this._configPrimary = mergeDeep({}, this._config);
+        this._primaryAreaWidth = this.config.width;
+        this._primaryAreaHeight = this.config.height;
+        if (this._config.round
+            && this.config.width !== this.config.height) {
+            throw new Error(`${NiceImageCropperComponent.и}: Both width and height must be equal when using \`ImgCropperConfig.round = true\``);
+        }
+        const maxFileSize = this._config.maxFileSize;
+        if (maxFileSize) {
+            this.maxFileSize = maxFileSize;
+        }
+    }
+    get config() {
+        return this._config;
+    }
+    /** Set scale */
+    set scale(val) {
+        this.setScale(val);
+    }
+    get scale() {
+        return this._scale;
+    }
+    /** Get min scale */
+    get minScale() {
+        return this._minScale;
+    }
+    constructor(_renderer, _elementRef, cd, _ngZone, _document, viewPortRuler) {
+        this._renderer = _renderer;
+        this._elementRef = _elementRef;
+        this.cd = cd;
+        this._ngZone = _ngZone;
+        this._imgRect = {};
+        this._rotation = 0;
+        this.scaleChange = new EventEmitter();
+        /** Emits minimum supported image scale */
+        // tslint:disable-next-line:no-output-rename
+        this.minScaleChange = new EventEmitter();
+        /** Emits maximum supported image scale */
+        // tslint:disable-next-line:no-output-rename
+        this.maxScaleChange = new EventEmitter();
+        /** Emits when the image is loaded */
+        this.imageLoaded = new EventEmitter();
+        /** Emits when the cropper is ready to be interacted */
+        this.ready = new EventEmitter();
+        /** On crop new image */
+        this.cropped = new EventEmitter();
+        /** Emits when the cropper is cleaned */
+        this.cleaned = new EventEmitter();
+        /** Emit an error when the loaded image is not valid */
+        // tslint:disable-next-line: no-output-native
+        this.error = new EventEmitter();
+        /** Emits whenever the component is destroyed. */
+        this._destroy = new Subject();
+        this._pointerDown = (event) => {
+            // Don't do anything if the
+            // user is using anything other than the main mouse button.
+            if (this._isSliding || (!isTouchEvent(event) && event.button !== 0)) {
+                return;
+            }
+            this._ngZone.run(() => {
+                this._isSliding = true;
+                this.offset = {
+                    x: this._imgRect.x,
+                    y: this._imgRect.y,
+                    left: this._imgRect.xc,
+                    top: this._imgRect.yc
+                };
+                this._lastPointerEvent = event;
+                this._startPointerEvent = getGesturePointFromEvent(event);
+                event.preventDefault();
+                this._bindGlobalEvents(event);
+            });
+        };
+        /**
+         * Called when the user has moved their pointer after
+         * starting to drag.
+         */
+        this._pointerMove = (event) => {
+            if (this._isSliding) {
+                event.preventDefault();
+                this._lastPointerEvent = event;
+                let x;
+                let y;
+                const canvas = this._imgCanvas.nativeElement;
+                const scaleFix = this._scal3Fix;
+                const config = this.config;
+                const startP = this.offset;
+                const point = getGesturePointFromEvent(event);
+                const deltaX = point.x - this._startPointerEvent.x;
+                const deltaY = point.y - this._startPointerEvent.y;
+                if (!scaleFix || !startP) {
+                    return;
+                }
+                const isMinScaleY = canvas.height * scaleFix < config.height && config.extraZoomOut;
+                const isMinScaleX = canvas.width * scaleFix < config.width && config.extraZoomOut;
+                const limitLeft = (config.width / 2 / scaleFix) >= startP.left - (deltaX / scaleFix);
+                const limitRight = (config.width / 2 / scaleFix) +
+                    (canvas.width) - (startP.left - (deltaX / scaleFix)) <= config.width / scaleFix;
+                const limitTop = ((config.height / 2 / scaleFix) >= (startP.top - (deltaY / scaleFix)));
+                const limitBottom = (((config.height / 2 / scaleFix) + (canvas.height) - (startP.top - (deltaY / scaleFix))) <= (config.height / scaleFix));
+                // Limit for left
+                if ((limitLeft && !isMinScaleX) || (!limitLeft && isMinScaleX)) {
+                    x = startP.x + (startP.left) - (config.width / 2 / scaleFix);
+                }
+                // Limit for right
+                if ((limitRight && !isMinScaleX) || (!limitRight && isMinScaleX)) {
+                    x = startP.x + (startP.left) + (config.width / 2 / scaleFix) - canvas.width;
+                }
+                // Limit for top
+                if ((limitTop && !isMinScaleY) || (!limitTop && isMinScaleY)) {
+                    y = startP.y + (startP.top) - (config.height / 2 / scaleFix);
+                }
+                // Limit for bottom
+                if ((limitBottom && !isMinScaleY) || (!limitBottom && isMinScaleY)) {
+                    y = startP.y + (startP.top) + (config.height / 2 / scaleFix) - canvas.height;
+                }
+                // When press shiftKey, deprecated
+                // if (event.srcEvent && event.srcEvent.shiftKey) {
+                //   if (Math.abs(event.deltaX) === Math.max(Math.abs(event.deltaX), Math.abs(event.deltaY))) {
+                //     y = this.offset.top;
+                //   } else {
+                //     x = this.offset.left;
+                //   }
+                // }
+                if (x === void 0) {
+                    x = (deltaX / scaleFix) + (startP.x);
+                }
+                if (y === void 0) {
+                    y = (deltaY / scaleFix) + (startP.y);
+                }
+                this._setStylesForContImg({
+                    x, y
+                });
+            }
+        };
+        /** Called when the user has lifted their pointer. */
+        this._pointerUp = (event) => {
+            if (this._isSliding) {
+                event.preventDefault();
+                this._removeGlobalEvents();
+                this._isSliding = false;
+                this._startPointerEvent = null;
+                this._cropIfAutoCrop();
+            }
+        };
+        /** Called when the window has lost focus. */
+        this._windowBlur = () => {
+            // If the window is blurred while dragging we need to stop dragging because the
+            // browser won't dispatch the `mouseup` and `touchend` events anymore.
+            if (this._lastPointerEvent) {
+                this._pointerUp(this._lastPointerEvent);
+            }
+        };
+        this._document = _document;
+        viewPortRuler.change()
+            .pipe(takeUntil(this._destroy))
+            .subscribe(() => this._ngZone.run(() => this.updateCropperPosition()));
+    }
+    ngOnInit() {
+        this._ngZone.runOutsideAngular(() => {
+            const element = this._imgContainer.nativeElement;
+            element.addEventListener("mousedown", this._pointerDown, activeEventOptions);
+            element.addEventListener("touchstart", this._pointerDown, activeEventOptions);
+        });
+    }
+    ngOnDestroy() {
+        this._destroy.next();
+        this._destroy.complete();
+        const element = this._imgContainer.nativeElement;
+        this._lastPointerEvent = null;
+        this._removeGlobalEvents();
+        element.removeEventListener("mousedown", this._pointerDown, activeEventOptions);
+        element.removeEventListener("touchstart", this._pointerDown, activeEventOptions);
+    }
+    /** Load image with canvas */
+    _imgLoaded(imgElement) {
+        if (imgElement) {
+            this._img = imgElement;
+            const canvas = this._imgCanvas.nativeElement;
+            canvas.width = imgElement.width;
+            canvas.height = imgElement.height;
+            const ctx = canvas.getContext("2d");
+            ctx.clearRect(0, 0, imgElement.width, imgElement.height);
+            ctx.drawImage(imgElement, 0, 0);
+            /** set min scale */
+            this._updateMinScale(canvas);
+            this._updateMaxScale();
+        }
+    }
+    _setStylesForContImg(values) {
+        const newStyles = {};
+        if (values.x != null && values.y != null) {
+            const rootRect = this._rootRect();
+            const x = rootRect.width / 2 - (values.x);
+            const y = rootRect.height / 2 - (values.y);
+            this._imgRect.x = (values.x);
+            this._imgRect.y = (values.y);
+            this._imgRect.xc = (x);
+            this._imgRect.yc = (y);
+        }
+        newStyles.transform = `translate3d(${(this._imgRect.x)}px,${(this._imgRect.y)}px, 0)`;
+        newStyles.transform += `scale(${this._scal3Fix})`;
+        newStyles.transformOrigin = `${this._imgRect.xc}px ${this._imgRect.yc}px 0`;
+        newStyles["-webkit-transform"] = newStyles.transform;
+        newStyles["-webkit-transform-origin"] = newStyles.transformOrigin;
+        for (const key in newStyles) {
+            if (newStyles.hasOwnProperty(key)) {
+                this._renderer.setStyle(this._imgContainer.nativeElement, key, newStyles[key]);
+            }
+        }
+    }
+    /**
+     * Update area and image position only if needed,
+     * this is used when window resize
+     */
+    updateCropperPosition() {
+        if (this.isLoaded) {
+            this.updatePosition();
+            this._updateAreaIfNeeded();
+        }
+    }
+    /** Load Image from input event */
+    selectInputEvent(img) {
+        this._currentInputElement = img.target;
+        const _img = img.target;
+        if (_img.files && _img.files.length !== 1) {
+            return;
+        }
+        const fileSize = _img.files[0].size;
+        const fileName = _img.value.replace(/.*(\/|\\)/, "");
+        if (this.maxFileSize && fileSize > this.maxFileSize) {
+            const cropEvent = {
+                name: fileName,
+                type: _img.files[0].type,
+                size: fileSize,
+                error: ImgCropperError.Size
+            };
+            this.clean();
+            this.error.emit(cropEvent);
+            return;
+        }
+        new Observable(observer => {
+            const reader = new FileReader();
+            reader.onerror = err => observer.error(err);
+            reader.onabort = err => observer.error(err);
+            reader.onload = (ev) => setTimeout(() => {
+                observer.next(ev);
+                observer.complete();
+            });
+            reader.readAsDataURL(_img.files[0]);
+        })
+            .pipe(take(1), takeUntil(this._destroy))
+            .subscribe((loadEvent) => {
+            const originalDataURL = loadEvent.target.result;
+            this.loadImage({
+                name: fileName,
+                size: _img.files[0].size,
+                type: this.config.type || _img.files[0].type,
+                originalDataURL
+            });
+            this.cd.markForCheck();
+        }, () => {
+            const cropEvent = {
+                name: fileName,
+                size: fileSize,
+                error: ImgCropperError.Other,
+                errorMsg: "The File could not be loaded.",
+                type: _img.files[0].type
+            };
+            this.clean();
+            this.error.emit(cropEvent);
+        });
+    }
+    /** Set the size of the image, the values can be 0 between 1, where 1 is the original size */
+    setScale(size, noAutoCrop) {
+        // fix min scale
+        const newSize = size >= this.minScale && size <= 1 ? size : this.minScale;
+        // check
+        const changed = size != null && size !== this.scale && newSize !== this.scale;
+        this._scale = size;
+        if (!changed) {
+            return;
+        }
+        this._scal3Fix = newSize;
+        this._updateAbsoluteScale();
+        if (this.isLoaded) {
+            if (changed) {
+                const originPosition = { ...this._imgRect };
+                this.offset = {
+                    x: originPosition.x,
+                    y: originPosition.y,
+                    left: originPosition.xc,
+                    top: originPosition.yc
+                };
+                this._setStylesForContImg({});
+                this._simulatePointerMove();
+            }
+            else {
+                return;
+            }
+        }
+        else if (this.minScale) {
+            this._setStylesForContImg({
+                ...this._getCenterPoints()
+            });
+        }
+        else {
+            return;
+        }
+        this.scaleChange.emit(size);
+        if (!noAutoCrop) {
+            this._cropIfAutoCrop();
+        }
+    }
+    _getCenterPoints() {
+        const root = this._elementRef.nativeElement;
+        const img = this._imgCanvas.nativeElement;
+        const x = (root.offsetWidth - (img.width)) / 2;
+        const y = (root.offsetHeight - (img.height)) / 2;
+        return {
+            x,
+            y
+        };
+    }
+    /**
+     * Fit to screen
+     */
+    fitToScreen() {
+        const container = this._elementRef.nativeElement;
+        const min = {
+            width: container.offsetWidth,
+            height: container.offsetHeight
+        };
+        const { width, height } = this._img;
+        const minScale = {
+            width: min.width / width,
+            height: min.height / height
+        };
+        const result = Math.max(minScale.width, minScale.height);
+        this.setScale(result);
+    }
+    fit() {
+        this.setScale(this.minScale);
+    }
+    /**
+     * Simulate pointerMove with clientX = 0 and clientY = 0,
+     * this is used by `setScale` and `rotate`
+     */
+    _simulatePointerMove() {
+        this._isSliding = true;
+        this._startPointerEvent = {
+            x: 0,
+            y: 0
+        };
+        this._pointerMove({
+            clientX: 0,
+            clientY: 0,
+            type: "n",
+            preventDefault: () => { }
+        });
+        this._isSliding = false;
+        this._startPointerEvent = null;
+    }
+    _markForCheck() {
+        this.cd.markForCheck();
+    }
+    updatePosition(xOrigin, yOrigin) {
+        const hostRect = this._rootRect();
+        const areaRect = this._areaCropperRect();
+        const areaWidth = areaRect.width > hostRect.width
+            ? hostRect.width
+            : areaRect.width;
+        const areaHeight = areaRect.height > hostRect.height
+            ? hostRect.height
+            : areaRect.height;
+        let x;
+        let y;
+        if (xOrigin == null && yOrigin == null) {
+            xOrigin = this._imgRect.xc;
+            yOrigin = this._imgRect.yc;
+        }
+        x = (areaRect.left - hostRect.left);
+        y = (areaRect.top - hostRect.top);
+        x -= (xOrigin - (areaWidth / 2));
+        y -= (yOrigin - (areaHeight / 2));
+        this._setStylesForContImg({
+            x, y
+        });
+    }
+    _slideEnd() {
+        this._cropIfAutoCrop();
+    }
+    _cropIfAutoCrop() {
+        if (this.config.autoCrop) {
+            this.crop();
+        }
+    }
+    /** + */
+    zoomIn() {
+        const scale = this._scal3Fix + .05;
+        if (scale > this.minScale && scale <= this._maxScale) {
+            this.setScale(scale);
+        }
+        else {
+            this.setScale(this._maxScale);
+        }
+    }
+    /** Clean the img cropper */
+    clean() {
+        // fix choosing the same image does not load
+        if (this._currentInputElement) {
+            this._currentInputElement.value = "";
+            this._currentInputElement = null;
+        }
+        if (this.isLoaded) {
+            this._imgRect = {};
+            this.offset = undefined;
+            this.scale = undefined;
+            this._scal3Fix = undefined;
+            this._rotation = 0;
+            this._minScale = undefined;
+            this._isLoadedImg = false;
+            this.isLoaded = false;
+            this.isCropped = false;
+            this._currentLoadConfig = undefined;
+            this.config = this._configPrimary;
+            const canvas = this._imgCanvas.nativeElement;
+            canvas.width = 0;
+            canvas.height = 0;
+            this.cleaned.emit(null);
+            this.cd.markForCheck();
+        }
+    }
+    /** - */
+    zoomOut() {
+        const scale = this._scal3Fix - .05;
+        if (scale > this.minScale && scale <= this._maxScale) {
+            this.setScale(scale);
+        }
+        else {
+            this.fit();
+        }
+    }
+    center() {
+        const newStyles = {
+            ...this._getCenterPoints()
+        };
+        this._setStylesForContImg(newStyles);
+        this._cropIfAutoCrop();
+    }
+    /**
+     * load an image from a given configuration,
+     * or from the result of a cropped image
+     */
+    loadImage(config, fn) {
+        this.clean();
+        const _config = this._currentLoadConfig = typeof config === "string"
+            ? { originalDataURL: config }
+            : { ...config };
+        let src = _config.originalDataURL;
+        this._primaryAreaWidth = this._configPrimary.width;
+        this._primaryAreaHeight = this._configPrimary.height;
+        if (_config.areaWidth && _config.areaHeight) {
+            this.config.width = _config.areaWidth;
+            this.config.height = _config.areaHeight;
+        }
+        src = normalizeSVG(src);
+        const img = createHtmlImg(src);
+        const cropEvent = { ..._config };
+        new Observable(observer => {
+            img.onerror = err => observer.error(err);
+            img.onabort = err => observer.error(err);
+            img.onload = () => observer.next(null);
+        })
+            .pipe(take(1), takeUntil(this._destroy))
+            .subscribe(() => {
+            this._imgLoaded(img);
+            this._isLoadedImg = true;
+            this.imageLoaded.emit(cropEvent);
+            this.cd.markForCheck();
+            this._ngZone.runOutsideAngular(() => {
+                this._ngZone
+                    .onStable
+                    .asObservable()
+                    .pipe(take(1), takeUntil(this._destroy))
+                    .subscribe(() => setTimeout(() => this._ngZone.run(() => this._positionImg(cropEvent, fn))));
+            });
+        }, () => {
+            const error = {
+                name: _config.name,
+                error: ImgCropperError.Type,
+                type: _config.type,
+                size: _config.size
+            };
+            this.error.emit(error);
+        });
+    }
+    _updateAreaIfNeeded() {
+        if (!this._config.responsiveArea) {
+            return;
+        }
+        const rootRect = this._rootRect();
+        const areaRect = this._areaCropperRect();
+        const minWidth = this.config.minWidth || 1;
+        const minHeight = this.config.minHeight || 1;
+        if (!(areaRect.width > rootRect.width
+            || areaRect.height > rootRect.height
+            || areaRect.width < this._primaryAreaWidth
+            || areaRect.height < this._primaryAreaHeight)) {
+            return;
+        }
+        const areaWidthConf = Math.max(this.config.width, minWidth);
+        const areaWidthMax = Math.max(rootRect.width, minWidth);
+        const minHost = Math.min(Math.max(rootRect.width, minWidth), Math.max(rootRect.height, minHeight));
+        const currentScale = this._scal3Fix;
+        let newScale = 0;
+        const roundConf = this.config.round;
+        if (roundConf) {
+            this.config.width = this.config.height = minHost;
+        }
+        else {
+            if (areaWidthConf === areaRect.width) {
+                if (areaWidthMax > this._primaryAreaWidth) {
+                    this.config.width = this._primaryAreaWidth;
+                    this.config.height = (this._primaryAreaWidth * areaRect.height) / areaRect.width;
+                    newScale = (currentScale * this._primaryAreaWidth) / areaRect.width;
+                }
+                else {
+                    this.config.width = areaWidthMax;
+                    this.config.height = (areaWidthMax * areaRect.height) / areaRect.width;
+                    newScale = (currentScale * areaWidthMax) / areaRect.width;
+                }
+                this._updateMinScale();
+                this._updateMaxScale();
+                this.setScale(newScale, true);
+                this._markForCheck();
+            }
+        }
+    }
+    _updateAbsoluteScale() {
+        const scale = this._scal3Fix / (this.config.width / this._primaryAreaWidth);
+        this._absoluteScale = scale;
+    }
+    /**
+     * Load Image from URL
+     * @deprecated Use `loadImage` instead of `setImageUrl`
+     * @param src URL
+     * @param fn function that will be called before emit the event loaded
+     */
+    setImageUrl(src, fn) {
+        this.loadImage(src, fn);
+    }
+    _positionImg(cropEvent, fn) {
+        const loadConfig = this._currentLoadConfig;
+        this._updateMinScale(this._imgCanvas.nativeElement);
+        this._updateMaxScale();
+        this.isLoaded = false;
+        if (fn) {
+            fn();
+        }
+        else {
+            if (loadConfig.scale) {
+                this.setScale(loadConfig.scale, true);
+            }
+            else {
+                this.setScale(this.minScale, true);
+            }
+            this.rotate(loadConfig.rotation || 0);
+            this._updateAreaIfNeeded();
+            this._markForCheck();
+            this._ngZone.runOutsideAngular(() => {
+                this._ngZone
+                    .onStable
+                    .asObservable()
+                    .pipe(take(1), takeUntil(this._destroy))
+                    .subscribe(() => {
+                    if (loadConfig.xOrigin != null && loadConfig.yOrigin != null) {
+                        this.updatePosition(loadConfig.xOrigin, loadConfig.yOrigin);
+                    }
+                    this._updateAreaIfNeeded();
+                    this.isLoaded = true;
+                    this._cropIfAutoCrop();
+                    this._ngZone.run(() => {
+                        this._markForCheck();
+                        this.ready.emit(cropEvent);
+                    });
+                });
+            });
+        }
+    }
+    rotate(degrees) {
+        let validDegrees = _normalizeDegrees(degrees);
+        // If negative convert to positive
+        if (validDegrees < 0) {
+            validDegrees += 360;
+        }
+        const newRotation = _normalizeDegrees((this._rotation || 0) + validDegrees);
+        if (newRotation === this._rotation) {
+            return;
+        }
+        const degreesRad = validDegrees * Math.PI / 180;
+        const canvas = this._imgCanvas.nativeElement;
+        const canvasClon = createCanvasImg(canvas);
+        const ctx = canvas.getContext("2d");
+        this._rotation = newRotation;
+        // clear
+        ctx.clearRect(0, 0, canvasClon.width, canvasClon.height);
+        // rotate canvas image
+        const transform = `rotate(${validDegrees}deg) scale(${1 / this._scal3Fix})`;
+        const transformOrigin = `${this._imgRect.xc}px ${this._imgRect.yc}px 0`;
+        canvas.style.transform = transform;
+        // tslint:disable-next-line: deprecation
+        canvas.style.webkitTransform = transform;
+        canvas.style.transformOrigin = transformOrigin;
+        // tslint:disable-next-line: deprecation
+        canvas.style.webkitTransformOrigin = transformOrigin;
+        const { left, top } = canvas.getBoundingClientRect();
+        // save rect
+        const canvasRect = canvas.getBoundingClientRect();
+        // remove rotate styles
+        canvas.removeAttribute("style");
+        // set w & h
+        const w = canvasRect.width;
+        const h = canvasRect.height;
+        ctx.canvas.width = w;
+        ctx.canvas.height = h;
+        // clear
+        ctx.clearRect(0, 0, w, h);
+        // translate and rotate
+        ctx.translate(w / 2, h / 2);
+        ctx.rotate(degreesRad);
+        ctx.drawImage(canvasClon, -canvasClon.width / 2, -canvasClon.height / 2);
+        // Update min scale
+        this._updateMinScale(canvas);
+        this._updateMaxScale();
+        // set the minimum scale, only if necessary
+        if (this.scale < this.minScale) {
+            this.setScale(0, true);
+        } //                ↑ no AutoCrop
+        const rootRect = this._rootRect();
+        this._setStylesForContImg({
+            x: (left - rootRect.left),
+            y: (top - rootRect.top)
+        });
+        // keep image inside the frame
+        const originPosition = { ...this._imgRect };
+        this.offset = {
+            x: originPosition.x,
+            y: originPosition.y,
+            left: originPosition.xc,
+            top: originPosition.yc
+        };
+        this._setStylesForContImg({});
+        this._simulatePointerMove();
+        this._cropIfAutoCrop();
+    }
+    _updateMinScale(canvas) {
+        if (!canvas) {
+            canvas = this._imgCanvas.nativeElement;
+        }
+        const config = this.config;
+        const minScale = (config.extraZoomOut ? Math.min : Math.max)(config.width / canvas.width, config.height / canvas.height);
+        this._minScale = minScale;
+        this.minScaleChange.emit(minScale);
+    }
+    _updateMaxScale() {
+        const maxScale = (this.config.width / this._primaryAreaWidth);
+        this._maxScale = maxScale;
+        this.maxScaleChange.emit(maxScale);
+    }
+    /**
+     * Resize & crop image
+     */
+    crop(config) {
+        const newConfig = config
+            ? mergeDeep({}, this.config || new ImgCropperConfig(), config) : this.config;
+        const cropEvent = this._imgCrop(newConfig);
+        this.cd.markForCheck();
+        return cropEvent;
+    }
+    /**
+     * @docs-private
+     */
+    _imgCrop(myConfig) {
+        const canvasElement = document.createElement("canvas");
+        const areaRect = this._areaCropperRect();
+        const canvasRect = this._canvasRect();
+        const scaleFix = this._scal3Fix;
+        const left = (areaRect.left - canvasRect.left) / scaleFix;
+        const top = (areaRect.top - canvasRect.top) / scaleFix;
+        const { output } = myConfig;
+        const currentImageLoadConfig = this._currentLoadConfig;
+        const area = {
+            width: myConfig.width,
+            height: myConfig.height
+        };
+        canvasElement.width = area.width / scaleFix;
+        canvasElement.height = area.height / scaleFix;
+        const ctx = canvasElement.getContext("2d");
+        if (myConfig.fill) {
+            ctx.fillStyle = myConfig.fill;
+            ctx.fillRect(0, 0, canvasElement.width, canvasElement.height);
+        }
+        ctx.drawImage(this._imgCanvas.nativeElement, -(left), -(top));
+        const result = canvasElement;
+        if (myConfig.output === ImgResolution.Default) {
+            resizeCanvas(result, this._configPrimary.width, this._configPrimary.height);
+        }
+        else if (typeof output === "object") {
+            if (output.width && output.height) {
+                resizeCanvas(result, output.width, output.height);
+            }
+            else if (output.width) {
+                const newHeight = area.height * output.width / area.width;
+                resizeCanvas(result, output.width, newHeight);
+            }
+            else if (output.height) {
+                const newWidth = area.width * output.height / area.height;
+                resizeCanvas(result, newWidth, output.height);
+            }
+        }
+        const type = currentImageLoadConfig.originalDataURL.startsWith("http")
+            ? currentImageLoadConfig.type || myConfig.type
+            : myConfig.type || currentImageLoadConfig.type;
+        const dataURL = result.toDataURL(type);
+        const cropEvent = {
+            dataURL,
+            type,
+            name: currentImageLoadConfig.name,
+            areaWidth: this._primaryAreaWidth,
+            areaHeight: this._primaryAreaHeight,
+            width: result.width,
+            height: result.height,
+            originalDataURL: currentImageLoadConfig.originalDataURL,
+            scale: this._absoluteScale,
+            rotation: this._rotation,
+            left: (areaRect.left - canvasRect.left) / this._scal3Fix,
+            top: (areaRect.top - canvasRect.top) / this._scal3Fix,
+            size: currentImageLoadConfig.size,
+            xOrigin: this._imgRect.xc,
+            yOrigin: this._imgRect.yc,
+            position: {
+                x: this._imgRect.xc,
+                y: this._imgRect.yc
+            }
+        };
+        this.isCropped = true;
+        this.cropped.emit(cropEvent);
+        return cropEvent;
+    }
+    _rootRect() {
+        return this._elementRef.nativeElement.getBoundingClientRect();
+    }
+    _areaCropperRect() {
+        return this._areaRef.nativeElement.getBoundingClientRect();
+    }
+    _canvasRect() {
+        return this._imgCanvas.nativeElement.getBoundingClientRect();
+    }
+    _bindGlobalEvents(triggerEvent) {
+        const element = this._document;
+        const isTouch = isTouchEvent(triggerEvent);
+        const moveEventName = isTouch ? "touchmove" : "mousemove";
+        const endEventName = isTouch ? "touchend" : "mouseup";
+        element.addEventListener(moveEventName, this._pointerMove, activeEventOptions);
+        element.addEventListener(endEventName, this._pointerUp, activeEventOptions);
+        if (isTouch) {
+            element.addEventListener("touchcancel", this._pointerUp, activeEventOptions);
+        }
+        const window = this._getWindow();
+        if (typeof window !== "undefined" && window) {
+            window.addEventListener("blur", this._windowBlur);
+        }
+    }
+    /** Removes any global event listeners that we may have added. */
+    _removeGlobalEvents() {
+        const element = this._document;
+        element.removeEventListener("mousemove", this._pointerMove, activeEventOptions);
+        element.removeEventListener("mouseup", this._pointerUp, activeEventOptions);
+        element.removeEventListener("touchmove", this._pointerMove, activeEventOptions);
+        element.removeEventListener("touchend", this._pointerUp, activeEventOptions);
+        element.removeEventListener("touchcancel", this._pointerUp, activeEventOptions);
+        const window = this._getWindow();
+        if (typeof window !== "undefined" && window) {
+            window.removeEventListener("blur", this._windowBlur);
+        }
+    }
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    _getWindow() {
+        return this._document.defaultView || window;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.5", ngImport: i0, type: NiceImageCropperComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: DOCUMENT }, { token: i1.ViewportRuler }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.5", type: NiceImageCropperComponent, selector: "nice-img-cropper, nice-image-cropper", inputs: { config: "config", scale: "scale", maxFileSize: "maxFileSize" }, outputs: { scaleChange: "scaleChange", minScaleChange: "minScale", maxScaleChange: "maxScale", imageLoaded: "imageLoaded", ready: "ready", cropped: "cropped", cleaned: "cleaned", error: "error" }, viewQueries: [{ propertyName: "_imgContainer", first: true, predicate: ["_imgContainer"], descendants: true, static: true }, { propertyName: "_areaRef", first: true, predicate: ["_area"], descendants: true, read: ElementRef }, { propertyName: "_imgCanvas", first: true, predicate: ["_imgCanvas"], descendants: true, static: true }], ngImport: i0, template: "<!-- (selectstart): On Safari starting to slide temporarily triggers text selection mode which\nshow the wrong cursor. We prevent it by stopping the `selectstart` event. -->\n<div class=\"image-container\" #_imgContainer\n     (selectstart)=\"$event.preventDefault()\"\n>\n    <canvas #_imgCanvas></canvas>\n</div>\n<nice-cropper-area\n    #_area\n    *ngIf=\"_isLoadedImg\"\n    [round]=\"!!config.round\"\n    [resizableArea]=\"!!config.resizableArea\"\n    [keepAspectRatio]=\"!!config.keepAspectRatio\"\n    [ngStyle]=\"{\n        width: config.width + 'px',\n        height: config.height + 'px'\n    }\"\n></nice-cropper-area>\n<button class=\"close-button\" mat-icon-button *ngIf=\"_isLoadedImg\" (click)=\"clean()\">\n    <mat-icon>arrow_back</mat-icon>\n</button>\n", styles: ["nice-image-cropper,nice-img-cropper{-webkit-user-select:none;user-select:none;display:flex;overflow:hidden;position:relative;justify-content:center;align-items:center}nice-image-cropper .image-container,nice-img-cropper .image-container{cursor:move;position:absolute;top:0;left:0;display:flex;touch-action:none}nice-image-cropper .image-container>canvas,nice-img-cropper .image-container>canvas{display:block}nice-image-cropper .close-button,nice-img-cropper .close-button{position:absolute;top:8px;left:8px;background-color:#fff!important;border-radius:4px;height:20px;width:20px;min-height:20px}nice-image-cropper .close-button .mat-icon,nice-img-cropper .close-button .mat-icon{height:14px!important;width:14px!important;font-size:14px!important;line-height:14px!important}\n"], dependencies: [{ kind: "directive", type: i0.forwardRef(function () { return i2.NgIf; }), selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i0.forwardRef(function () { return i2.NgStyle; }), selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: i0.forwardRef(function () { return i3.MatIconButton; }), selector: "button[mat-icon-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i0.forwardRef(function () { return i4.MatIcon; }), selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i0.forwardRef(function () { return NiceCropperAreaComponent; }), selector: "nice-cropper-area", inputs: ["keepAspectRatio", "round", "resizableArea"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.5", ngImport: i0, type: NiceImageCropperComponent, decorators: [{
+            type: Component,
+            args: [{ changeDetection: ChangeDetectionStrategy.OnPush, preserveWhitespaces: false, selector: "nice-img-cropper, nice-image-cropper", encapsulation: ViewEncapsulation.None, template: "<!-- (selectstart): On Safari starting to slide temporarily triggers text selection mode which\nshow the wrong cursor. We prevent it by stopping the `selectstart` event. -->\n<div class=\"image-container\" #_imgContainer\n     (selectstart)=\"$event.preventDefault()\"\n>\n    <canvas #_imgCanvas></canvas>\n</div>\n<nice-cropper-area\n    #_area\n    *ngIf=\"_isLoadedImg\"\n    [round]=\"!!config.round\"\n    [resizableArea]=\"!!config.resizableArea\"\n    [keepAspectRatio]=\"!!config.keepAspectRatio\"\n    [ngStyle]=\"{\n        width: config.width + 'px',\n        height: config.height + 'px'\n    }\"\n></nice-cropper-area>\n<button class=\"close-button\" mat-icon-button *ngIf=\"_isLoadedImg\" (click)=\"clean()\">\n    <mat-icon>arrow_back</mat-icon>\n</button>\n", styles: ["nice-image-cropper,nice-img-cropper{-webkit-user-select:none;user-select:none;display:flex;overflow:hidden;position:relative;justify-content:center;align-items:center}nice-image-cropper .image-container,nice-img-cropper .image-container{cursor:move;position:absolute;top:0;left:0;display:flex;touch-action:none}nice-image-cropper .image-container>canvas,nice-img-cropper .image-container>canvas{display:block}nice-image-cropper .close-button,nice-img-cropper .close-button{position:absolute;top:8px;left:8px;background-color:#fff!important;border-radius:4px;height:20px;width:20px;min-height:20px}nice-image-cropper .close-button .mat-icon,nice-img-cropper .close-button .mat-icon{height:14px!important;width:14px!important;font-size:14px!important;line-height:14px!important}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.ViewportRuler }]; }, propDecorators: { _imgContainer: [{
+                type: ViewChild,
+                args: ["_imgContainer", { static: true }]
+            }], _areaRef: [{
+                type: ViewChild,
+                args: ["_area", { read: ElementRef }]
+            }], _imgCanvas: [{
+                type: ViewChild,
+                args: ["_imgCanvas", { static: true }]
+            }], config: [{
+                type: Input
+            }], scale: [{
+                type: Input
+            }], maxFileSize: [{
+                type: Input
+            }], scaleChange: [{
+                type: Output
+            }], minScaleChange: [{
+                type: Output,
+                args: ["minScale"]
+            }], maxScaleChange: [{
+                type: Output,
+                args: ["maxScale"]
+            }], imageLoaded: [{
+                type: Output
+            }], ready: [{
+                type: Output
+            }], cropped: [{
+                type: Output
+            }], cleaned: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }] } });
+/**
+ * Normalize degrees for cropper rotation
+ * @docs-private
+ */
+export function _normalizeDegrees(n) {
+    const de = n % 360;
+    if (de % 90) {
+        throw new Error(`LyCropper: Invalid \`${n}\` degree, only accepted values: 0, 90, 180, 270 & 360.`);
+    }
+    return de;
+}
+/**
+ * @docs-private
+ */
+function createCanvasImg(img) {
+    // create a new canvas
+    const newCanvas = document.createElement("canvas");
+    const context = newCanvas.getContext("2d");
+    // set dimensions
+    newCanvas.width = img.width;
+    newCanvas.height = img.height;
+    // apply the old canvas to the new one
+    context.drawImage(img, 0, 0);
+    // return the new canvas
+    return newCanvas;
+}
+const DATA_IMAGE_SVG_PREFIX = "data:image/svg+xml;base64,";
+function normalizeSVG(dataURL) {
+    if (window.atob && isSvgImage(dataURL)) {
+        const len = dataURL.length / 5;
+        const text = window.atob(dataURL.replace(DATA_IMAGE_SVG_PREFIX, ""));
+        const span = document.createElement("span");
+        span.innerHTML = text;
+        const svg = span.querySelector("svg");
+        span.setAttribute("style", "display:none");
+        document.body.appendChild(span);
+        const width = parseFloat(getComputedStyle(svg).width) || 1;
+        const height = parseFloat(getComputedStyle(svg).height) || 1;
+        const max = Math.max(width, height);
+        svg.setAttribute("width", `${len / (width / max)}px`);
+        svg.setAttribute("height", `${len / (height / max)}px`);
+        const result = DATA_IMAGE_SVG_PREFIX + window.btoa(span.innerHTML);
+        document.body.removeChild(span);
+        return result;
+    }
+    return dataURL;
+}
+function isSvgImage(dataUrl) {
+    return dataUrl.startsWith(DATA_IMAGE_SVG_PREFIX);
+}
+function createHtmlImg(src) {
+    const img = new Image();
+    img.crossOrigin = "anonymous";
+    img.src = src;
+    return img;
+}
+function getGesturePointFromEvent(event) {
+    // `touches` will be empty for start/end events so we have to fall back to `changedTouches`.
+    const point = isTouchEvent(event)
+        ? (event.touches[0] || event.changedTouches[0])
+        : event;
+    return {
+        x: point.clientX,
+        y: point.clientY
+    };
+}
+/** Returns whether an event is a touch event. */
+function isTouchEvent(event) {
+    return event.type[0] === "t";
+}
+export function round(n) {
+    return Math.round(n);
+}
+/**
+ * Simple object check.
+ * @param item
+ */
+function isObject(item) {
+    return (item && typeof item === "object" && !Array.isArray(item));
+}
+/**
+ * Deep merge two objects.
+ * @param target
+ * @param ...sources
+ */
+export function mergeDeep(target, ...sources) {
+    if (!sources.length) {
+        return target;
+    }
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key]) {
+                    Object.assign(target, { [key]: {} });
+                }
+                mergeDeep(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return mergeDeep(target, ...sources);
+}
+/**
+ * We have the cropper area in the same file to fix the build
+ */
+export class NiceCropperAreaComponent {
+    constructor(_document, _elementRef, _cropper, _ngZone) {
+        this._elementRef = _elementRef;
+        this._cropper = _cropper;
+        this._ngZone = _ngZone;
+        this._pointerDown = (event) => {
+            // Don't do anything if the
+            // user is using anything other than the main mouse button.
+            if (this._isSliding || (!isTouchEvent(event) && event.button !== 0)) {
+                return;
+            }
+            event.preventDefault();
+            this._ngZone.run(() => {
+                this._isSliding = true;
+                this._lastPointerEvent = event;
+                this._startPointerEvent = getGesturePointFromEvent(event);
+                this._startAreaRect = this._cropper._areaCropperRect();
+                this._startImgRect = this._cropper._canvasRect();
+                event.preventDefault();
+                this._bindGlobalEvents(event);
+            });
+        };
+        this._pointerMove = (event) => {
+            if (this._isSliding) {
+                event.preventDefault();
+                this._lastPointerEvent = event;
+                const element = this._elementRef.nativeElement;
+                const { width, height, minWidth, minHeight } = this._cropper.config;
+                const point = getGesturePointFromEvent(event);
+                const deltaX = point.x - this._startPointerEvent.x;
+                const deltaY = point.y - this._startPointerEvent.y;
+                const startAreaRect = this._startAreaRect;
+                const startImgRect = this._startImgRect;
+                const isRound = this.round;
+                const keepAspectRatio = this._cropper.config.keepAspectRatio || event.shiftKey;
+                let newWidth = 0;
+                let newHeight = 0;
+                const rootRect = this._cropper._rootRect();
+                if (isRound) {
+                    // The distance from the center of the cropper area to the pointer
+                    const originX = ((width / 2 / Math.sqrt(2)) + deltaX);
+                    const originY = ((height / 2 / Math.sqrt(2)) + deltaY);
+                    // Leg
+                    const side = Math.sqrt(originX ** 2 + originY ** 2);
+                    newWidth = newHeight = side * 2;
+                }
+                else if (keepAspectRatio) {
+                    newWidth = width + deltaX * 2;
+                    newHeight = height + deltaY * 2;
+                    if (width !== height) {
+                        if (width > height) {
+                            newHeight = height / (width / newWidth);
+                        }
+                        else if (height > width) {
+                            newWidth = width / (height / newHeight);
+                        }
+                    }
+                    else {
+                        newWidth = newHeight = Math.max(newWidth, newHeight);
+                    }
+                }
+                else {
+                    newWidth = width + deltaX * 2;
+                    newHeight = height + deltaY * 2;
+                }
+                // To min width
+                if (newWidth < minWidth) {
+                    newWidth = minWidth;
+                }
+                // To min height
+                if (newHeight < minHeight) {
+                    newHeight = minHeight;
+                }
+                // Do not overflow the cropper area
+                const centerX = startAreaRect.x + startAreaRect.width / 2;
+                const centerY = startAreaRect.y + startAreaRect.height / 2;
+                const topOverflow = startImgRect.y > centerY - (newHeight / 2);
+                const bottomOverflow = centerY + (newHeight / 2) > startImgRect.bottom;
+                const minHeightOnOverflow = Math.min((centerY - startImgRect.y) * 2, (startImgRect.bottom - centerY) * 2);
+                const leftOverflow = startImgRect.x > centerX - (newWidth / 2);
+                const rightOverflow = centerX + (newWidth / 2) > startImgRect.right;
+                const minWidthOnOverflow = Math.min((centerX - startImgRect.x) * 2, (startImgRect.right - centerX) * 2);
+                const minOnOverflow = Math.min(minWidthOnOverflow, minHeightOnOverflow);
+                if (round) {
+                    if (topOverflow || bottomOverflow || leftOverflow || rightOverflow) {
+                        newHeight = newWidth = minOnOverflow;
+                    }
+                }
+                else if (keepAspectRatio) {
+                    const newNewWidth = [];
+                    const newNewHeight = [];
+                    if ((topOverflow || bottomOverflow) && Math.min()) {
+                        newHeight = minHeightOnOverflow;
+                        newNewHeight.push(newHeight);
+                        newWidth = width / (height / minHeightOnOverflow);
+                        newNewWidth.push(newWidth);
+                    }
+                    if ((leftOverflow || rightOverflow)) {
+                        newWidth = minWidthOnOverflow;
+                        newNewWidth.push(newWidth);
+                        newHeight = height / (width / minWidthOnOverflow);
+                        newNewHeight.push(newHeight);
+                    }
+                    if (newNewWidth.length === 2) {
+                        newWidth = Math.min(...newNewWidth);
+                    }
+                    if (newNewHeight.length === 2) {
+                        newHeight = Math.min(...newNewHeight);
+                    }
+                }
+                else {
+                    if (topOverflow || bottomOverflow) {
+                        newHeight = minHeightOnOverflow;
+                    }
+                    if (leftOverflow || rightOverflow) {
+                        newWidth = minWidthOnOverflow;
+                    }
+                }
+                // Do not overflow the container
+                if (round) {
+                    const min = Math.min(rootRect.width, rootRect.height);
+                    if (newWidth > min) {
+                        newWidth = newHeight = min;
+                    }
+                    else if (newHeight > min) {
+                        newWidth = newHeight = min;
+                    }
+                }
+                else if (keepAspectRatio) {
+                    if (newWidth > rootRect.width) {
+                        newWidth = rootRect.width;
+                        newHeight = height / (width / rootRect.width);
+                    }
+                    else if (newHeight > rootRect.height) {
+                        newWidth = width / (height / rootRect.height);
+                        newHeight = rootRect.height;
+                    }
+                }
+                else {
+                    if (newWidth > rootRect.width) {
+                        newWidth = rootRect.width;
+                    }
+                    else if (newHeight > rootRect.height) {
+                        newHeight = rootRect.height;
+                    }
+                }
+                // round values
+                newWidth = Math.round(newWidth);
+                newHeight = Math.round(newHeight);
+                element.style.width = `${newWidth}px`;
+                element.style.height = `${newHeight}px`;
+                this._currentWidth = newWidth;
+                this._currentHeight = newHeight;
+            }
+        };
+        /** Called when the user has lifted their pointer. */
+        this._pointerUp = (event) => {
+            if (this._isSliding) {
+                event.preventDefault();
+                this._removeGlobalEvents();
+                this._cropper._primaryAreaWidth = this._cropper.config.width = this._currentWidth;
+                this._cropper._primaryAreaHeight = this._cropper.config.height = this._currentHeight;
+                this._cropper.config = this._cropper.config;
+                this._cropper._updateMinScale();
+                this._isSliding = false;
+                this._startPointerEvent = null;
+            }
+        };
+        /** Called when the window has lost focus. */
+        this._windowBlur = () => {
+            // If the window is blurred while dragging we need to stop dragging because the
+            // browser won't dispatch the `mouseup` and `touchend` events anymore.
+            if (this._lastPointerEvent) {
+                this._pointerUp(this._lastPointerEvent);
+            }
+        };
+        this._document = _document;
+    }
+    set resizableArea(val) {
+        if (val !== this._resizableArea) {
+            this._resizableArea = val;
+            Promise.resolve(null).then(() => {
+                if (val) {
+                    this._removeResizableArea();
+                    this._addResizableArea();
+                }
+                else {
+                    this._removeResizableArea();
+                }
+            });
+        }
+    }
+    get resizableArea() {
+        return this._resizableArea;
+    }
+    ngOnDestroy() {
+        this._removeResizableArea();
+    }
+    _addResizableArea() {
+        this._ngZone.runOutsideAngular(() => {
+            const element = this._resizer.nativeElement;
+            element.addEventListener("mousedown", this._pointerDown, activeEventOptions);
+            element.addEventListener("touchstart", this._pointerDown, activeEventOptions);
+        });
+    }
+    _removeResizableArea() {
+        const element = this._resizer?.nativeElement;
+        if (element) {
+            this._lastPointerEvent = null;
+            this._removeGlobalEvents();
+            element.removeEventListener("mousedown", this._pointerDown, activeEventOptions);
+            element.removeEventListener("touchstart", this._pointerDown, activeEventOptions);
+        }
+    }
+    _bindGlobalEvents(triggerEvent) {
+        const element = this._document;
+        const isTouch = isTouchEvent(triggerEvent);
+        const moveEventName = isTouch ? "touchmove" : "mousemove";
+        const endEventName = isTouch ? "touchend" : "mouseup";
+        element.addEventListener(moveEventName, this._pointerMove, activeEventOptions);
+        element.addEventListener(endEventName, this._pointerUp, activeEventOptions);
+        if (isTouch) {
+            element.addEventListener("touchcancel", this._pointerUp, activeEventOptions);
+        }
+        const window = this._getWindow();
+        if (typeof window !== "undefined" && window) {
+            window.addEventListener("blur", this._windowBlur);
+        }
+    }
+    /** Removes any global event listeners that we may have added. */
+    _removeGlobalEvents() {
+        const element = this._document;
+        element.removeEventListener("mousemove", this._pointerMove, activeEventOptions);
+        element.removeEventListener("mouseup", this._pointerUp, activeEventOptions);
+        element.removeEventListener("touchmove", this._pointerMove, activeEventOptions);
+        element.removeEventListener("touchend", this._pointerUp, activeEventOptions);
+        element.removeEventListener("touchcancel", this._pointerUp, activeEventOptions);
+        const window = this._getWindow();
+        if (typeof window !== "undefined" && window) {
+            window.removeEventListener("blur", this._windowBlur);
+        }
+    }
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    _getWindow() {
+        return this._document.defaultView || window;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.5", ngImport: i0, type: NiceCropperAreaComponent, deps: [{ token: DOCUMENT }, { token: i0.ElementRef }, { token: NiceImageCropperComponent }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.5", type: NiceCropperAreaComponent, selector: "nice-cropper-area", inputs: { keepAspectRatio: "keepAspectRatio", round: "round", resizableArea: "resizableArea" }, host: { properties: { "class.round": "this.round" } }, viewQueries: [{ propertyName: "_resizer", first: true, predicate: ["resizer"], descendants: true }], ngImport: i0, template: "<div class=\"resizer\" #resizer *ngIf=\"resizableArea\"></div>\n", styles: ["nice-cropper-area{pointer-events:none;box-shadow:0 0 0 20000px #0006;margin:auto;position:absolute;inset:0}nice-cropper-area.round{border-radius:50%}nice-cropper-area:before,nice-cropper-area:after{position:absolute;inset:0;content:\"\"}nice-cropper-area:before{width:0;height:0;margin:auto;border-radius:50%;background:#fff;border:solid 2px rgb(255,255,255)}nice-cropper-area:after{border:solid 2px rgb(255,255,255);border-radius:inherit}nice-cropper-area .resizer{width:10px;height:10px;background:#fff;border-radius:3px;position:absolute;touch-action:none;bottom:0;pointer-events:all}nice-cropper-area .resizer:before{content:\"\";width:20px;height:20px;transform:translate(-25%,-25%)}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.5", ngImport: i0, type: NiceCropperAreaComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "nice-cropper-area", encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"resizer\" #resizer *ngIf=\"resizableArea\"></div>\n", styles: ["nice-cropper-area{pointer-events:none;box-shadow:0 0 0 20000px #0006;margin:auto;position:absolute;inset:0}nice-cropper-area.round{border-radius:50%}nice-cropper-area:before,nice-cropper-area:after{position:absolute;inset:0;content:\"\"}nice-cropper-area:before{width:0;height:0;margin:auto;border-radius:50%;background:#fff;border:solid 2px rgb(255,255,255)}nice-cropper-area:after{border:solid 2px rgb(255,255,255);border-radius:inherit}nice-cropper-area .resizer{width:10px;height:10px;background:#fff;border-radius:3px;position:absolute;touch-action:none;bottom:0;pointer-events:all}nice-cropper-area .resizer:before{content:\"\";width:20px;height:20px;transform:translate(-25%,-25%)}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ElementRef }, { type: NiceImageCropperComponent }, { type: i0.NgZone }]; }, propDecorators: { _resizer: [{
+                type: ViewChild,
+                args: ["resizer"]
+            }], keepAspectRatio: [{
+                type: Input
+            }], round: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ["class.round"]
+            }], resizableArea: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-cropper.component.js","sourceRoot":"","sources":["../../../../../../projects/nice-ui-kit-v2/src/lib/components/image-cropper/image-cropper.component.ts","../../../../../../projects/nice-ui-kit-v2/src/lib/components/image-cropper/image-cropper.template.html","../../../../../../projects/nice-ui-kit-v2/src/lib/components/image-cropper/image-cropper-area.template.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * Adapted from https://github.com/A-l-y-l-e/Alyle-UI/tree/10.5.3/src/lib/image-cropper\n */\n\nimport { normalizePassiveListenerOptions } from \"@angular/cdk/platform\";\nimport { ViewportRuler } from \"@angular/cdk/scrolling\";\nimport { DOCUMENT } from \"@angular/common\";\nimport {\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ElementRef,\n    EventEmitter, HostBinding,\n    Inject,\n    Input,\n    NgZone,\n    OnDestroy,\n    OnInit,\n    Output,\n    Renderer2,\n    ViewChild,\n    ViewEncapsulation\n} from \"@angular/core\";\nimport { Observable, Subject } from \"rxjs\";\nimport { take, takeUntil } from \"rxjs/operators\";\nimport { resizeCanvas } from \"./resize-canvas\";\n\nconst activeEventOptions = normalizePassiveListenerOptions({ passive: false });\n\n/** Image Cropper Config */\nexport class ImgCropperConfig {\n    /** Cropper area width */\n    width = 250;\n    /** Cropper area height */\n    height = 200;\n    minWidth = 40;\n    minHeight = 40;\n    /** If this is not defined, the new image will be automatically defined. */\n    type?: string;\n    /** Background color( default: null), if is null in png is transparent but not in jpg. */\n    fill?: string | null;\n    /**\n     * Set anti-aliased (default: true)\n     * @deprecated this is not necessary as the cropper will automatically resize the image\n     * to the best quality\n     */\n    antiAliased = true;\n    autoCrop?: boolean;\n    output?: ImgOutput | ImgResolution = ImgResolution.Default;\n    /**\n     * Zoom out until the entire image fits into the cropping area.\n     * default: false\n     */\n    extraZoomOut?: boolean;\n    /**\n     * Emit event `error` if the file size in bytes for the limit.\n     * Note: It only works when the image is received from the `<input>` event.\n     */\n    maxFileSize?: number | null;\n    /**\n     * Whether the cropper area will be round.\n     * This implies that the cropper area will maintain its aspect ratio.\n     * default: false\n     */\n    round?: boolean;\n    /**\n     * Whether the cropper area is resizable.\n     * default: false\n     */\n    resizableArea?: boolean;\n    /**\n     * Keep the width and height of the growing area the same according\n     * to `ImgCropperConfig.width` and `ImgCropperConfig.height`\n     * default: false\n     */\n    keepAspectRatio?: boolean;\n    /**\n     * Whether the cropper area is responsive.\n     * By default, the width and height of the cropper area is fixed,\n     * so can use when the cropper area is larger than its container,\n     * otherwise this will bring problems when cropping.\n     */\n    responsiveArea?: boolean;\n}\n\n/**\n * The output image\n * With this option you can resize the output image.\n * If `width` or `height` are 0, this will be set automatically.\n * Both cannot be 0.\n */\nexport interface ImgOutput {\n    /**\n     * The cropped image will be resized to this `width`.\n     */\n    width: number;\n    /**\n     * Cropped image will be resized to this `height`.\n     */\n    height: number;\n}\n\n/** Image output */\nexport enum ImgResolution {\n    /**\n     * The output image will be equal to the initial size of the cropper area.\n     */\n    Default,\n    /** Just crop the image without resizing */\n    OriginalImage\n}\n\n/** Image output */\nexport enum ImgCropperError {\n    /** The loaded image exceeds the size limit set. */\n    Size,\n    /** The file loaded is not image. */\n    Type,\n    /** When the image has not been loaded. */\n    Other\n}\n\nexport interface ImgCropperEvent {\n    /** Cropped image data URL */\n    dataURL?: string;\n    name: string | null;\n    /** Filetype */\n    type?: string;\n    /** Cropped area width */\n    areaWidth: number;\n    /** Cropped area height */\n    areaHeight: number;\n    /** Cropped image width */\n    width: number;\n    /** Cropped image height */\n    height: number;\n    /** Original Image data URL */\n    originalDataURL?: string;\n    scale: number;\n    /** Current rotation in degrees */\n    rotation: number;\n    /** Size of the image in bytes */\n    size: number;\n    /** Scaled offset from the left edge of the image */\n    left: number;\n    /** Scaled offset from the top edge of the image */\n    top: number;\n    /**\n     * Scaled offset from the left edge of the image to center of area\n     * Can be used to set image position\n     */\n    xOrigin: number;\n    /**\n     * Scaled offset from the top edge of the image to center of area\n     * Can be used to set image position\n     */\n    yOrigin: number;\n    /** @deprecated Use `xOrigin & yOrigin` instead. */\n    position?: {\n        x: number\n        y: number\n    };\n}\n\nexport interface ImgCropperErrorEvent {\n    name?: string;\n    /** Size of the image in bytes */\n    size: number;\n    /** Filetype */\n    type: string;\n    /** Type of error */\n    error: ImgCropperError;\n    errorMsg?: string;\n}\n\ninterface ImgRect {\n    x: number;\n    y: number;\n    xc: number;\n    yc: number;\n    /** transform with */\n    wt: number;\n    ht: number;\n}\n\nexport interface ImgCropperLoaderConfig {\n    name?: string | null;\n    /** Filetype */\n    type?: string;\n    /** Cropped area width */\n    areaWidth?: number;\n    /** Cropped area height */\n    areaHeight?: number;\n    /** Cropped image width */\n    width?: number;\n    /** Cropped image height */\n    height?: number;\n    /** Original Image data URL */\n    originalDataURL: string;\n    scale?: number;\n    /** Current rotation in degrees */\n    rotation?: number;\n    /** Size of the image in bytes */\n    size?: number;\n    /** Offset from the left edge of the image to center of area */\n    xOrigin?: number;\n    /** Offset from the top edge of the image to center of area */\n    yOrigin?: number;\n}\n\n@Component({\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    preserveWhitespaces: false,\n    selector: \"nice-img-cropper, nice-image-cropper\",\n    templateUrl: \"image-cropper.template.html\",\n    styleUrls: [\"image-cropper.style.scss\"],\n    encapsulation: ViewEncapsulation.None\n})\nexport class NiceImageCropperComponent implements OnInit, OnDestroy {\n    static readonly и = \"NiceImageCropper\";\n\n    private _currentLoadConfig?: ImgCropperLoaderConfig;\n\n    /** Original image */\n    private _img: HTMLImageElement;\n    private offset?: {\n        x: number\n        y: number\n        left: number\n        top: number\n    };\n    private _scale?: number;\n    private _scal3Fix?: number;\n    private _minScale?: number;\n    private _maxScale?: number;\n    /** Initial config */\n    private _configPrimary: ImgCropperConfig;\n    private _config: ImgCropperConfig;\n    private _imgRect: ImgRect = {} as any;\n    private _rotation = 0;\n    // private _sizeInBytes: number | null;\n    private _isSliding: boolean;\n    /** Keeps track of the last pointer event that was captured by the crop area. */\n    private _lastPointerEvent: MouseEvent | TouchEvent | null;\n    private _startPointerEvent: {\n        x: number\n        y: number\n    } | null;\n    public _primaryAreaWidth: number;\n    public _primaryAreaHeight: number;\n\n    public _absoluteScale: number;\n\n    /**\n     * When is loaded image\n     * @internal\n     */\n    public _isLoadedImg: boolean;\n\n    /** When is loaded image & ready for crop */\n    public isLoaded: boolean;\n    /** When the cropper is ready to be interacted  */\n    public isReady: boolean;\n    public isCropped: boolean;\n\n    @ViewChild(\"_imgContainer\", { static: true })\n    private _imgContainer: ElementRef;\n\n    @ViewChild(\"_area\", { read: ElementRef })\n    private _areaRef: ElementRef;\n    @ViewChild(\"_imgCanvas\", { static: true })\n    private _imgCanvas: ElementRef<HTMLCanvasElement>;\n\n    @Input()\n    public set config(val: ImgCropperConfig) {\n        this._config = mergeDeep({}, new ImgCropperConfig(), val);\n        this._configPrimary = mergeDeep({}, this._config);\n        this._primaryAreaWidth = this.config.width;\n        this._primaryAreaHeight = this.config.height;\n        if (\n            this._config.round\n            && this.config.width !== this.config.height\n        ) {\n            throw new Error(`${NiceImageCropperComponent.и}: Both width and height must be equal when using \\`ImgCropperConfig.round = true\\``);\n        }\n        const maxFileSize = this._config.maxFileSize;\n        if (maxFileSize) {\n            this.maxFileSize = maxFileSize;\n        }\n    }\n    public get config(): ImgCropperConfig {\n        return this._config;\n    }\n    /** Set scale */\n    @Input()\n    public set scale(val: number | undefined) {\n        this.setScale(val);\n    }\n    public get scale(): number | undefined {\n        return this._scale;\n    }\n\n    /**\n     * Emit event `error` if the file size for the limit.\n     * Note: It only works when the image is received from the `<input>` event.\n     */\n    @Input()\n    public maxFileSize: number;\n\n    /** Get min scale */\n    public get minScale(): number | undefined {\n        return this._minScale;\n    }\n\n    @Output()\n    private readonly scaleChange = new EventEmitter<number>();\n\n    /** Emits minimum supported image scale */\n    // tslint:disable-next-line:no-output-rename\n    @Output(\"minScale\")\n    private readonly minScaleChange = new EventEmitter<number>();\n\n    /** Emits maximum supported image scale */\n    // tslint:disable-next-line:no-output-rename\n    @Output(\"maxScale\")\n    private readonly maxScaleChange = new EventEmitter<number>();\n\n    /** Emits when the image is loaded */\n    @Output()\n    private readonly imageLoaded = new EventEmitter<ImgCropperEvent>();\n\n    /** Emits when the cropper is ready to be interacted */\n    @Output()\n    private readonly ready = new EventEmitter<ImgCropperEvent>();\n\n    /** On crop new image */\n    @Output()\n    private readonly cropped = new EventEmitter<ImgCropperEvent>();\n\n    /** Emits when the cropper is cleaned */\n    @Output()\n    private readonly cleaned = new EventEmitter<void>();\n\n    /** Emit an error when the loaded image is not valid */\n    // tslint:disable-next-line: no-output-native\n    @Output()\n    private readonly error = new EventEmitter<ImgCropperErrorEvent>();\n\n    private _currentInputElement?: HTMLInputElement;\n\n    /** Emits whenever the component is destroyed. */\n    private readonly _destroy = new Subject<void>();\n\n    /** Used to subscribe to global move and end events */\n    protected _document: Document;\n\n    constructor(\n        private _renderer: Renderer2,\n        readonly _elementRef: ElementRef<HTMLElement>,\n        private cd: ChangeDetectorRef,\n        private _ngZone: NgZone,\n        @Inject(DOCUMENT) _document: any,\n        viewPortRuler: ViewportRuler\n    ) {\n        this._document = _document;\n        viewPortRuler.change()\n            .pipe(takeUntil(this._destroy))\n            .subscribe(() =>\n                this._ngZone.run(() => this.updateCropperPosition())\n            );\n    }\n\n    public ngOnInit(): void {\n        this._ngZone.runOutsideAngular(() => {\n            const element = this._imgContainer.nativeElement;\n            element.addEventListener(\"mousedown\", this._pointerDown, activeEventOptions);\n            element.addEventListener(\"touchstart\", this._pointerDown, activeEventOptions);\n        });\n    }\n\n    public ngOnDestroy(): void {\n        this._destroy.next();\n        this._destroy.complete();\n        const element = this._imgContainer.nativeElement;\n        this._lastPointerEvent = null;\n        this._removeGlobalEvents();\n        element.removeEventListener(\"mousedown\", this._pointerDown, activeEventOptions);\n        element.removeEventListener(\"touchstart\", this._pointerDown, activeEventOptions);\n    }\n\n    /** Load image with canvas */\n    private _imgLoaded(imgElement: HTMLImageElement): void {\n        if (imgElement) {\n            this._img = imgElement;\n            const canvas = this._imgCanvas.nativeElement;\n            canvas.width = imgElement.width;\n            canvas.height = imgElement.height;\n            const ctx = canvas.getContext(\"2d\");\n            ctx.clearRect(0, 0, imgElement.width, imgElement.height);\n            ctx.drawImage(imgElement, 0, 0);\n\n            /** set min scale */\n            this._updateMinScale(canvas);\n            this._updateMaxScale();\n        }\n    }\n\n    private _setStylesForContImg(values: { x?: number, y?: number }) {\n        const newStyles = { } as any;\n        if (values.x != null && values.y != null) {\n            const rootRect = this._rootRect();\n            const x = rootRect.width / 2 - (values.x);\n            const y = rootRect.height / 2 - (values.y);\n\n            this._imgRect.x = (values.x);\n            this._imgRect.y = (values.y);\n            this._imgRect.xc = (x);\n            this._imgRect.yc = (y);\n\n        }\n        newStyles.transform = `translate3d(${(this._imgRect.x)}px,${(this._imgRect.y)}px, 0)`;\n        newStyles.transform += `scale(${this._scal3Fix})`;\n        newStyles.transformOrigin = `${this._imgRect.xc}px ${this._imgRect.yc}px 0`;\n        newStyles[\"-webkit-transform\"] = newStyles.transform;\n        newStyles[\"-webkit-transform-origin\"] = newStyles.transformOrigin;\n        for (const key in newStyles) {\n            if (newStyles.hasOwnProperty(key)) {\n                this._renderer.setStyle(this._imgContainer.nativeElement, key, newStyles[key]);\n            }\n        }\n    }\n    /**\n     * Update area and image position only if needed,\n     * this is used when window resize\n     */\n    public updateCropperPosition(): void {\n        if (this.isLoaded) {\n            this.updatePosition();\n            this._updateAreaIfNeeded();\n        }\n    }\n\n    /** Load Image from input event */\n    public selectInputEvent(img: Event) {\n        this._currentInputElement = img.target as HTMLInputElement;\n        const _img = img.target as HTMLInputElement;\n        if (_img.files && _img.files.length !== 1) {\n            return;\n        }\n        const fileSize = _img.files[0].size;\n        const fileName = _img.value.replace(/.*(\\/|\\\\)/, \"\");\n\n        if (this.maxFileSize && fileSize > this.maxFileSize) {\n            const cropEvent: ImgCropperErrorEvent = {\n                name: fileName,\n                type: _img.files[0].type,\n                size: fileSize,\n                error: ImgCropperError.Size\n            };\n            this.clean();\n            this.error.emit(cropEvent as ImgCropperErrorEvent);\n            return;\n        }\n\n        new Observable<ProgressEvent>(observer => {\n\n            const reader = new FileReader();\n\n            reader.onerror = err => observer.error(err);\n            reader.onabort = err => observer.error(err);\n            reader.onload = (ev) => setTimeout(() => {\n                observer.next(ev);\n                observer.complete();\n            });\n\n            reader.readAsDataURL(_img.files[0]);\n        })\n            .pipe(take(1), takeUntil(this._destroy))\n            .subscribe(\n                (loadEvent) => {\n                    const originalDataURL = (loadEvent.target as FileReader).result as string;\n\n                    this.loadImage({\n                        name: fileName,\n                        size: _img.files[0].size, // size in bytes\n                        type: this.config.type || _img.files[0].type,\n                        originalDataURL\n                    });\n\n                    this.cd.markForCheck();\n                },\n                () => {\n                    const cropEvent: ImgCropperErrorEvent = {\n                        name: fileName,\n                        size: fileSize,\n                        error: ImgCropperError.Other,\n                        errorMsg: \"The File could not be loaded.\",\n                        type: _img.files[0].type\n                    };\n                    this.clean();\n                    this.error.emit(cropEvent as ImgCropperErrorEvent);\n                }\n            );\n\n    }\n\n    /** Set the size of the image, the values can be 0 between 1, where 1 is the original size */\n    public setScale(size?: number, noAutoCrop?: boolean) {\n        // fix min scale\n        const newSize = size >= this.minScale && size <= 1 ? size : this.minScale;\n\n        // check\n        const changed = size != null && size !== this.scale && newSize !== this.scale;\n        this._scale = size;\n        if (!changed) {\n            return;\n        }\n        this._scal3Fix = newSize;\n        this._updateAbsoluteScale();\n        if (this.isLoaded) {\n            if (changed) {\n                const originPosition = {...this._imgRect};\n                this.offset = {\n                    x: originPosition.x,\n                    y: originPosition.y,\n                    left: originPosition.xc,\n                    top: originPosition.yc\n                };\n                this._setStylesForContImg({});\n                this._simulatePointerMove();\n            } else {\n                return;\n            }\n        } else if (this.minScale) {\n            this._setStylesForContImg({\n                ...this._getCenterPoints()\n            });\n        } else {\n            return;\n        }\n\n        this.scaleChange.emit(size);\n        if (!noAutoCrop) {\n            this._cropIfAutoCrop();\n        }\n\n    }\n\n    private _getCenterPoints() {\n        const root = this._elementRef.nativeElement as HTMLElement;\n        const img = this._imgCanvas.nativeElement;\n        const x = (root.offsetWidth - (img.width)) / 2;\n        const y = (root.offsetHeight - (img.height)) / 2;\n        return {\n            x,\n            y\n        };\n    }\n\n    /**\n     * Fit to screen\n     */\n    public fitToScreen() {\n        const container = this._elementRef.nativeElement as HTMLElement;\n        const min = {\n            width: container.offsetWidth,\n            height: container.offsetHeight\n        };\n        const { width, height } = this._img;\n        const minScale = {\n            width: min.width / width,\n            height: min.height / height\n        };\n        const result = Math.max(minScale.width, minScale.height);\n        this.setScale(result);\n    }\n\n    public fit() {\n        this.setScale(this.minScale);\n    }\n\n    private _pointerDown = (event: TouchEvent | MouseEvent) => {\n        // Don't do anything if the\n        // user is using anything other than the main mouse button.\n        if (this._isSliding || (!isTouchEvent(event) && event.button !== 0)) {\n            return;\n        }\n\n        this._ngZone.run(() => {\n            this._isSliding = true;\n            this.offset = {\n                x: this._imgRect.x,\n                y: this._imgRect.y,\n                left: this._imgRect.xc,\n                top: this._imgRect.yc\n            };\n            this._lastPointerEvent = event;\n            this._startPointerEvent = getGesturePointFromEvent(event);\n            event.preventDefault();\n            this._bindGlobalEvents(event);\n        });\n\n    }\n\n    /**\n     * Simulate pointerMove with clientX = 0 and clientY = 0,\n     * this is used by `setScale` and `rotate`\n     */\n    private _simulatePointerMove() {\n        this._isSliding = true;\n        this._startPointerEvent = {\n            x: 0,\n            y: 0\n        };\n        this._pointerMove({\n            clientX: 0,\n            clientY: 0,\n            type: \"n\",\n            preventDefault: () => {}\n        } as MouseEvent);\n        this._isSliding = false;\n        this._startPointerEvent = null;\n    }\n\n    public _markForCheck() {\n        this.cd.markForCheck();\n    }\n\n    /**\n     * Called when the user has moved their pointer after\n     * starting to drag.\n     */\n    private _pointerMove = (event: TouchEvent | MouseEvent) => {\n        if (this._isSliding) {\n            event.preventDefault();\n            this._lastPointerEvent = event;\n            let x: number | undefined;\n            let y: number | undefined;\n            const canvas = this._imgCanvas.nativeElement;\n            const scaleFix = this._scal3Fix;\n            const config = this.config;\n            const startP = this.offset;\n            const point = getGesturePointFromEvent(event);\n            const deltaX = point.x - this._startPointerEvent.x;\n            const deltaY = point.y - this._startPointerEvent.y;\n            if (!scaleFix || !startP) {\n                return;\n            }\n\n            const isMinScaleY = canvas.height * scaleFix < config.height && config.extraZoomOut;\n            const isMinScaleX = canvas.width * scaleFix < config.width && config.extraZoomOut;\n\n            const limitLeft = (config.width / 2 / scaleFix) >= startP.left - (deltaX / scaleFix);\n            const limitRight = (config.width / 2 / scaleFix) +\n                (canvas.width) - (startP.left - (deltaX / scaleFix)) <= config.width / scaleFix;\n            const limitTop = ((config.height / 2 / scaleFix) >= (startP.top - (deltaY / scaleFix)));\n            const limitBottom = (\n                ((config.height / 2 / scaleFix) + (canvas.height) - (startP.top - (deltaY / scaleFix))) <= (config.height / scaleFix)\n            );\n\n            // Limit for left\n            if ((limitLeft && !isMinScaleX) || (!limitLeft && isMinScaleX)) {\n                x = startP.x + (startP.left) - (config.width / 2 / scaleFix);\n            }\n\n            // Limit for right\n            if ((limitRight && !isMinScaleX) || (!limitRight && isMinScaleX)) {\n                x = startP.x + (startP.left) + (config.width / 2 / scaleFix) - canvas.width;\n            }\n\n            // Limit for top\n            if ((limitTop && !isMinScaleY) || (!limitTop && isMinScaleY)) {\n                y = startP.y + (startP.top) - (config.height / 2 / scaleFix);\n            }\n\n            // Limit for bottom\n            if ((limitBottom && !isMinScaleY) || (!limitBottom && isMinScaleY)) {\n                y = startP.y + (startP.top) + (config.height / 2 / scaleFix) - canvas.height;\n            }\n\n            // When press shiftKey, deprecated\n            // if (event.srcEvent && event.srcEvent.shiftKey) {\n            //   if (Math.abs(event.deltaX) === Math.max(Math.abs(event.deltaX), Math.abs(event.deltaY))) {\n            //     y = this.offset.top;\n            //   } else {\n            //     x = this.offset.left;\n            //   }\n            // }\n\n            if (x === void 0) { x = (deltaX / scaleFix) + (startP.x); }\n            if (y === void 0) { y = (deltaY / scaleFix) + (startP.y); }\n            this._setStylesForContImg({\n                x, y\n            });\n        }\n    }\n\n    public updatePosition(): void;\n    public updatePosition(xOrigin: number, yOrigin: number): void;\n    public updatePosition(xOrigin?: number, yOrigin?: number): void {\n        const hostRect = this._rootRect();\n        const areaRect = this._areaCropperRect();\n        const areaWidth = areaRect.width > hostRect.width\n            ? hostRect.width\n            : areaRect.width;\n        const areaHeight = areaRect.height > hostRect.height\n            ? hostRect.height\n            : areaRect.height;\n        let x: number;\n        let y: number;\n        if (xOrigin == null && yOrigin == null) {\n            xOrigin = this._imgRect.xc;\n            yOrigin = this._imgRect.yc;\n        }\n        x = (areaRect.left - hostRect.left);\n        y = (areaRect.top - hostRect.top);\n        x -= (xOrigin - (areaWidth / 2));\n        y -= (yOrigin - (areaHeight / 2));\n\n        this._setStylesForContImg({\n            x, y\n        });\n    }\n\n    public _slideEnd() {\n        this._cropIfAutoCrop();\n    }\n\n    private _cropIfAutoCrop() {\n        if (this.config.autoCrop) {\n            this.crop();\n        }\n    }\n\n    /** + */\n    public zoomIn() {\n        const scale = this._scal3Fix + .05;\n        if (scale > this.minScale && scale <= this._maxScale) {\n            this.setScale(scale);\n        } else {\n            this.setScale(this._maxScale);\n        }\n    }\n\n    /** Clean the img cropper */\n    public clean() {\n        // fix choosing the same image does not load\n        if (this._currentInputElement) {\n            this._currentInputElement.value = \"\";\n            this._currentInputElement = null;\n        }\n        if (this.isLoaded) {\n            this._imgRect = { } as any;\n            this.offset = undefined;\n            this.scale = undefined as any;\n            this._scal3Fix = undefined;\n            this._rotation = 0;\n            this._minScale = undefined;\n            this._isLoadedImg = false;\n            this.isLoaded = false;\n            this.isCropped = false;\n            this._currentLoadConfig = undefined;\n            this.config = this._configPrimary;\n            const canvas = this._imgCanvas.nativeElement;\n            canvas.width = 0;\n            canvas.height = 0;\n            this.cleaned.emit(null);\n            this.cd.markForCheck();\n        }\n    }\n\n    /** - */\n    public zoomOut() {\n        const scale = this._scal3Fix - .05;\n        if (scale > this.minScale && scale <= this._maxScale) {\n            this.setScale(scale);\n        } else {\n            this.fit();\n        }\n    }\n    public center() {\n        const newStyles = {\n            ...this._getCenterPoints()\n        };\n        this._setStylesForContImg(newStyles);\n        this._cropIfAutoCrop();\n    }\n    /**\n     * load an image from a given configuration,\n     * or from the result of a cropped image\n     */\n    public loadImage(config: ImgCropperLoaderConfig | string, fn?: () => void) {\n        this.clean();\n        const _config = this._currentLoadConfig = typeof config === \"string\"\n            ? { originalDataURL: config }\n            : { ...config };\n        let src = _config.originalDataURL;\n        this._primaryAreaWidth = this._configPrimary.width;\n        this._primaryAreaHeight = this._configPrimary.height;\n        if (_config.areaWidth && _config.areaHeight) {\n            this.config.width = _config.areaWidth;\n            this.config.height = _config.areaHeight;\n        }\n        src = normalizeSVG(src);\n\n        const img = createHtmlImg(src);\n\n        const cropEvent = { ..._config } as ImgCropperEvent;\n\n        new Observable<void>(observer => {\n\n            img.onerror = err => observer.error(err);\n            img.onabort = err => observer.error(err);\n            img.onload = () => observer.next(null);\n        })\n            .pipe(take(1), takeUntil(this._destroy))\n            .subscribe(\n                () => {\n                    this._imgLoaded(img);\n                    this._isLoadedImg = true;\n                    this.imageLoaded.emit(cropEvent);\n                    this.cd.markForCheck();\n                    this._ngZone.runOutsideAngular(() => {\n                        this._ngZone\n                            .onStable\n                            .asObservable()\n                            .pipe(take(1), takeUntil(this._destroy))\n                            .subscribe(\n                                () => setTimeout(() => this._ngZone.run(() => this._positionImg(cropEvent, fn)))\n                            );\n                    });\n                },\n                () => {\n                    const error: ImgCropperErrorEvent = {\n                        name: _config.name,\n                        error: ImgCropperError.Type,\n                        type: _config.type,\n                        size: _config.size\n                    };\n                    this.error.emit(error);\n                }\n            );\n    }\n\n    private _updateAreaIfNeeded() {\n        if (!this._config.responsiveArea) {\n            return;\n        }\n\n        const rootRect = this._rootRect();\n        const areaRect = this._areaCropperRect();\n        const minWidth = this.config.minWidth || 1;\n        const minHeight = this.config.minHeight || 1;\n        if (!(\n            areaRect.width > rootRect.width\n            || areaRect.height > rootRect.height\n            || areaRect.width < this._primaryAreaWidth\n            || areaRect.height < this._primaryAreaHeight\n        )) {\n            return;\n        }\n        const areaWidthConf = Math.max(this.config.width, minWidth);\n        const areaWidthMax = Math.max(rootRect.width, minWidth);\n        const minHost = Math.min(\n            Math.max(rootRect.width, minWidth), Math.max(rootRect.height, minHeight)\n        );\n        const currentScale = this._scal3Fix;\n        let newScale = 0;\n        const roundConf = this.config.round;\n\n        if (roundConf) {\n            this.config.width = this.config.height = minHost;\n        } else {\n            if (areaWidthConf === areaRect.width) {\n                if (areaWidthMax > this._primaryAreaWidth) {\n                    this.config.width = this._primaryAreaWidth;\n                    this.config.height = (this._primaryAreaWidth * areaRect.height) / areaRect.width;\n                    newScale = (currentScale * this._primaryAreaWidth) / areaRect.width;\n                } else {\n                    this.config.width = areaWidthMax;\n                    this.config.height = (areaWidthMax * areaRect.height) / areaRect.width;\n                    newScale = (currentScale * areaWidthMax) / areaRect.width;\n                }\n                this._updateMinScale();\n                this._updateMaxScale();\n                this.setScale(newScale, true);\n                this._markForCheck();\n            }\n        }\n    }\n\n    private _updateAbsoluteScale() {\n        const scale = this._scal3Fix / (this.config.width / this._primaryAreaWidth);\n        this._absoluteScale = scale;\n    }\n\n    /**\n     * Load Image from URL\n     * @deprecated Use `loadImage` instead of `setImageUrl`\n     * @param src URL\n     * @param fn function that will be called before emit the event loaded\n     */\n    public setImageUrl(src: string, fn?: () => void) {\n        this.loadImage(src, fn);\n    }\n\n    private _positionImg(cropEvent: ImgCropperEvent, fn?: () => void) {\n        const loadConfig = this._currentLoadConfig;\n        this._updateMinScale(this._imgCanvas.nativeElement);\n        this._updateMaxScale();\n        this.isLoaded = false;\n        if (fn) {\n            fn();\n        } else {\n            if (loadConfig.scale) {\n                this.setScale(loadConfig.scale, true);\n            } else {\n                this.setScale(this.minScale, true);\n            }\n            this.rotate(loadConfig.rotation || 0);\n            this._updateAreaIfNeeded();\n            this._markForCheck();\n            this._ngZone.runOutsideAngular(() => {\n                this._ngZone\n                    .onStable\n                    .asObservable()\n                    .pipe(take(1), takeUntil(this._destroy))\n                    .subscribe(() => {\n                        if (loadConfig.xOrigin != null && loadConfig.yOrigin != null) {\n                            this.updatePosition(loadConfig.xOrigin, loadConfig.yOrigin);\n                        }\n                        this._updateAreaIfNeeded();\n                        this.isLoaded = true;\n                        this._cropIfAutoCrop();\n                        this._ngZone.run(() => {\n                            this._markForCheck();\n                            this.ready.emit(cropEvent);\n                        });\n                    });\n            });\n        }\n    }\n\n    public rotate(degrees: number) {\n        let validDegrees = _normalizeDegrees(degrees);\n        // If negative convert to positive\n        if (validDegrees < 0) {\n            validDegrees += 360;\n        }\n        const newRotation = _normalizeDegrees((this._rotation || 0) + validDegrees);\n        if (newRotation === this._rotation) {\n            return;\n        }\n        const degreesRad = validDegrees * Math.PI / 180;\n        const canvas = this._imgCanvas.nativeElement;\n        const canvasClon = createCanvasImg(canvas);\n        const ctx = canvas.getContext(\"2d\");\n        this._rotation = newRotation;\n\n        // clear\n        ctx.clearRect(0, 0, canvasClon.width, canvasClon.height);\n\n        // rotate canvas image\n        const transform = `rotate(${validDegrees}deg) scale(${1 / this._scal3Fix})`;\n        const transformOrigin = `${this._imgRect.xc}px ${this._imgRect.yc}px 0`;\n        canvas.style.transform = transform;\n        // tslint:disable-next-line: deprecation\n        canvas.style.webkitTransform = transform;\n        canvas.style.transformOrigin = transformOrigin;\n        // tslint:disable-next-line: deprecation\n        canvas.style.webkitTransformOrigin = transformOrigin;\n\n        const { left, top } = canvas.getBoundingClientRect() as DOMRect;\n\n        // save rect\n        const canvasRect = canvas.getBoundingClientRect();\n\n        // remove rotate styles\n        canvas.removeAttribute(\"style\");\n\n        // set w & h\n        const w = canvasRect.width;\n        const h = canvasRect.height;\n        ctx.canvas.width = w;\n        ctx.canvas.height = h;\n\n        // clear\n        ctx.clearRect(0, 0, w, h);\n\n        // translate and rotate\n        ctx.translate(w / 2, h / 2);\n        ctx.rotate(degreesRad);\n        ctx.drawImage(canvasClon, -canvasClon.width / 2, -canvasClon.height / 2);\n\n        // Update min scale\n        this._updateMinScale(canvas);\n        this._updateMaxScale();\n\n        // set the minimum scale, only if necessary\n        if (this.scale < this.minScale) {\n            this.setScale(0, true);\n        } //                ↑ no AutoCrop\n\n        const rootRect = this._rootRect();\n\n        this._setStylesForContImg({\n            x: (left - rootRect.left),\n            y: (top - rootRect.top)\n        });\n\n        // keep image inside the frame\n        const originPosition = {...this._imgRect};\n        this.offset = {\n            x: originPosition.x,\n            y: originPosition.y,\n            left: originPosition.xc,\n            top: originPosition.yc\n        };\n        this._setStylesForContImg({});\n        this._simulatePointerMove();\n\n        this._cropIfAutoCrop();\n    }\n\n    public _updateMinScale(canvas?: HTMLCanvasElement) {\n        if (!canvas) {\n            canvas = this._imgCanvas.nativeElement;\n        }\n        const config = this.config;\n        const minScale = (config.extraZoomOut ? Math.min : Math.max)(\n            config.width / canvas.width,\n            config.height / canvas.height);\n        this._minScale = minScale;\n        this.minScaleChange.emit(minScale);\n    }\n\n    private _updateMaxScale() {\n        const maxScale = (this.config.width / this._primaryAreaWidth);\n        this._maxScale = maxScale;\n        this.maxScaleChange.emit(maxScale);\n    }\n\n    /**\n     * Resize & crop image\n     */\n    public crop(config?: ImgCropperConfig): ImgCropperEvent {\n        const newConfig = config\n            ? mergeDeep({ }, this.config || new ImgCropperConfig(), config) : this.config;\n        const cropEvent = this._imgCrop(newConfig);\n        this.cd.markForCheck();\n        return cropEvent;\n    }\n\n    /**\n     * @docs-private\n     */\n    private _imgCrop(myConfig: ImgCropperConfig) {\n        const canvasElement: HTMLCanvasElement = document.createElement(\"canvas\");\n        const areaRect = this._areaCropperRect();\n        const canvasRect = this._canvasRect();\n        const scaleFix = this._scal3Fix;\n        const left = (areaRect.left - canvasRect.left) / scaleFix;\n        const top = (areaRect.top - canvasRect.top) / scaleFix;\n        const { output } = myConfig;\n        const currentImageLoadConfig = this._currentLoadConfig;\n        const area = {\n            width: myConfig.width,\n            height: myConfig.height\n        };\n        canvasElement.width = area.width / scaleFix;\n        canvasElement.height = area.height / scaleFix;\n        const ctx = canvasElement.getContext(\"2d\");\n        if (myConfig.fill) {\n            ctx.fillStyle = myConfig.fill;\n            ctx.fillRect(0, 0, canvasElement.width, canvasElement.height);\n        }\n        ctx.drawImage(this._imgCanvas.nativeElement,\n            -(left), -(top),\n        );\n        const result = canvasElement;\n        if (myConfig.output === ImgResolution.Default) {\n            resizeCanvas(\n                result,\n                this._configPrimary.width,\n                this._configPrimary.height);\n        } else if (typeof output === \"object\") {\n            if (output.width && output.height) {\n                resizeCanvas(result, output.width, output.height);\n            } else if (output.width) {\n                const newHeight = area.height * output.width / area.width;\n                resizeCanvas(result, output.width, newHeight);\n            } else if (output.height) {\n                const newWidth = area.width * output.height / area.height;\n                resizeCanvas(result, newWidth, output.height);\n            }\n        }\n        const type = currentImageLoadConfig.originalDataURL.startsWith(\"http\")\n            ? currentImageLoadConfig.type || myConfig.type\n            : myConfig.type || currentImageLoadConfig.type;\n        const dataURL = result.toDataURL(type);\n        const cropEvent: ImgCropperEvent = {\n            dataURL,\n            type,\n            name: currentImageLoadConfig.name,\n            areaWidth: this._primaryAreaWidth,\n            areaHeight: this._primaryAreaHeight,\n            width: result.width,\n            height: result.height,\n            originalDataURL: currentImageLoadConfig.originalDataURL,\n            scale: this._absoluteScale,\n            rotation: this._rotation,\n            left: (areaRect.left - canvasRect.left) / this._scal3Fix,\n            top: (areaRect.top - canvasRect.top) / this._scal3Fix,\n            size: currentImageLoadConfig.size,\n            xOrigin: this._imgRect.xc,\n            yOrigin: this._imgRect.yc,\n            position: {\n                x: this._imgRect.xc,\n                y: this._imgRect.yc\n            }\n        };\n\n        this.isCropped = true;\n        this.cropped.emit(cropEvent);\n        return cropEvent;\n    }\n\n    public _rootRect(): DOMRect {\n        return this._elementRef.nativeElement.getBoundingClientRect() as DOMRect;\n    }\n\n    public _areaCropperRect(): DOMRect {\n        return this._areaRef.nativeElement.getBoundingClientRect() as DOMRect;\n    }\n\n    public _canvasRect(): DOMRect {\n        return this._imgCanvas.nativeElement.getBoundingClientRect();\n    }\n\n\n    /** Called when the user has lifted their pointer. */\n    private _pointerUp = (event: TouchEvent | MouseEvent) => {\n        if (this._isSliding) {\n            event.preventDefault();\n            this._removeGlobalEvents();\n            this._isSliding = false;\n            this._startPointerEvent = null;\n            this._cropIfAutoCrop();\n        }\n    }\n\n    /** Called when the window has lost focus. */\n    private _windowBlur = () => {\n        // If the window is blurred while dragging we need to stop dragging because the\n        // browser won't dispatch the `mouseup` and `touchend` events anymore.\n        if (this._lastPointerEvent) {\n            this._pointerUp(this._lastPointerEvent);\n        }\n    }\n\n    private _bindGlobalEvents(triggerEvent: TouchEvent | MouseEvent) {\n        const element = this._document;\n        const isTouch = isTouchEvent(triggerEvent);\n        const moveEventName = isTouch ? \"touchmove\" : \"mousemove\";\n        const endEventName = isTouch ? \"touchend\" : \"mouseup\";\n        element.addEventListener(moveEventName, this._pointerMove, activeEventOptions);\n        element.addEventListener(endEventName, this._pointerUp, activeEventOptions);\n\n        if (isTouch) {\n            element.addEventListener(\"touchcancel\", this._pointerUp, activeEventOptions);\n        }\n\n        const window = this._getWindow();\n\n        if (typeof window !== \"undefined\" && window) {\n            window.addEventListener(\"blur\", this._windowBlur);\n        }\n    }\n\n    /** Removes any global event listeners that we may have added. */\n    private _removeGlobalEvents() {\n        const element = this._document;\n        element.removeEventListener(\"mousemove\", this._pointerMove, activeEventOptions);\n        element.removeEventListener(\"mouseup\", this._pointerUp, activeEventOptions);\n        element.removeEventListener(\"touchmove\", this._pointerMove, activeEventOptions);\n        element.removeEventListener(\"touchend\", this._pointerUp, activeEventOptions);\n        element.removeEventListener(\"touchcancel\", this._pointerUp, activeEventOptions);\n\n        const window = this._getWindow();\n\n        if (typeof window !== \"undefined\" && window) {\n            window.removeEventListener(\"blur\", this._windowBlur);\n        }\n    }\n\n    /** Use defaultView of injected document if available or fallback to global window reference */\n    private _getWindow(): Window {\n        return this._document.defaultView || window;\n    }\n\n}\n\n/**\n * Normalize degrees for cropper rotation\n * @docs-private\n */\nexport function _normalizeDegrees(n: number) {\n    const de = n % 360;\n    if (de % 90) {\n        throw new Error(`LyCropper: Invalid \\`${n}\\` degree, only accepted values: 0, 90, 180, 270 & 360.`);\n    }\n    return de;\n}\n\n/**\n * @docs-private\n */\nfunction createCanvasImg(img: HTMLCanvasElement | HTMLImageElement) {\n\n    // create a new canvas\n    const newCanvas = document.createElement(\"canvas\");\n    const context = newCanvas.getContext(\"2d\");\n\n    // set dimensions\n    newCanvas.width = img.width;\n    newCanvas.height = img.height;\n\n    // apply the old canvas to the new one\n    context.drawImage(img, 0, 0);\n\n    // return the new canvas\n    return newCanvas;\n}\n\n\nconst DATA_IMAGE_SVG_PREFIX = \"data:image/svg+xml;base64,\";\n\nfunction normalizeSVG(dataURL: string) {\n    if (window.atob && isSvgImage(dataURL)) {\n        const len = dataURL.length / 5;\n        const text = window.atob(dataURL.replace(DATA_IMAGE_SVG_PREFIX, \"\"));\n        const span = document.createElement(\"span\");\n        span.innerHTML = text;\n        const svg = span.querySelector(\"svg\");\n        span.setAttribute(\"style\", \"display:none\");\n        document.body.appendChild(span);\n        const width = parseFloat(getComputedStyle(svg).width) || 1;\n        const height = parseFloat(getComputedStyle(svg).height) || 1;\n        const max = Math.max(width, height);\n\n        svg.setAttribute(\"width\", `${len / (width / max)}px`);\n        svg.setAttribute(\"height\", `${len / (height / max)}px`);\n        const result = DATA_IMAGE_SVG_PREFIX + window.btoa(span.innerHTML);\n        document.body.removeChild(span);\n        return result;\n    }\n    return dataURL;\n}\n\nfunction isSvgImage(dataUrl: string) {\n    return dataUrl.startsWith(DATA_IMAGE_SVG_PREFIX);\n}\n\nfunction createHtmlImg(src: string) {\n    const img = new Image();\n    img.crossOrigin = \"anonymous\";\n    img.src = src;\n    return img;\n}\n\n\nfunction getGesturePointFromEvent(event: TouchEvent | MouseEvent) {\n\n    // `touches` will be empty for start/end events so we have to fall back to `changedTouches`.\n    const point = isTouchEvent(event)\n        ? (event.touches[0] || event.changedTouches[0])\n        : event;\n\n    return {\n        x: point.clientX,\n        y: point.clientY\n    };\n}\n\n/** Returns whether an event is a touch event. */\nfunction isTouchEvent(event: MouseEvent | TouchEvent): event is TouchEvent {\n    return event.type[0] === \"t\";\n}\n\nexport function round(n: number) {\n    return Math.round(n);\n}\n\n/**\n * Simple object check.\n * @param item\n */\nfunction isObject(item) {\n    return (item && typeof item === \"object\" && !Array.isArray(item));\n}\n\nexport function mergeDeep<T, U>(target: T, source: U): T & U;\nexport function mergeDeep<T, U, V>(target: T, source1: U, source2: V): T & U & V;\nexport function mergeDeep<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;\nexport function mergeDeep(target: object, ...sources: any[]): any;\n\n/**\n * Deep merge two objects.\n * @param target\n * @param ...sources\n */\nexport function mergeDeep(target: any, ...sources: any[]) {\n    if (!sources.length) { return target; }\n    const source = sources.shift();\n\n    if (isObject(target) && isObject(source)) {\n        for (const key in source) {\n            if (isObject(source[key])) {\n                if (!target[key]) { Object.assign(target, { [key]: {} }); }\n                mergeDeep(target[key], source[key]);\n            } else {\n                Object.assign(target, { [key]: source[key] });\n            }\n        }\n    }\n\n    return mergeDeep(target, ...sources);\n}\n\n\n/**\n * We have the cropper area in the same file to fix the build\n */\n\n@Component({\n    selector: \"nice-cropper-area\",\n    templateUrl: \"./image-cropper-area.template.html\",\n    styleUrls: [\"./image-cropper-area.style.scss\"],\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class NiceCropperAreaComponent implements OnDestroy {\n    @ViewChild(\"resizer\")\n    private readonly _resizer?: ElementRef;\n\n    @Input()\n    public keepAspectRatio: boolean;\n\n    @Input()\n    @HostBinding(\"class.round\")\n    public round: boolean;\n\n    /** Used to subscribe to global move and end events */\n    protected _document: Document;\n    private _isSliding: boolean;\n\n    /** Keeps track of the last pointer event that was captured by the crop area. */\n    private _lastPointerEvent: MouseEvent | TouchEvent | null;\n    private _startPointerEvent: {\n        x: number\n        y: number\n    } | null;\n    private _currentWidth: number;\n    private _currentHeight: number;\n    private _startAreaRect: DOMRect;\n    private _startImgRect: DOMRect;\n\n    constructor(\n        @Inject(DOCUMENT) _document: any,\n        private readonly _elementRef: ElementRef,\n        private readonly _cropper: NiceImageCropperComponent,\n        private readonly _ngZone: NgZone,\n    ) {\n        this._document = _document;\n    }\n\n    private _resizableArea: boolean;\n\n    @Input()\n    public set resizableArea(val: boolean) {\n        if (val !== this._resizableArea) {\n            this._resizableArea = val;\n            Promise.resolve(null).then(() => {\n                if (val) {\n                    this._removeResizableArea();\n                    this._addResizableArea();\n                } else {\n                    this._removeResizableArea();\n                }\n            });\n        }\n    }\n    public get resizableArea() {\n        return this._resizableArea;\n    }\n\n    public ngOnDestroy() {\n        this._removeResizableArea();\n    }\n\n    private _addResizableArea() {\n        this._ngZone.runOutsideAngular(() => {\n            const element = this._resizer.nativeElement;\n            element.addEventListener(\"mousedown\", this._pointerDown, activeEventOptions);\n            element.addEventListener(\"touchstart\", this._pointerDown, activeEventOptions);\n        });\n    }\n\n    private _removeResizableArea() {\n        const element = this._resizer?.nativeElement;\n        if (element) {\n            this._lastPointerEvent = null;\n            this._removeGlobalEvents();\n            element.removeEventListener(\"mousedown\", this._pointerDown, activeEventOptions);\n            element.removeEventListener(\"touchstart\", this._pointerDown, activeEventOptions);\n        }\n    }\n\n    private _pointerDown = (event: MouseEvent | TouchEvent) => {\n        // Don't do anything if the\n        // user is using anything other than the main mouse button.\n        if (this._isSliding || (!isTouchEvent(event) && event.button !== 0)) {\n            return;\n        }\n\n        event.preventDefault();\n\n        this._ngZone.run(() => {\n            this._isSliding = true;\n            this._lastPointerEvent = event;\n            this._startPointerEvent = getGesturePointFromEvent(event);\n            this._startAreaRect = this._cropper._areaCropperRect();\n            this._startImgRect = this._cropper._canvasRect();\n            event.preventDefault();\n            this._bindGlobalEvents(event);\n        });\n    }\n\n    private _pointerMove = (event: MouseEvent | TouchEvent) => {\n        if (this._isSliding) {\n            event.preventDefault();\n            this._lastPointerEvent = event;\n            const element: HTMLDivElement = this._elementRef.nativeElement;\n            const {width, height, minWidth, minHeight} = this._cropper.config;\n            const point = getGesturePointFromEvent(event);\n            const deltaX = point.x - this._startPointerEvent.x;\n            const deltaY = point.y - this._startPointerEvent.y;\n            const startAreaRect = this._startAreaRect;\n            const startImgRect = this._startImgRect;\n            const isRound = this.round;\n            const keepAspectRatio = this._cropper.config.keepAspectRatio || event.shiftKey;\n            let newWidth = 0;\n            let newHeight = 0;\n            const rootRect = this._cropper._rootRect();\n\n            if (isRound) {\n                // The distance from the center of the cropper area to the pointer\n                const originX = ((width / 2 / Math.sqrt(2)) + deltaX);\n                const originY = ((height / 2 / Math.sqrt(2)) + deltaY);\n\n                // Leg\n                const side = Math.sqrt(originX ** 2 + originY ** 2);\n                newWidth = newHeight = side * 2;\n\n            } else if (keepAspectRatio) {\n                newWidth = width + deltaX * 2;\n                newHeight = height + deltaY * 2;\n                if (width !== height) {\n                    if (width > height) {\n                        newHeight = height / (width / newWidth);\n                    } else if (height > width) {\n                        newWidth = width / (height / newHeight);\n                    }\n                } else {\n                    newWidth = newHeight = Math.max(newWidth, newHeight);\n                }\n            } else {\n                newWidth = width + deltaX * 2;\n                newHeight = height + deltaY * 2;\n            }\n\n            // To min width\n            if (newWidth < minWidth) {\n                newWidth = minWidth;\n            }\n            // To min height\n            if (newHeight < minHeight) {\n                newHeight = minHeight;\n            }\n\n            // Do not overflow the cropper area\n            const centerX = startAreaRect.x + startAreaRect.width / 2;\n            const centerY = startAreaRect.y + startAreaRect.height / 2;\n            const topOverflow = startImgRect.y > centerY - (newHeight / 2);\n            const bottomOverflow = centerY + (newHeight / 2) > startImgRect.bottom;\n            const minHeightOnOverflow = Math.min((centerY - startImgRect.y) * 2, (startImgRect.bottom - centerY) * 2);\n            const leftOverflow = startImgRect.x > centerX - (newWidth / 2);\n            const rightOverflow = centerX + (newWidth / 2) > startImgRect.right;\n            const minWidthOnOverflow = Math.min((centerX - startImgRect.x) * 2, (startImgRect.right - centerX) * 2);\n            const minOnOverflow = Math.min(minWidthOnOverflow, minHeightOnOverflow);\n            if (round) {\n                if (topOverflow || bottomOverflow || leftOverflow || rightOverflow) {\n                    newHeight = newWidth = minOnOverflow;\n                }\n            } else if (keepAspectRatio) {\n                const newNewWidth: number[] = [];\n                const newNewHeight: number[] = [];\n                if ((topOverflow || bottomOverflow) && Math.min()) {\n                    newHeight = minHeightOnOverflow;\n                    newNewHeight.push(newHeight);\n                    newWidth = width / (height / minHeightOnOverflow);\n                    newNewWidth.push(newWidth);\n                }\n                if ((leftOverflow || rightOverflow)) {\n                    newWidth = minWidthOnOverflow;\n                    newNewWidth.push(newWidth);\n                    newHeight = height / (width / minWidthOnOverflow);\n                    newNewHeight.push(newHeight);\n                }\n                if (newNewWidth.length === 2) {\n                    newWidth = Math.min(...newNewWidth);\n                }\n                if (newNewHeight.length === 2) {\n                    newHeight = Math.min(...newNewHeight);\n                }\n            } else {\n                if (topOverflow || bottomOverflow) {\n                    newHeight = minHeightOnOverflow;\n                }\n                if (leftOverflow || rightOverflow) {\n                    newWidth = minWidthOnOverflow;\n                }\n            }\n\n            // Do not overflow the container\n            if (round) {\n                const min = Math.min(rootRect.width, rootRect.height);\n                if (newWidth > min) {\n                    newWidth = newHeight = min;\n                } else if (newHeight > min) {\n                    newWidth = newHeight = min;\n                }\n            } else if (keepAspectRatio) {\n                if (newWidth > rootRect.width) {\n                    newWidth = rootRect.width;\n                    newHeight = height / (width / rootRect.width);\n                } else if (newHeight > rootRect.height) {\n                    newWidth = width / (height / rootRect.height);\n                    newHeight = rootRect.height;\n                }\n            } else {\n                if (newWidth > rootRect.width) {\n                    newWidth = rootRect.width;\n                } else if (newHeight > rootRect.height) {\n                    newHeight = rootRect.height;\n                }\n            }\n\n\n            // round values\n            newWidth = Math.round(newWidth);\n            newHeight = Math.round(newHeight);\n\n            element.style.width = `${newWidth}px`;\n            element.style.height = `${newHeight}px`;\n            this._currentWidth = newWidth;\n            this._currentHeight = newHeight;\n        }\n    }\n\n    /** Called when the user has lifted their pointer. */\n    private _pointerUp = (event: TouchEvent | MouseEvent) => {\n        if (this._isSliding) {\n            event.preventDefault();\n            this._removeGlobalEvents();\n            this._cropper._primaryAreaWidth = this._cropper.config.width = this._currentWidth;\n            this._cropper._primaryAreaHeight = this._cropper.config.height = this._currentHeight;\n            this._cropper.config = this._cropper.config;\n            this._cropper._updateMinScale();\n            this._isSliding = false;\n            this._startPointerEvent = null;\n        }\n    }\n\n    /** Called when the window has lost focus. */\n    private _windowBlur = () => {\n        // If the window is blurred while dragging we need to stop dragging because the\n        // browser won't dispatch the `mouseup` and `touchend` events anymore.\n        if (this._lastPointerEvent) {\n            this._pointerUp(this._lastPointerEvent);\n        }\n    }\n\n    private _bindGlobalEvents(triggerEvent: TouchEvent | MouseEvent) {\n        const element = this._document;\n        const isTouch = isTouchEvent(triggerEvent);\n        const moveEventName = isTouch ? \"touchmove\" : \"mousemove\";\n        const endEventName = isTouch ? \"touchend\" : \"mouseup\";\n        element.addEventListener(moveEventName, this._pointerMove, activeEventOptions);\n        element.addEventListener(endEventName, this._pointerUp, activeEventOptions);\n\n        if (isTouch) {\n            element.addEventListener(\"touchcancel\", this._pointerUp, activeEventOptions);\n        }\n\n        const window = this._getWindow();\n\n        if (typeof window !== \"undefined\" && window) {\n            window.addEventListener(\"blur\", this._windowBlur);\n        }\n    }\n\n    /** Removes any global event listeners that we may have added. */\n    private _removeGlobalEvents() {\n        const element = this._document;\n        element.removeEventListener(\"mousemove\", this._pointerMove, activeEventOptions);\n        element.removeEventListener(\"mouseup\", this._pointerUp, activeEventOptions);\n        element.removeEventListener(\"touchmove\", this._pointerMove, activeEventOptions);\n        element.removeEventListener(\"touchend\", this._pointerUp, activeEventOptions);\n        element.removeEventListener(\"touchcancel\", this._pointerUp, activeEventOptions);\n\n        const window = this._getWindow();\n\n        if (typeof window !== \"undefined\" && window) {\n            window.removeEventListener(\"blur\", this._windowBlur);\n        }\n    }\n\n    /** Use defaultView of injected document if available or fallback to global window reference */\n    private _getWindow(): Window {\n        return this._document.defaultView || window;\n    }\n}\n","<!-- (selectstart): On Safari starting to slide temporarily triggers text selection mode which\nshow the wrong cursor. We prevent it by stopping the `selectstart` event. -->\n<div class=\"image-container\" #_imgContainer\n     (selectstart)=\"$event.preventDefault()\"\n>\n    <canvas #_imgCanvas></canvas>\n</div>\n<nice-cropper-area\n    #_area\n    *ngIf=\"_isLoadedImg\"\n    [round]=\"!!config.round\"\n    [resizableArea]=\"!!config.resizableArea\"\n    [keepAspectRatio]=\"!!config.keepAspectRatio\"\n    [ngStyle]=\"{\n        width: config.width + 'px',\n        height: config.height + 'px'\n    }\"\n></nice-cropper-area>\n<button class=\"close-button\" mat-icon-button *ngIf=\"_isLoadedImg\" (click)=\"clean()\">\n    <mat-icon>arrow_back</mat-icon>\n</button>\n","<div class=\"resizer\" #resizer *ngIf=\"resizableArea\"></div>\n"]}