@bravobit/bb-foundation 0.15.6 → 0.16.3

package/esm2020/lib/core/services/exif.service.mjs

@@ -0,0 +1,163 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./platform.service";
+import * as i2 from "./file-loader.service";
+export class Exif {
+    constructor(_platform, _fileLoader) {
+        this._platform = _platform;
+        this._fileLoader = _fileLoader;
+        this.transformImage = (image, type, orientation, quality = 100) => {
+            // Create the canvas and context.
+            const canvas = document.createElement('canvas');
+            const context = canvas.getContext('2d');
+            // Validate the context exists.
+            if (!context) {
+                return null;
+            }
+            // Set the canvas size based on the image.
+            const { width, height } = image;
+            canvas.width = width;
+            canvas.height = height;
+            // Validate the orientation is correct
+            // else flip the canvas sizes.
+            if (4 < orientation && orientation < 9) {
+                canvas.width = height;
+                canvas.height = width;
+            }
+            // Transform the context based on the orientation.
+            switch (orientation) {
+                case 2:
+                    context.transform(-1, 0, 0, 1, width, 0);
+                    break;
+                case 3:
+                    context.transform(-1, 0, 0, -1, width, height);
+                    break;
+                case 4:
+                    context.transform(1, 0, 0, -1, 0, height);
+                    break;
+                case 5:
+                    context.transform(0, 1, 1, 0, 0, 0);
+                    break;
+                case 6:
+                    context.transform(0, 1, -1, 0, height, 0);
+                    break;
+                case 7:
+                    context.transform(0, -1, -1, 0, height, width);
+                    break;
+                case 8:
+                    context.transform(0, -1, 1, 0, 0, width);
+                    break;
+                default:
+                    break;
+            }
+            // Draw the image on the context and return the data URL.
+            context.drawImage(image, 0, 0, width, height);
+            return canvas.toDataURL(type, quality / 100);
+        };
+        this.getSupportedCanvasType = (fileType) => {
+            switch (fileType) {
+                case 'image/jpeg':
+                case 'image/jpg':
+                    return 'image/jpeg';
+                case 'image/x-windows-bmp':
+                case 'image/bmp':
+                    return 'image/bmp';
+                default:
+                    return 'image/png';
+            }
+        };
+        this.getOrientation = (buffer) => {
+            // Create a new data view.
+            const view = new DataView(buffer);
+            if (view.getUint16(0, false) !== 0xFFD8) {
+                return -2;
+            }
+            const length = view.byteLength;
+            let offset = 2;
+            while (offset < length) {
+                if (view.getUint16(offset + 2, false) <= 8) {
+                    return -1;
+                }
+                const marker = view.getUint16(offset, false);
+                offset += 2;
+                if (marker === 0xFFE1) {
+                    if (view.getUint32(offset += 2, false) !== 0x45786966) {
+                        return -1;
+                    }
+                    const little = view.getUint16(offset += 6, false) === 0x4949;
+                    offset += view.getUint32(offset + 4, little);
+                    const tags = view.getUint16(offset, little);
+                    offset += 2;
+                    for (let index = 0; index < tags; index++) {
+                        if (view.getUint16(offset + index * 12, little) === 0x0112) {
+                            return view.getUint16(offset + index * 12 + 8, little);
+                        }
+                    }
+                }
+                else if ((marker & 0xFF00) !== 0xFF00) {
+                    break;
+                }
+                else {
+                    offset += view.getUint16(offset, false);
+                }
+            }
+            return -1;
+        };
+    }
+    async strip(file, quality = 100) {
+        // Validate we are on a browser.
+        if (!this._platform.isBrowser) {
+            return file;
+        }
+        // Validate the file exists and is
+        // an instance of a File object.
+        if (!file || !(file instanceof File)) {
+            return file;
+        }
+        // Only jpeg images need correction.
+        if (!['image/jpeg'].includes(file.type)) {
+            return file;
+        }
+        try {
+            // Read the file as an array buffer and data url.
+            const arrayBuffer = await this._fileLoader.asArrayBuffer(file);
+            const dataUrl = await this._fileLoader.asDataUrl(file);
+            // Create an image element.
+            const imageElement = await this.createImageElement(dataUrl);
+            // Get the orientation by using the buffer.
+            const orientation = this.getOrientation(arrayBuffer);
+            // Transform the image to remove the orientation.
+            const canvasType = this.getSupportedCanvasType(file.type);
+            const imageUrl = this.transformImage(imageElement, canvasType, orientation, quality);
+            // Validate the image url exists.
+            if (!imageUrl) {
+                return file;
+            }
+            // Transform the image url to a file.
+            return this._fileLoader.fromDataUrl(imageUrl, file.name);
+        }
+        catch {
+            // When something goes wrong we
+            // just return the default file.
+            return file;
+        }
+    }
+    async createImageElement(dataUrl) {
+        return new Promise((resolve, reject) => {
+            const image = new Image();
+            image.src = dataUrl;
+            image.onerror = () => reject('Error image create');
+            image.onabort = () => reject('Abort image create');
+            image.onload = () => resolve(image);
+        });
+    }
+}
+Exif.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Exif, deps: [{ token: i1.Platform }, { token: i2.FileLoader }], target: i0.ɵɵFactoryTarget.Injectable });
+Exif.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Exif, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Exif, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: i2.FileLoader }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exif.service.js","sourceRoot":"","sources":["../../../../../../projects/bb-foundation/src/lib/core/services/exif.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {FileLoader} from './file-loader.service';\nimport {Platform} from './platform.service';\nimport {Injectable} from '@angular/core';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class Exif {\n\n    constructor(private _platform: Platform,\n                private _fileLoader: FileLoader) {\n    }\n\n    async strip(file: File, quality: number = 100) {\n        // Validate we are on a browser.\n        if (!this._platform.isBrowser) {\n            return file;\n        }\n\n        // Validate the file exists and is\n        // an instance of a File object.\n        if (!file || !(file instanceof File)) {\n            return file;\n        }\n\n        // Only jpeg images need correction.\n        if (!['image/jpeg'].includes(file.type)) {\n            return file;\n        }\n\n        try {\n            // Read the file as an array buffer and data url.\n            const arrayBuffer = await this._fileLoader.asArrayBuffer(file);\n            const dataUrl = await this._fileLoader.asDataUrl(file);\n\n            // Create an image element.\n            const imageElement = await this.createImageElement(dataUrl);\n\n            // Get the orientation by using the buffer.\n            const orientation = this.getOrientation(arrayBuffer);\n\n            // Transform the image to remove the orientation.\n            const canvasType = this.getSupportedCanvasType(file.type);\n            const imageUrl = this.transformImage(imageElement, canvasType, orientation, quality);\n\n            // Validate the image url exists.\n            if (!imageUrl) {\n                return file;\n            }\n\n            // Transform the image url to a file.\n            return this._fileLoader.fromDataUrl(imageUrl, file.name);\n        } catch {\n            // When something goes wrong we\n            // just return the default file.\n            return file;\n        }\n    }\n\n    private async createImageElement(dataUrl: string) {\n        return new Promise<HTMLImageElement>((resolve, reject) => {\n            const image = new Image();\n            image.src = dataUrl;\n            image.onerror = () => reject('Error image create');\n            image.onabort = () => reject('Abort image create');\n            image.onload = () => resolve(image);\n        });\n    }\n\n    private transformImage = (image: HTMLImageElement, type: string, orientation: number, quality: number = 100) => {\n        // Create the canvas and context.\n        const canvas = document.createElement('canvas');\n        const context = canvas.getContext('2d');\n\n        // Validate the context exists.\n        if (!context) {\n            return null;\n        }\n\n        // Set the canvas size based on the image.\n        const {width, height} = image;\n        canvas.width = width;\n        canvas.height = height;\n\n        // Validate the orientation is correct\n        // else flip the canvas sizes.\n        if (4 < orientation && orientation < 9) {\n            canvas.width = height;\n            canvas.height = width;\n        }\n\n        // Transform the context based on the orientation.\n        switch (orientation) {\n            case 2:\n                context.transform(-1, 0, 0, 1, width, 0);\n                break;\n            case 3:\n                context.transform(-1, 0, 0, -1, width, height);\n                break;\n            case 4:\n                context.transform(1, 0, 0, -1, 0, height);\n                break;\n            case 5:\n                context.transform(0, 1, 1, 0, 0, 0);\n                break;\n            case 6:\n                context.transform(0, 1, -1, 0, height, 0);\n                break;\n            case 7:\n                context.transform(0, -1, -1, 0, height, width);\n                break;\n            case 8:\n                context.transform(0, -1, 1, 0, 0, width);\n                break;\n            default:\n                break;\n        }\n\n        // Draw the image on the context and return the data URL.\n        context.drawImage(image, 0, 0, width, height);\n        return canvas.toDataURL(type, quality / 100);\n    };\n\n    private getSupportedCanvasType = (fileType: string) => {\n        switch (fileType) {\n            case 'image/jpeg':\n            case 'image/jpg':\n                return 'image/jpeg';\n            case 'image/x-windows-bmp':\n            case 'image/bmp':\n                return 'image/bmp';\n            default:\n                return 'image/png';\n        }\n    };\n\n    private getOrientation = (buffer: ArrayBuffer) => {\n        // Create a new data view.\n        const view = new DataView(buffer);\n\n        if (view.getUint16(0, false) !== 0xFFD8) {\n            return -2;\n        }\n\n        const length = view.byteLength;\n        let offset = 2;\n\n        while (offset < length) {\n            if (view.getUint16(offset + 2, false) <= 8) {\n                return -1;\n            }\n\n            const marker = view.getUint16(offset, false);\n            offset += 2;\n\n            if (marker === 0xFFE1) {\n                if (view.getUint32(offset += 2, false) !== 0x45786966) {\n                    return -1;\n                }\n\n                const little = view.getUint16(offset += 6, false) === 0x4949;\n                offset += view.getUint32(offset + 4, little);\n\n                const tags = view.getUint16(offset, little);\n                offset += 2;\n\n                for (let index = 0; index < tags; index++) {\n                    if (view.getUint16(offset + index * 12, little) === 0x0112) {\n                        return view.getUint16(offset + index * 12 + 8, little);\n                    }\n                }\n            } else if ((marker & 0xFF00) !== 0xFF00) {\n                break;\n            } else {\n                offset += view.getUint16(offset, false);\n            }\n        }\n\n        return -1;\n    };\n\n}\n"]}

package/esm2020/lib/core/services/file-loader.service.mjs

@@ -0,0 +1,87 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FileLoader {
+    constructor() {
+        this.isFile = (input) => {
+            return 'File' in window && input instanceof File;
+        };
+        this.isBlob = (input) => {
+            return 'Blob' in window && input instanceof Blob;
+        };
+        this.blobToFile = (blob, fileName) => {
+            const anyBlob = blob;
+            anyBlob.lastModifiedDate = new Date();
+            anyBlob.name = fileName;
+            return anyBlob;
+        };
+    }
+    fromDataUrl(value, name = 'file') {
+        if (!value) {
+            return null;
+        }
+        try {
+            // Convert base64 to raw binary data held in a string.
+            const byteString = window.atob(value.split(',')[1]);
+            // Separate out the mime component.
+            const mimeString = value
+                .split(',')[0]
+                .split(':')[1]
+                .split(';')[0];
+            // Write the bytes of the string to an ArrayBuffer.
+            const arrayBuffer = new ArrayBuffer(byteString.length);
+            const uint8Array = new Uint8Array(arrayBuffer);
+            for (let index = 0; index < byteString.length; index++) {
+                uint8Array[index] = byteString.charCodeAt(index);
+            }
+            const dataView = new DataView(arrayBuffer);
+            const blob = new Blob([dataView.buffer], { type: mimeString });
+            return this.createFile(blob, name);
+        }
+        catch {
+            return null;
+        }
+    }
+    asDataUrl(file) {
+        return this.read(file, 'dataurl');
+    }
+    asArrayBuffer(file) {
+        return this.read(file, 'arraybuffer');
+    }
+    async read(file, type) {
+        return new Promise((resolve, reject) => {
+            const isFileLike = this.isFile(file) || this.isBlob(file);
+            if (!file || !isFileLike) {
+                return reject('Invalid file');
+            }
+            const reader = new FileReader();
+            reader.onerror = () => reject('Error file read');
+            reader.onabort = () => reject('Abort file read');
+            reader.onload = () => {
+                const result = reader.result;
+                return resolve(result);
+            };
+            if (type === 'dataurl') {
+                reader.readAsDataURL(file);
+            }
+            else if (type === 'arraybuffer') {
+                reader.readAsArrayBuffer(file);
+            }
+        });
+    }
+    createFile(blob, name) {
+        if (!navigator['msSaveBlob']) {
+            return new File([blob], name, { lastModified: Date.now(), type: blob?.type });
+        }
+        const blobFile = new Blob([blob], { type: blob?.type });
+        return this.blobToFile(blobFile, name);
+    }
+}
+FileLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: FileLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FileLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: FileLoader, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: FileLoader, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-loader.service.js","sourceRoot":"","sources":["../../../../../../projects/bb-foundation/src/lib/core/services/file-loader.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class FileLoader {\n\n    fromDataUrl(value: string, name: string = 'file') {\n        if (!value) {\n            return null;\n        }\n\n        try {\n            // Convert base64 to raw binary data held in a string.\n            const byteString = window.atob(value.split(',')[1]);\n\n            // Separate out the mime component.\n            const mimeString = value\n                .split(',')[0]\n                .split(':')[1]\n                .split(';')[0];\n\n            // Write the bytes of the string to an ArrayBuffer.\n            const arrayBuffer = new ArrayBuffer(byteString.length);\n            const uint8Array = new Uint8Array(arrayBuffer);\n            for (let index = 0; index < byteString.length; index++) {\n                uint8Array[index] = byteString.charCodeAt(index);\n            }\n\n            const dataView = new DataView(arrayBuffer);\n            const blob = new Blob([dataView.buffer], {type: mimeString});\n\n            return this.createFile(blob, name);\n        } catch {\n            return null;\n        }\n    }\n\n    asDataUrl(file: File | Blob) {\n        return this.read<string>(file, 'dataurl');\n    }\n\n    asArrayBuffer(file: File | Blob) {\n        return this.read<ArrayBuffer>(file, 'arraybuffer');\n    }\n\n    private async read<T = string | ArrayBuffer>(file: File | Blob, type: 'dataurl' | 'arraybuffer') {\n        return new Promise<T>((resolve, reject) => {\n            const isFileLike = this.isFile(file) || this.isBlob(file);\n            if (!file || !isFileLike) {\n                return reject('Invalid file');\n            }\n\n            const reader = new FileReader();\n            reader.onerror = () => reject('Error file read');\n            reader.onabort = () => reject('Abort file read');\n            reader.onload = () => {\n                const result = reader.result as unknown;\n                return resolve(result as T);\n            };\n\n            if (type === 'dataurl') {\n                reader.readAsDataURL(file);\n            } else if (type === 'arraybuffer') {\n                reader.readAsArrayBuffer(file);\n            }\n        });\n    }\n\n    private isFile = (input: unknown) => {\n        return 'File' in window && input instanceof File;\n    };\n\n    private isBlob = (input: unknown) => {\n        return 'Blob' in window && input instanceof Blob;\n    };\n\n    private createFile(blob: Blob, name: string) {\n        if (!navigator['msSaveBlob']) {\n            return new File([blob], name, {lastModified: Date.now(), type: blob?.type});\n        }\n\n        const blobFile = new Blob([blob], {type: blob?.type});\n        return this.blobToFile(blobFile, name);\n    }\n\n    private blobToFile = (blob: Blob, fileName: string) => {\n        const anyBlob: any = blob;\n        anyBlob.lastModifiedDate = new Date();\n        anyBlob.name = fileName;\n        return anyBlob as File;\n    };\n\n}\n"]}

package/esm2020/lib/core/services/image-converter.service.mjs

@@ -0,0 +1,123 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./exif.service";
+import * as i2 from "./platform.service";
+import * as i3 from "./file-loader.service";
+export class ImageConverter {
+    constructor(_exif, _platform, _fileLoader) {
+        this._exif = _exif;
+        this._platform = _platform;
+        this._fileLoader = _fileLoader;
+        // Data.
+        this._types = ['image/png', 'image/jpeg'];
+        this.calculateOffsetAndDimensions = (image, canvasWidth, canvasHeight) => {
+            const originalWidth = image.width;
+            const originalHeight = image.height;
+            const widthRatio = canvasWidth / originalWidth;
+            const heightRatio = canvasHeight / originalHeight;
+            let width;
+            let height;
+            if (originalWidth > originalHeight) {
+                height = originalHeight * heightRatio;
+                width = (originalWidth / originalHeight) * height;
+            }
+            else {
+                width = originalWidth * widthRatio;
+                height = (originalHeight / originalWidth) * width;
+            }
+            let xOffset = 0;
+            let yOffset = 0;
+            if (canvasHeight === height) {
+                xOffset = -((width - canvasWidth) / 2);
+            }
+            else if (canvasWidth === width) {
+                yOffset = -((height - canvasHeight) / 2);
+            }
+            return { xOffset, yOffset, width, height };
+        };
+    }
+    async toDataUri(contents, options = null) {
+        // Check if the current platform is a browser.
+        if (!this._platform.isBrowser) {
+            return null;
+        }
+        // Get the image.
+        const image = await this.getImage(contents);
+        // Get the canvas width and height.
+        const canvasWidth = options?.width || image?.width;
+        const canvasHeight = options?.height || image?.height;
+        // Get the canvas and context.
+        const canvas = document.createElement('canvas');
+        const context = canvas.getContext('2d');
+        // Validate the context exists.
+        if (!context) {
+            return null;
+        }
+        // Set the width and height.
+        canvas.width = canvasWidth;
+        canvas.height = canvasHeight;
+        // When the canvas sizes are 0 we have failed.
+        if (canvas?.width === 0 && canvas?.height === 0) {
+            return null;
+        }
+        // Check if dimensions where supplied, else create the image.
+        if (!options) {
+            // Draw the image.
+            context.drawImage(image, 0, 0);
+            // Convert the canvas to a data url.
+            return canvas.toDataURL(this._types[0]);
+        }
+        // Get the dimensions and offsets.
+        const { width, height, xOffset, yOffset } = this.calculateOffsetAndDimensions(image, canvasWidth, canvasHeight);
+        // Draw the image.
+        context.drawImage(image, 0, 0, image.width, image.height, xOffset, yOffset, width, height);
+        // Convert the canvas to a data url.
+        return canvas.toDataURL(this._types[0]);
+    }
+    async fileToImage(file, types = this._types) {
+        // Check if the file matches an image.
+        if (!types.includes(file.type)) {
+            throw new Error('The selected file does not meet the required format.');
+        }
+        let stripped = null;
+        try {
+            stripped = await this._exif.strip(file, 90);
+        }
+        catch {
+            // Do nothing.
+        }
+        // Ge the data uri.
+        const dataUri = await this._fileLoader.asDataUrl(stripped ?? file);
+        // Convert the data URI to a image element.
+        return await this.stringToImage(dataUri);
+    }
+    stringToImage(src) {
+        return new Promise((resolve, reject) => {
+            const image = new Image();
+            image.src = src;
+            image.onload = () => resolve(image);
+            image.onerror = error => reject(error);
+        });
+    }
+    async getImage(contents) {
+        // If the contents is already an HTML image element just return it.
+        if (contents instanceof HTMLImageElement) {
+            return contents;
+        }
+        // If the contents is a file convert it to an HTML image element.
+        if (contents instanceof File) {
+            return this.fileToImage(contents);
+        }
+        // If the contents is a string convert it to an HTML image element.
+        return this.stringToImage(contents);
+    }
+}
+ImageConverter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: ImageConverter, deps: [{ token: i1.Exif }, { token: i2.Platform }, { token: i3.FileLoader }], target: i0.ɵɵFactoryTarget.Injectable });
+ImageConverter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: ImageConverter, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: ImageConverter, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Exif }, { type: i2.Platform }, { type: i3.FileLoader }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-converter.service.js","sourceRoot":"","sources":["../../../../../../projects/bb-foundation/src/lib/core/services/image-converter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {FileLoader} from './file-loader.service';\nimport {Platform} from './platform.service';\nimport {Injectable} from '@angular/core';\nimport {Exif} from './exif.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ImageConverter {\n\n    // Data.\n    private readonly _types = ['image/png', 'image/jpeg'];\n\n    constructor(private _exif: Exif,\n                private _platform: Platform,\n                private _fileLoader: FileLoader) {\n    }\n\n    async toDataUri(contents: string | File | HTMLImageElement, options: { width: number, height: number } | null = null) {\n        // Check if the current platform is a browser.\n        if (!this._platform.isBrowser) {\n            return null;\n        }\n\n        // Get the image.\n        const image = await this.getImage(contents);\n\n        // Get the canvas width and height.\n        const canvasWidth = options?.width || image?.width;\n        const canvasHeight = options?.height || image?.height;\n\n        // Get the canvas and context.\n        const canvas = document.createElement('canvas');\n        const context = canvas.getContext('2d');\n\n        // Validate the context exists.\n        if (!context) {\n            return null;\n        }\n\n        // Set the width and height.\n        canvas.width = canvasWidth;\n        canvas.height = canvasHeight;\n\n        // When the canvas sizes are 0 we have failed.\n        if (canvas?.width === 0 && canvas?.height === 0) {\n            return null;\n        }\n\n        // Check if dimensions where supplied, else create the image.\n        if (!options) {\n            // Draw the image.\n            context.drawImage(image, 0, 0);\n\n            // Convert the canvas to a data url.\n            return canvas.toDataURL(this._types[0]);\n        }\n\n        // Get the dimensions and offsets.\n        const {width, height, xOffset, yOffset} = this.calculateOffsetAndDimensions(image, canvasWidth, canvasHeight);\n\n        // Draw the image.\n        context.drawImage(image, 0, 0, image.width, image.height, xOffset, yOffset, width, height);\n\n        // Convert the canvas to a data url.\n        return canvas.toDataURL(this._types[0]);\n    }\n\n    async fileToImage(file: File, types: string[] = this._types) {\n        // Check if the file matches an image.\n        if (!types.includes(file.type)) {\n            throw new Error('The selected file does not meet the required format.');\n        }\n\n        let stripped: File | null = null;\n        try {\n            stripped = await this._exif.strip(file, 90);\n        } catch {\n            // Do nothing.\n        }\n\n        // Ge the data uri.\n        const dataUri = await this._fileLoader.asDataUrl(stripped ?? file);\n\n        // Convert the data URI to a image element.\n        return await this.stringToImage(dataUri);\n    }\n\n    stringToImage(src: string) {\n        return new Promise<HTMLImageElement>((resolve, reject) => {\n            const image = new Image();\n            image.src = src;\n            image.onload = () => resolve(image);\n            image.onerror = error => reject(error);\n        });\n    }\n\n    private async getImage(contents: string | File | HTMLImageElement) {\n        // If the contents is already an HTML image element just return it.\n        if (contents instanceof HTMLImageElement) {\n            return contents;\n        }\n\n        // If the contents is a file convert it to an HTML image element.\n        if (contents instanceof File) {\n            return this.fileToImage(contents);\n        }\n\n        // If the contents is a string convert it to an HTML image element.\n        return this.stringToImage(contents);\n    }\n\n    private calculateOffsetAndDimensions = (image: HTMLImageElement, canvasWidth: number, canvasHeight: number) => {\n        const originalWidth = image.width;\n        const originalHeight = image.height;\n\n        const widthRatio = canvasWidth / originalWidth;\n        const heightRatio = canvasHeight / originalHeight;\n\n        let width: number;\n        let height: number;\n\n        if (originalWidth > originalHeight) {\n            height = originalHeight * heightRatio;\n            width = (originalWidth / originalHeight) * height;\n        } else {\n            width = originalWidth * widthRatio;\n            height = (originalHeight / originalWidth) * width;\n        }\n\n        let xOffset = 0;\n        let yOffset = 0;\n\n        if (canvasHeight === height) {\n            xOffset = -((width - canvasWidth) / 2);\n        } else if (canvasWidth === width) {\n            yOffset = -((height - canvasHeight) / 2);\n        }\n\n        return {xOffset, yOffset, width, height};\n    };\n\n}\n"]}

package/{esm2015/lib/core/services/languages.service.js → esm2020/lib/core/services/languages.service.mjs}

@@ -58,9 +58,9 @@ export class Languages {
             .sort((a, b) => b.quality - a.quality);
     }
 }
-Languages.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.11", ngImport: i0, type: Languages, deps: [{ token: ACCEPT_LANGUAGE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-Languages.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.11", ngImport: i0, type: Languages, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.11", ngImport: i0, type: Languages, decorators: [{
+Languages.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Languages, deps: [{ token: ACCEPT_LANGUAGE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Languages.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Languages, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Languages, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
@@ -71,4 +71,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.11", ngImpo
                     type: Inject,
                     args: [ACCEPT_LANGUAGE]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFuZ3VhZ2VzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9iYi1mb3VuZGF0aW9uL3NyYy9saWIvY29yZS9zZXJ2aWNlcy9sYW5ndWFnZXMuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsZUFBZSxFQUFDLE1BQU0saUNBQWlDLENBQUM7QUFDaEUsT0FBTyxFQUFDLE1BQU0sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDOztBQUszRCxNQUFNLE9BQU8sU0FBUztJQUtsQixZQUF5RCxlQUF3QjtRQUF4QixvQkFBZSxHQUFmLGVBQWUsQ0FBUztRQUhqRixRQUFRO1FBQ1MsVUFBSyxHQUEwRSxFQUFFLENBQUM7UUEyQzNGLGlCQUFZLEdBQUcsR0FBRyxFQUFFO1lBQ3hCLGlEQUFpRDtZQUNqRCxJQUFJLElBQUksQ0FBQyxlQUFlLEVBQUU7Z0JBQ3RCLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQzthQUMvQjtZQUVELCtDQUErQztZQUMvQyxJQUFJLE9BQU8sU0FBUyxLQUFLLFFBQVEsRUFBRTtnQkFDL0IsT0FBTyxJQUFJLENBQUM7YUFDZjtZQUVELElBQUksQ0FBQyxHQUFHLFNBQVMsQ0FBQztZQUNsQixJQUFJLENBQUMsR0FBRyxTQUFTLENBQUM7WUFDbEIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsR0FBRyxDQUFDLEdBQUcsR0FBRyxDQUFDLENBQUM7WUFFekIsTUFBTSxJQUFJLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsR0FBRyxDQUFDLENBQUM7Z0JBQzVDLENBQUMsQ0FBQyxVQUFVLEdBQUcsQ0FBQyxDQUFDO2dCQUNqQixDQUFDLENBQUMsT0FBTyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUU5QixPQUFPLE9BQU8sSUFBSSxLQUFLLFFBQVE7Z0JBQzNCLENBQUMsQ0FBQyxJQUFJO2dCQUNOLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3pCLENBQUMsQ0FBQztRQTlERSxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztJQUNuQyxDQUFDO0lBRUQsSUFBSSxHQUFHO1FBQ0gsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBQ3RCLENBQUM7SUFFTyxVQUFVO1FBQ2QscUJBQXFCO1FBQ3JCLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUVqQyx3Q0FBd0M7UUFDeEMsTUFBTSxPQUFPLEdBQUcsQ0FBQyxJQUFJLElBQUksRUFBRSxDQUFDO2FBQ3ZCLEtBQUssQ0FBQyxnRUFBZ0UsQ0FBQyxDQUFDO1FBRTdFLDBDQUEwQztRQUMxQyxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFO1lBQy9CLElBQUksQ0FBQyxJQUFJLEVBQUU7Z0JBQ1AsT0FBTyxJQUFJLENBQUM7YUFDZjtZQUVELE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDN0IsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUNoQyxNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQztZQUVwQyxPQUFPO2dCQUNILElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDO2dCQUNiLE1BQU0sRUFBRSxTQUFTLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSTtnQkFDbEMsTUFBTSxFQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO2dCQUNyQyxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxHQUFHO2FBQzdELENBQUM7UUFDTixDQUFDLENBQUMsQ0FBQztRQUVILGlDQUFpQztRQUNqQyxnQ0FBZ0M7UUFDaEMsT0FBTyxPQUFPO2FBQ1QsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQzthQUN0QixJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsT0FBTyxHQUFHLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUMvQyxDQUFDOztzR0E1Q1EsU0FBUyxrQkFLYyxlQUFlOzBHQUx0QyxTQUFTLGNBRk4sTUFBTTsyRkFFVCxTQUFTO2tCQUhyQixVQUFVO21CQUFDO29CQUNSLFVBQVUsRUFBRSxNQUFNO2lCQUNyQjs7MEJBTWdCLFFBQVE7OzBCQUFJLE1BQU07MkJBQUMsZUFBZSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QUNDRVBUX0xBTkdVQUdFfSBmcm9tICcuLi90b2tlbnMvYWNjZXB0LWxhbmd1YWdlLnRva2VuJztcbmltcG9ydCB7SW5qZWN0LCBJbmplY3RhYmxlLCBPcHRpb25hbH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgTGFuZ3VhZ2VzIHtcblxuICAgIC8vIERhdGEuXG4gICAgcHJpdmF0ZSByZWFkb25seSBfZGF0YTogeyBjb2RlOiBzdHJpbmcsIHNjcmlwdD86IHN0cmluZywgcmVnaW9uPzogc3RyaW5nLCBxdWFsaXR5OiBudW1iZXIgfVtdID0gW107XG5cbiAgICBjb25zdHJ1Y3RvcihAT3B0aW9uYWwoKSBASW5qZWN0KEFDQ0VQVF9MQU5HVUFHRSkgcHJpdmF0ZSBfYWNjZXB0TGFuZ3VhZ2U/OiBzdHJpbmcpIHtcbiAgICAgICAgdGhpcy5fZGF0YSA9IHRoaXMuaW5pdGlhbGl6ZSgpO1xuICAgIH1cblxuICAgIGdldCBhbGwoKSB7XG4gICAgICAgIHJldHVybiB0aGlzLl9kYXRhO1xuICAgIH1cblxuICAgIHByaXZhdGUgaW5pdGlhbGl6ZSgpIHtcbiAgICAgICAgLy8gR2V0IHRoZSBsYW5ndWFnZXMuXG4gICAgICAgIGNvbnN0IGRhdGEgPSB0aGlzLmdldExhbmd1YWdlcygpO1xuXG4gICAgICAgIC8vIFBhcnNlIGFsbCBsYW5ndWFnZXMgYnkgdXNpbmcgYSByZWdleC5cbiAgICAgICAgY29uc3Qgc3RyaW5ncyA9IChkYXRhIHx8ICcnKVxuICAgICAgICAgICAgLm1hdGNoKC8oKChbYS16QS1aXSsoLVthLXpBLVowLTldKyl7MCwyfSl8XFwqKSg7cT1bMC0xXShcXC5bMC05XSspPyk/KSovZyk7XG5cbiAgICAgICAgLy8gR2V0IHRoZSBjb250ZW50IGJ5IHBhcnNpbmcgdGhlIHN0cmluZ3MuXG4gICAgICAgIGNvbnN0IGNvbnRlbnQgPSBzdHJpbmdzLm1hcChpdGVtID0+IHtcbiAgICAgICAgICAgIGlmICghaXRlbSkge1xuICAgICAgICAgICAgICAgIHJldHVybiBudWxsO1xuICAgICAgICAgICAgfVxuXG4gICAgICAgICAgICBjb25zdCBiaXRzID0gaXRlbS5zcGxpdCgnOycpO1xuICAgICAgICAgICAgY29uc3QgaWV0ZiA9IGJpdHNbMF0uc3BsaXQoJy0nKTtcbiAgICAgICAgICAgIGNvbnN0IGhhc1NjcmlwdCA9IGlldGYubGVuZ3RoID09PSAzO1xuXG4gICAgICAgICAgICByZXR1cm4ge1xuICAgICAgICAgICAgICAgIGNvZGU6IGlldGZbMF0sXG4gICAgICAgICAgICAgICAgc2NyaXB0OiBoYXNTY3JpcHQgPyBpZXRmWzFdIDogbnVsbCxcbiAgICAgICAgICAgICAgICByZWdpb246IGhhc1NjcmlwdCA/IGlldGZbMl0gOiBpZXRmWzFdLFxuICAgICAgICAgICAgICAgIHF1YWxpdHk6IGJpdHNbMV0gPyBwYXJzZUZsb2F0KGJpdHNbMV0uc3BsaXQoJz0nKVsxXSkgOiAxLjBcbiAgICAgICAgICAgIH07XG4gICAgICAgIH0pO1xuXG4gICAgICAgIC8vIEZpbHRlciBvdXQgYWxsIHRoZSBlbXB0eSBpdGVtc1xuICAgICAgICAvLyBhbmQgc29ydCB0aGVtIGJ5IHRoZSBxdWFsaXR5LlxuICAgICAgICByZXR1cm4gY29udGVudFxuICAgICAgICAgICAgLmZpbHRlcihpdGVtID0+ICEhaXRlbSlcbiAgICAgICAgICAgIC5zb3J0KChhLCBiKSA9PiBiLnF1YWxpdHkgLSBhLnF1YWxpdHkpO1xuICAgIH1cblxuICAgIHByaXZhdGUgZ2V0TGFuZ3VhZ2VzID0gKCkgPT4ge1xuICAgICAgICAvLyBJZiBkZWZpbmVkIHdlIG11c3QgYmUgaW4gYSBzZXJ2ZXIgZW52aXJvbm1lbnQuXG4gICAgICAgIGlmICh0aGlzLl9hY2NlcHRMYW5ndWFnZSkge1xuICAgICAgICAgICAgcmV0dXJuIHRoaXMuX2FjY2VwdExhbmd1YWdlO1xuICAgICAgICB9XG5cbiAgICAgICAgLy8gVHJ5IHRvIGdldCB0aGUgbGFuZ3VhZ2VzIGZyb20gdGhlIG5hdmlnYXRvci5cbiAgICAgICAgaWYgKHR5cGVvZiBuYXZpZ2F0b3IgIT09ICdvYmplY3QnKSB7XG4gICAgICAgICAgICByZXR1cm4gbnVsbDtcbiAgICAgICAgfVxuXG4gICAgICAgIGxldCB0ID0gJ2FuZ3VhZ2UnO1xuICAgICAgICBsZXQgbiA9IG5hdmlnYXRvcjtcbiAgICAgICAgbGV0IGYgPSBuWydsJyArIHQgKyAncyddO1xuXG4gICAgICAgIGNvbnN0IGRhdGEgPSBmICYmIGYubGVuZ3RoID8gZiA6ICh0ID0gblsnbCcgKyB0XSB8fFxuICAgICAgICAgICAgblsnYnJvd3NlckwnICsgdF0gfHxcbiAgICAgICAgICAgIG5bJ3VzZXJMJyArIHRdKSA/IFt0XSA6IHQ7XG5cbiAgICAgICAgcmV0dXJuIHR5cGVvZiBkYXRhID09PSAnc3RyaW5nJ1xuICAgICAgICAgICAgPyBkYXRhXG4gICAgICAgICAgICA6IGRhdGEuam9pbignOycpO1xuICAgIH07XG5cbn1cbiJdfQ==

package/{esm2015/lib/core/services/network.service.js → esm2020/lib/core/services/network.service.mjs}

@@ -26,8 +26,7 @@ export class Network {
         const online$ = fromEvent(this._window, 'online').pipe(mapTo(true));
         const offline$ = fromEvent(this._window, 'offline').pipe(mapTo(false));
         const now$ = new Observable(subscriber => {
-            var _a;
-            subscriber.next((_a = this._navigator) === null || _a === void 0 ? void 0 : _a.onLine);
+            subscriber.next(this._navigator?.onLine);
             subscriber.complete();
         });
         // Merge all event so we get notified when
@@ -35,9 +34,9 @@ export class Network {
         this._online$ = merge(now$, online$, offline$).pipe(map(value => value), distinctUntilChanged(), shareReplay(1));
     }
 }
-Network.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.11", ngImport: i0, type: Network, deps: [{ token: i1.Platform }, { token: WINDOW, optional: true }, { token: NAVIGATOR, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-Network.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.11", ngImport: i0, type: Network, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.11", ngImport: i0, type: Network, decorators: [{
+Network.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Network, deps: [{ token: i1.Platform }, { token: WINDOW, optional: true }, { token: NAVIGATOR, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Network.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Network, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Network, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
@@ -53,4 +52,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.11", ngImpo
                     type: Inject,
                     args: [NAVIGATOR]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/services/patch.service.mjs

@@ -0,0 +1,63 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { debounceTime, startWith } from 'rxjs/operators';
+import { WINDOW } from '../tokens/window.token';
+import { fromEvent, Subscription } from 'rxjs';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "./platform.service";
+export class Patch {
+    constructor(_platform, _window, _document) {
+        this._platform = _platform;
+        this._window = _window;
+        this._document = _document;
+        this._hasPatchedMobileVerticalHeight = false;
+        // Subscriptions.
+        this._subscription = new Subscription();
+    }
+    mobileVerticalHeight() {
+        // Check if the user has already patched
+        // the mobile vertical height.
+        if (this._hasPatchedMobileVerticalHeight) {
+            return;
+        }
+        this.periodicallySetDocumentVerticalProperty();
+        this._hasPatchedMobileVerticalHeight = true;
+    }
+    ngOnDestroy() {
+        this._subscription?.unsubscribe();
+    }
+    periodicallySetDocumentVerticalProperty() {
+        // Validate we are using a browser.
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        // Listen to a debounced window resize event.
+        const resize$ = fromEvent(this._window, 'resize').pipe(debounceTime(25), startWith(0));
+        // Subscribe to the resize observable.
+        const subscription = resize$.subscribe(() => {
+            const verticalHeight = this._window?.innerHeight * 0.01;
+            this._document?.documentElement?.style?.setProperty('--vh', `${verticalHeight}px`);
+        });
+        // Save the subscription so we can destroy it later.
+        this._subscription.add(subscription);
+    }
+}
+Patch.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Patch, deps: [{ token: i1.Platform }, { token: WINDOW, optional: true }, { token: DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Patch.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Patch, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Patch, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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