@loaders.gl/images 3.1.0-alpha.5 → 3.1.0-beta.4

package/dist/lib/category-api/binary-image-api.js

@@ -0,0 +1,141 @@
+"use strict";
+// Attributions
+// * Based on binary-gltf-utils under MIT license: Copyright (c) 2016-17 Karl Cheng
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBmpMetadata = exports.getBinaryImageMetadata = void 0;
+const BIG_ENDIAN = false;
+const LITTLE_ENDIAN = true;
+/**
+ * Extracts `{mimeType, width and height}` from a memory buffer containing a known image format
+ * Currently supports `image/png`, `image/jpeg`, `image/bmp` and `image/gif`.
+ * @param binaryData image file memory to parse
+ * @returns metadata or null if memory is not a valid image file format layout.
+ */
+function getBinaryImageMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    return (getPngMetadata(dataView) ||
+        getJpegMetadata(dataView) ||
+        getGifMetadata(dataView) ||
+        getBmpMetadata(dataView));
+}
+exports.getBinaryImageMetadata = getBinaryImageMetadata;
+// PNG
+function getPngMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    // Check file contains the first 4 bytes of the PNG signature.
+    const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 0x89504e47;
+    if (!isPng) {
+        return null;
+    }
+    // Extract size from a binary PNG file
+    return {
+        mimeType: 'image/png',
+        width: dataView.getUint32(16, BIG_ENDIAN),
+        height: dataView.getUint32(20, BIG_ENDIAN)
+    };
+}
+// GIF
+// Extract size from a binary GIF file
+// TODO: GIF is not this simple
+function getGifMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    // Check first 4 bytes of the GIF signature ("GIF8").
+    const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 0x47494638;
+    if (!isGif) {
+        return null;
+    }
+    // GIF is little endian.
+    return {
+        mimeType: 'image/gif',
+        width: dataView.getUint16(6, LITTLE_ENDIAN),
+        height: dataView.getUint16(8, LITTLE_ENDIAN)
+    };
+}
+// BMP
+// TODO: BMP is not this simple
+function getBmpMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    // Check magic number is valid (first 2 characters should be "BM").
+    // The mandatory bitmap file header is 14 bytes long.
+    const isBmp = dataView.byteLength >= 14 &&
+        dataView.getUint16(0, BIG_ENDIAN) === 0x424d &&
+        dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
+    if (!isBmp) {
+        return null;
+    }
+    // BMP is little endian.
+    return {
+        mimeType: 'image/bmp',
+        width: dataView.getUint32(18, LITTLE_ENDIAN),
+        height: dataView.getUint32(22, LITTLE_ENDIAN)
+    };
+}
+exports.getBmpMetadata = getBmpMetadata;
+// JPEG
+// Extract width and height from a binary JPEG file
+function getJpegMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    // Check file contains the JPEG "start of image" (SOI) marker
+    // followed by another marker.
+    const isJpeg = dataView.byteLength >= 3 &&
+        dataView.getUint16(0, BIG_ENDIAN) === 0xffd8 &&
+        dataView.getUint8(2) === 0xff;
+    if (!isJpeg) {
+        return null;
+    }
+    const { tableMarkers, sofMarkers } = getJpegMarkers();
+    // Exclude the two byte SOI marker.
+    let i = 2;
+    while (i + 9 < dataView.byteLength) {
+        const marker = dataView.getUint16(i, BIG_ENDIAN);
+        // The frame that contains the width and height of the JPEG image.
+        if (sofMarkers.has(marker)) {
+            return {
+                mimeType: 'image/jpeg',
+                height: dataView.getUint16(i + 5, BIG_ENDIAN),
+                width: dataView.getUint16(i + 7, BIG_ENDIAN) // Number of pixels per line
+            };
+        }
+        // Miscellaneous tables/data preceding the frame header.
+        if (!tableMarkers.has(marker)) {
+            return null;
+        }
+        // Length includes size of length parameter but not the two byte header.
+        i += 2;
+        i += dataView.getUint16(i, BIG_ENDIAN);
+    }
+    return null;
+}
+function getJpegMarkers() {
+    // Tables/misc header markers.
+    // DQT, DHT, DAC, DRI, COM, APP_n
+    const tableMarkers = new Set([0xffdb, 0xffc4, 0xffcc, 0xffdd, 0xfffe]);
+    for (let i = 0xffe0; i < 0xfff0; ++i) {
+        tableMarkers.add(i);
+    }
+    // SOF markers and DHP marker.
+    // These markers are after tables/misc data.
+    const sofMarkers = new Set([
+        0xffc0, 0xffc1, 0xffc2, 0xffc3, 0xffc5, 0xffc6, 0xffc7, 0xffc9, 0xffca, 0xffcb, 0xffcd, 0xffce,
+        0xffcf, 0xffde
+    ]);
+    return { tableMarkers, sofMarkers };
+}
+// TODO - move into image module?
+function toDataView(data) {
+    if (data instanceof DataView) {
+        return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+        return new DataView(data.buffer);
+    }
+    // TODO: make these functions work for Node.js buffers?
+    // if (bufferToArrayBuffer) {
+    //   data = bufferToArrayBuffer(data);
+    // }
+    // Careful - Node Buffers will look like ArrayBuffers (keep after isBuffer)
+    if (data instanceof ArrayBuffer) {
+        return new DataView(data);
+    }
+    throw new Error('toDataView');
+}

package/dist/lib/category-api/image-format.d.ts

@@ -2,3 +2,4 @@
  * Check if image MIME type is supported. Result is cached.
  */
 export declare function _isImageFormatSupported(mimeType: string): boolean;
+//# sourceMappingURL=image-format.d.ts.map

package/dist/lib/category-api/image-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-format.d.ts","sourceRoot":"","sources":["../../../src/lib/category-api/image-format.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAKjE"}

package/dist/lib/category-api/image-format.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._isImageFormatSupported = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+// The following formats are supported by loaders.gl polyfills
+const NODE_FORMAT_SUPPORT = ['image/png', 'image/jpeg', 'image/gif'];
+/** Cache values for speed */
+const mimeTypeSupported = {};
+/**
+ * Check if image MIME type is supported. Result is cached.
+ */
+function _isImageFormatSupported(mimeType) {
+    if (mimeTypeSupported[mimeType] === undefined) {
+        mimeTypeSupported[mimeType] = checkFormatSupport(mimeType);
+    }
+    return mimeTypeSupported[mimeType];
+}
+exports._isImageFormatSupported = _isImageFormatSupported;
+/**
+ * Check if image MIME type is supported.
+ */
+function checkFormatSupport(mimeType) {
+    switch (mimeType) {
+        case 'image/webp':
+            return checkWebPSupport();
+        case 'image/svg':
+            return loader_utils_1.isBrowser;
+        default:
+            if (!loader_utils_1.isBrowser) {
+                // @ts-ignore
+                const { _parseImageNode } = globalThis;
+                return Boolean(_parseImageNode) && NODE_FORMAT_SUPPORT.includes(mimeType);
+            }
+            return true;
+    }
+}
+/** Check WebPSupport synchronously */
+function checkWebPSupport() {
+    if (!loader_utils_1.isBrowser) {
+        return false;
+    }
+    try {
+        const element = document.createElement('canvas');
+        return element.toDataURL('image/webp').indexOf('data:image/webp') === 0;
+    }
+    catch {
+        // Probably Safari...
+        return false;
+    }
+}
+// Note: better test but asynchronous
+// Lossy test image. Support for lossy images doesn't guarantee support for all WebP images.
+// https://stackoverflow.com/questions/5573096/detecting-webp-support
+// const WEBP_TEST_IMAGE = 'data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA';
+// Check WebPSupport asynchronously
+// async function isWebPSupported() {
+//   return new Promise( resolve => {
+//     const image = new Image();
+//     image.src = WEBP_TEST_IMAGE;
+//     image.onload = image.onerror = function () {
+//     resolve( image.height === 1 );
+//   }
+// }

package/dist/lib/category-api/image-type.d.ts

@@ -9,3 +9,4 @@ export declare function isImageTypeSupported(type: string): boolean;
  * @returns image type string
  */
 export declare function getDefaultImageType(): ImageTypeEnum;
+//# sourceMappingURL=image-type.d.ts.map

package/dist/lib/category-api/image-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-type.d.ts","sourceRoot":"","sources":["../../../src/lib/category-api/image-type.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAU/C;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAgB1D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CAanD"}

package/dist/lib/category-api/image-type.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultImageType = exports.isImageTypeSupported = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+// @ts-ignore TS2339: Property does not exist on type
+const { _parseImageNode } = globalThis;
+const IMAGE_SUPPORTED = typeof Image !== 'undefined'; // NOTE: "false" positives if jsdom is installed
+const IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== 'undefined';
+const NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
+const DATA_SUPPORTED = loader_utils_1.isBrowser ? true : NODE_IMAGE_SUPPORTED;
+/**
+ * Checks if a loaders.gl image type is supported
+ * @param type image type string
+ */
+function isImageTypeSupported(type) {
+    switch (type) {
+        case 'auto':
+            // Should only ever be false in Node.js, if polyfills have not been installed...
+            return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
+        case 'imagebitmap':
+            return IMAGE_BITMAP_SUPPORTED;
+        case 'image':
+            return IMAGE_SUPPORTED;
+        case 'data':
+            return DATA_SUPPORTED;
+        default:
+            throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
+    }
+}
+exports.isImageTypeSupported = isImageTypeSupported;
+/**
+ * Returns the "most performant" supported image type on this platform
+ * @returns image type string
+ */
+function getDefaultImageType() {
+    if (IMAGE_BITMAP_SUPPORTED) {
+        return 'imagebitmap';
+    }
+    if (IMAGE_SUPPORTED) {
+        return 'image';
+    }
+    if (DATA_SUPPORTED) {
+        return 'data';
+    }
+    // This should only happen in Node.js
+    throw new Error('Install \'@loaders.gl/polyfills\' to parse images under Node.js');
+}
+exports.getDefaultImageType = getDefaultImageType;

package/dist/lib/category-api/parsed-image-api.d.ts

@@ -7,3 +7,4 @@ export declare function getImageSize(image: ImageType): {
     height: number;
 };
 export declare function getImageData(image: ImageType): ImageDataType | ImageData;
+//# sourceMappingURL=parsed-image-api.d.ts.map

package/dist/lib/category-api/parsed-image-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsed-image-api.d.ts","sourceRoot":"","sources":["../../../src/lib/category-api/parsed-image-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,aAAa,CAAC;AAEzE,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAEjD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAQlD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,CAM5D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAE9E;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,GAAG,SAAS,CA0BxE"}

package/dist/lib/category-api/parsed-image-api.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImageData = exports.getImageSize = exports.getImageType = exports.deleteImage = exports.isImage = void 0;
+function isImage(image) {
+    return Boolean(getImageTypeOrNull(image));
+}
+exports.isImage = isImage;
+function deleteImage(image) {
+    switch (getImageType(image)) {
+        case 'imagebitmap':
+            image.close();
+            break;
+        default:
+        // Nothing to do for images and image data objects
+    }
+}
+exports.deleteImage = deleteImage;
+function getImageType(image) {
+    const format = getImageTypeOrNull(image);
+    if (!format) {
+        throw new Error('Not an image');
+    }
+    return format;
+}
+exports.getImageType = getImageType;
+function getImageSize(image) {
+    return getImageData(image);
+}
+exports.getImageSize = getImageSize;
+function getImageData(image) {
+    switch (getImageType(image)) {
+        case 'data':
+            return image;
+        case 'image':
+        case 'imagebitmap':
+            // Extract the image data from the image via a canvas
+            const canvas = document.createElement('canvas');
+            // TODO - reuse the canvas?
+            const context = canvas.getContext('2d');
+            if (!context) {
+                throw new Error('getImageData');
+            }
+            // @ts-ignore
+            canvas.width = image.width;
+            // @ts-ignore
+            canvas.height = image.height;
+            // @ts-ignore
+            context.drawImage(image, 0, 0);
+            // @ts-ignore
+            return context.getImageData(0, 0, image.width, image.height);
+        default:
+            throw new Error('getImageData');
+    }
+}
+exports.getImageData = getImageData;
+// PRIVATE
+// eslint-disable-next-line complexity
+function getImageTypeOrNull(image) {
+    if (typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
+        return 'imagebitmap';
+    }
+    if (typeof Image !== 'undefined' && image instanceof Image) {
+        return 'image';
+    }
+    if (image && typeof image === 'object' && image.data && image.width && image.height) {
+        return 'data';
+    }
+    return null;
+}

package/dist/lib/encoders/encode-image.d.ts

@@ -9,3 +9,4 @@
 export declare function encodeImage(image: any, options?: {
     [key: string]: any;
 }): Promise<ArrayBuffer>;
+//# sourceMappingURL=encode-image.d.ts.map

package/dist/lib/encoders/encode-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-image.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-image.ts"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,GAAG,EACV,OAAO,CAAC,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,GAC7B,OAAO,CAAC,WAAW,CAAC,CAOtB"}

package/dist/lib/encoders/encode-image.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeImage = void 0;
+// Image loading/saving for browser and Node.js
+const parsed_image_api_1 = require("../category-api/parsed-image-api");
+// @ts-ignore TS2339: Property does not exist on type
+const { _encodeImageNode } = globalThis;
+/**
+ * Returns data bytes representing a compressed image in PNG or JPG format,
+ * This data can be saved using file system (f) methods or used in a request.
+ * @param image - ImageBitmap Image or Canvas
+ * @param options
+ * param opt.type='png' - png, jpg or image/png, image/jpg are valid
+ * param mimeType= - Whether to include a data URI header
+ */
+async function encodeImage(image, options) {
+    options = options || {};
+    options.image = options.image || {};
+    return _encodeImageNode
+        ? _encodeImageNode(image, { type: options.image.mimeType })
+        : encodeImageInBrowser(image, options);
+}
+exports.encodeImage = encodeImage;
+// In case we get exceptions from canvas.toBlob(resolve, type, quality)
+let qualityParamSupported = true;
+/**
+ *
+ * @param image
+ * @param options
+ * @note Based on canvas.toBlob
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob
+ */
+async function encodeImageInBrowser(image, options) {
+    const { mimeType, jpegQuality } = options.image;
+    const { width, height } = (0, parsed_image_api_1.getImageSize)(image);
+    // create a canvas and resize it to the size of our image
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    drawImageToCanvas(image, canvas);
+    // The actual encoding is done asynchronously with `canvas.toBlob()`
+    const blob = await new Promise((resolve) => {
+        // get it back as a Blob
+        if (jpegQuality && qualityParamSupported) {
+            try {
+                canvas.toBlob(resolve, mimeType, jpegQuality);
+                return;
+            }
+            catch (error) {
+                qualityParamSupported = false;
+            }
+        }
+        canvas.toBlob(resolve, mimeType);
+    });
+    if (!blob) {
+        throw new Error('image encoding failed');
+    }
+    return await blob.arrayBuffer();
+}
+function drawImageToCanvas(image, canvas, x = 0, y = 0) {
+    // Try optimized path for ImageBitmaps via bitmaprenderer context
+    if (x === 0 && y === 0 && typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
+        const context = canvas.getContext('bitmaprenderer');
+        if (context) {
+            // transfer the ImageBitmap to it
+            context.transferFromImageBitmap(image);
+            return canvas;
+        }
+    }
+    // Available on most platforms, except IE11 and Andriod WebViews...
+    const context = canvas.getContext('2d');
+    if (image.data) {
+        // ImageData constructor expects clamped array even though getImageData does not return a clamped array...
+        const clampedArray = new Uint8ClampedArray(image.data);
+        const imageData = new ImageData(clampedArray, image.width, image.height);
+        context.putImageData(imageData, 0, 0);
+        return canvas;
+    }
+    // Fall back to generic image/image bitmap rendering path
+    context.drawImage(image, 0, 0);
+    return canvas;
+}

package/dist/lib/parsers/parse-image.d.ts

@@ -2,3 +2,4 @@ import type { LoaderContext } from '@loaders.gl/loader-utils';
 import type { ImageType } from '../../types';
 import type { ImageLoaderOptions } from '../../image-loader';
 export default function parseImage(arrayBuffer: ArrayBuffer, options?: ImageLoaderOptions, context?: LoaderContext): Promise<ImageType>;
+//# sourceMappingURL=parse-image.d.ts.map

package/dist/lib/parsers/parse-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-image.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE5D,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAS3D,wBAA8B,UAAU,CACtC,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,kBAAkB,EAC5B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,SAAS,CAAC,CAkCpB"}

package/dist/lib/parsers/parse-image.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const image_type_1 = require("../category-api/image-type");
+const parsed_image_api_1 = require("../category-api/parsed-image-api");
+const parse_to_image_1 = __importDefault(require("./parse-to-image"));
+const parse_to_image_bitmap_1 = __importDefault(require("./parse-to-image-bitmap"));
+const parse_to_node_image_1 = __importDefault(require("./parse-to-node-image"));
+// Parse to platform defined image type (data on node, ImageBitmap or HTMLImage on browser)
+// eslint-disable-next-line complexity
+async function parseImage(arrayBuffer, options, context) {
+    options = options || {};
+    const imageOptions = options.image || {};
+    // The user can request a specific output format via `options.image.type`
+    const imageType = imageOptions.type || 'auto';
+    const { url } = context || {};
+    // Note: For options.image.type === `data`, we may still need to load as `image` or `imagebitmap`
+    const loadType = getLoadableImageType(imageType);
+    let image;
+    switch (loadType) {
+        case 'imagebitmap':
+            image = await (0, parse_to_image_bitmap_1.default)(arrayBuffer, options, url);
+            break;
+        case 'image':
+            image = await (0, parse_to_image_1.default)(arrayBuffer, options, url);
+            break;
+        case 'data':
+            // Node.js loads imagedata directly
+            image = await (0, parse_to_node_image_1.default)(arrayBuffer, options);
+            break;
+        default:
+            (0, loader_utils_1.assert)(false);
+    }
+    // Browser: if options.image.type === 'data', we can now extract data from the loaded image
+    if (imageType === 'data') {
+        image = (0, parsed_image_api_1.getImageData)(image);
+    }
+    return image;
+}
+exports.default = parseImage;
+// Get a loadable image type from image type
+function getLoadableImageType(type) {
+    switch (type) {
+        case 'auto':
+        case 'data':
+            // Browser: For image data we need still need to load using an image format
+            // Node: the default image type is `data`.
+            return (0, image_type_1.getDefaultImageType)();
+        default:
+            // Throw an error if not supported
+            (0, image_type_1.isImageTypeSupported)(type);
+            return type;
+    }
+}

package/dist/lib/parsers/parse-to-image-bitmap.d.ts

@@ -7,3 +7,4 @@ import type { ImageLoaderOptions } from '../../image-loader';
  * TODO - createImageBitmap supports source rect (5 param overload), pass through?
  */
 export default function parseToImageBitmap(arrayBuffer: ArrayBuffer, options: ImageLoaderOptions, url?: string): Promise<ImageBitmap>;
+//# sourceMappingURL=parse-to-image-bitmap.d.ts.map

package/dist/lib/parsers/parse-to-image-bitmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-to-image-bitmap.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-to-image-bitmap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAQ3D;;;;;;GAMG;AACH,wBAA8B,kBAAkB,CAC9C,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,kBAAkB,EAC3B,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,WAAW,CAAC,CAgBtB"}

package/dist/lib/parsers/parse-to-image-bitmap.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const svg_utils_1 = require("./svg-utils");
+const parse_to_image_1 = __importDefault(require("./parse-to-image"));
+const EMPTY_OBJECT = {};
+let imagebitmapOptionsSupported = true;
+/**
+ * Asynchronously parses an array buffer into an ImageBitmap - this contains the decoded data
+ * ImageBitmaps are supported on worker threads, but not supported on Edge, IE11 and Safari
+ * https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap#Browser_compatibility
+ *
+ * TODO - createImageBitmap supports source rect (5 param overload), pass through?
+ */
+async function parseToImageBitmap(arrayBuffer, options, url) {
+    let blob;
+    // Cannot parse SVG directly to ImageBitmap, parse to Image first
+    if ((0, svg_utils_1.isSVG)(url)) {
+        // Note: this only works on main thread
+        const image = await (0, parse_to_image_1.default)(arrayBuffer, options, url);
+        blob = image;
+    }
+    else {
+        // Create blob from the array buffer
+        blob = (0, svg_utils_1.getBlob)(arrayBuffer, url);
+    }
+    const imagebitmapOptions = options && options.imagebitmap;
+    return await safeCreateImageBitmap(blob, imagebitmapOptions);
+}
+exports.default = parseToImageBitmap;
+/**
+ * Safely creates an imageBitmap with options
+ * *
+ * Firefox crashes if imagebitmapOptions is supplied
+ * Avoid supplying if not provided or supported, remember if not supported
+ */
+async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
+    if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+        imagebitmapOptions = null;
+    }
+    if (imagebitmapOptions) {
+        try {
+            // @ts-ignore Options
+            return await createImageBitmap(blob, imagebitmapOptions);
+        }
+        catch (error) {
+            console.warn(error); // eslint-disable-line
+            imagebitmapOptionsSupported = false;
+        }
+    }
+    return await createImageBitmap(blob);
+}
+function isEmptyObject(object) {
+    // @ts-ignore
+    for (const key in object || EMPTY_OBJECT) {
+        return false;
+    }
+    return true;
+}

package/dist/lib/parsers/parse-to-image.d.ts

@@ -1,3 +1,4 @@
 import type { ImageLoaderOptions } from '../../image-loader';
 export default function parseToImage(arrayBuffer: ArrayBuffer, options: ImageLoaderOptions, url?: string): Promise<HTMLImageElement>;
 export declare function loadToImage(url: any, options: any): Promise<HTMLImageElement>;
+//# sourceMappingURL=parse-to-image.d.ts.map

package/dist/lib/parsers/parse-to-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-to-image.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-to-image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAI3D,wBAA8B,YAAY,CACxC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,kBAAkB,EAC3B,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,CAAC,CAe3B;AAED,wBAAsB,WAAW,CAAC,GAAG,KAAA,EAAE,OAAO,KAAA,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAyBzE"}

package/dist/lib/parsers/parse-to-image.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadToImage = void 0;
+const svg_utils_1 = require("./svg-utils");
+// Parses html image from array buffer
+async function parseToImage(arrayBuffer, options, url) {
+    // Note: image parsing requires conversion to Blob (for createObjectURL).
+    // Potentially inefficient for not using `response.blob()` (and for File / Blob inputs)...
+    // But presumably not worth adding 'blob' flag to loader objects?
+    const blobOrDataUrl = (0, svg_utils_1.getBlobOrSVGDataUrl)(arrayBuffer, url);
+    const URL = self.URL || self.webkitURL;
+    const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);
+    try {
+        return await loadToImage(objectUrl || blobOrDataUrl, options);
+    }
+    finally {
+        if (objectUrl) {
+            URL.revokeObjectURL(objectUrl);
+        }
+    }
+}
+exports.default = parseToImage;
+async function loadToImage(url, options) {
+    const image = new Image();
+    image.src = url;
+    // The `image.onload()` callback does not guarantee that the image has been decoded
+    // so a main thread "freeze" can be incurred when using the image for the first time.
+    // `Image.decode()` returns a promise that completes when image is decoded.
+    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decode
+    // Note: When calling `img.decode()`, we do not need to wait for `img.onload()`
+    // Note: `HTMLImageElement.decode()` is not available in Edge and IE11
+    if (options.image && options.image.decode && image.decode) {
+        await image.decode();
+        return image;
+    }
+    // Create a promise that tracks onload/onerror callbacks
+    return await new Promise((resolve, reject) => {
+        try {
+            image.onload = () => resolve(image);
+            image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+exports.loadToImage = loadToImage;

package/dist/lib/parsers/parse-to-node-image.d.ts

@@ -1,3 +1,4 @@
 import type { ImageLoaderOptions } from '../../image-loader';
 import type { ImageDataType } from '../../types';
 export default function parseToNodeImage(arrayBuffer: ArrayBuffer, options: ImageLoaderOptions): Promise<ImageDataType>;
+//# sourceMappingURL=parse-to-node-image.d.ts.map

package/dist/lib/parsers/parse-to-node-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-to-node-image.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-to-node-image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAkB/C,wBAA8B,gBAAgB,CAC5C,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,aAAa,CAAC,CASxB"}