@loaders.gl/images 4.0.0-alpha.22 → 4.0.0-alpha.24

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

@@ -1,161 +0,0 @@
-"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;
-// TODO: make these functions work for Node.js buffers?
-// Quarantine references to Buffer to prevent bundler from adding big polyfills
-// import {bufferToArrayBuffer} from '../node/buffer-to-array-buffer';
-// TODO - this should be handled in @loaders.gl/polyfills
-const parse_isobmff_binary_1 = require("./parse-isobmff-binary");
-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: DataView | ArrayBuffer 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) ||
-        getISOBMFFMetadata(dataView));
-}
-exports.getBinaryImageMetadata = getBinaryImageMetadata;
-// ISOBMFF
-function getISOBMFFMetadata(binaryData) {
-    const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
-    const mediaType = (0, parse_isobmff_binary_1.getISOBMFFMediaType)(buffer);
-    if (!mediaType) {
-        return null;
-    }
-    return {
-        mimeType: mediaType.mimeType,
-        // TODO - decode width and height
-        width: 0,
-        height: 0
-    };
-}
-// 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.js

@@ -1,110 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImageFormatSupported = exports.getSupportedImageFormats = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const MIME_TYPES = [
-    'image/png',
-    'image/jpeg',
-    'image/gif',
-    'image/webp',
-    'image/avif',
-    'image/tiff',
-    // TODO - what is the correct type for SVG
-    'image/svg',
-    'image/svg+xml',
-    'image/bmp',
-    'image/vnd.microsoft.icon'
-];
-/** Only one round of tests is performed */
-const mimeTypeSupportedPromise = null;
-/** Run-time browser detection of file formats requires async tests for most precise results */
-async function getSupportedImageFormats() {
-    if (mimeTypeSupportedPromise) {
-        return await mimeTypeSupportedPromise;
-    }
-    const supportedMimeTypes = new Set();
-    for (const mimeType of MIME_TYPES) {
-        const supported = loader_utils_1.isBrowser
-            ? await checkBrowserImageFormatSupportAsync(mimeType)
-            : checkNodeImageFormatSupport(mimeType);
-        if (supported) {
-            supportedMimeTypes.add(mimeType);
-        }
-    }
-    return supportedMimeTypes;
-}
-exports.getSupportedImageFormats = getSupportedImageFormats;
-/** Cache sync values for speed */
-const mimeTypeSupportedSync = {};
-/**
- * Check if image MIME type is supported. Result is cached to avoid repeated tests.
- */
-function isImageFormatSupported(mimeType) {
-    if (mimeTypeSupportedSync[mimeType] === undefined) {
-        const supported = loader_utils_1.isBrowser
-            ? checkBrowserImageFormatSupport(mimeType)
-            : checkNodeImageFormatSupport(mimeType);
-        mimeTypeSupportedSync[mimeType] = supported;
-    }
-    return mimeTypeSupportedSync[mimeType];
-}
-exports.isImageFormatSupported = isImageFormatSupported;
-/**
- * Checks that polyfills are installed and that mimeType is supported by polyfills
- * @todo Ideally polyfills should declare what formats they support, instead of storing that data here.
- */
-function checkNodeImageFormatSupport(mimeType) {
-    /** @deprecated Remove these in 4.0 and rely on polyfills to inject them */
-    const NODE_FORMAT_SUPPORT = ['image/png', 'image/jpeg', 'image/gif'];
-    // @ts-ignore
-    const { _parseImageNode, _imageFormatsNode = NODE_FORMAT_SUPPORT } = globalThis;
-    return Boolean(_parseImageNode) && _imageFormatsNode.includes(mimeType);
-}
-/** Checks image format support synchronously.
- * @note Unreliable, fails on AVIF
- */
-function checkBrowserImageFormatSupport(mimeType) {
-    switch (mimeType) {
-        case 'image/avif': // Will fail
-        case 'image/webp':
-            return testBrowserImageFormatSupport(mimeType);
-        default:
-            return true;
-    }
-}
-const TEST_IMAGE = {
-    'image/avif': 'data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAACVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A=',
-    // Lossy test image. Support for lossy images doesn't guarantee support for all WebP images.
-    'image/webp': 'data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA'
-};
-/** Checks WebP and AVIF support asynchronously */
-async function checkBrowserImageFormatSupportAsync(mimeType) {
-    const dataURL = TEST_IMAGE[mimeType];
-    return dataURL ? await testBrowserImageFormatSupportAsync(dataURL) : true;
-}
-/**
- * Checks browser synchronously
- * Checks if toDataURL supports the mimeType.
- * @note Imperfect testOn Chrome this is true for WebP but not for AVIF
- */
-function testBrowserImageFormatSupport(mimeType) {
-    try {
-        const element = document.createElement('canvas');
-        const dataURL = element.toDataURL(mimeType);
-        return dataURL.indexOf(`data:${mimeType}`) === 0;
-    }
-    catch {
-        // Probably Safari...
-        return false;
-    }
-}
-// Check WebPSupport asynchronously
-async function testBrowserImageFormatSupportAsync(testImageDataURL) {
-    return new Promise((resolve) => {
-        const image = new Image();
-        image.src = testImageDataURL;
-        image.onload = () => resolve(image.height > 0);
-        image.onerror = () => resolve(false);
-    });
-}

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

@@ -1,48 +0,0 @@
-"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/parse-isobmff-binary.js

@@ -1,94 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-// code adapted from https://github.com/sindresorhus/file-type under MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeMajorBrand = exports.getISOBMFFMediaType = void 0;
-/**
- * Tests if a buffer is in ISO base media file format (ISOBMFF) @see https://en.wikipedia.org/wiki/ISO_base_media_file_format
- * (ISOBMFF is a media container standard based on the Apple QuickTime container format)
- */
-function getISOBMFFMediaType(buffer) {
-    // Almost all ISO base media files start with `ftyp` box. (It's not required to be first, but it's recommended to be.)
-    if (!checkString(buffer, 'ftyp', 4)) {
-        return null;
-    }
-    // Extra check: test for 8859-1 printable characters (for simplicity, it's a mask which also catches one non-printable character).
-    if ((buffer[8] & 0x60) === 0x00) {
-        return null;
-    }
-    // `ftyp` box must contain a brand major identifier, which must consist of ISO 8859-1 printable characters.
-    return decodeMajorBrand(buffer);
-}
-exports.getISOBMFFMediaType = getISOBMFFMediaType;
-/**
- * brands explained @see https://github.com/strukturag/libheif/issues/83
- * code adapted from @see https://github.com/sindresorhus/file-type/blob/main/core.js#L489-L492
- */
-function decodeMajorBrand(buffer) {
-    const brandMajor = getUTF8String(buffer, 8, 12).replace('\0', ' ').trim();
-    switch (brandMajor) {
-        case 'avif':
-        case 'avis':
-            return { extension: 'avif', mimeType: 'image/avif' };
-        default:
-            return null;
-    }
-    // We don't need these now, but they are easy to add
-    // case 'mif1':
-    //   return {extension: 'heic', mimeType: 'image/heif'};
-    // case 'msf1':
-    //   return {extension: 'heic', mimeType: 'image/heif-sequence'};
-    // case 'heic':
-    // case 'heix':
-    //   return {extension: 'heic', mimeType: 'image/heic'};
-    // case 'hevc':
-    // case 'hevx':
-    //   return {extension: 'heic', mimeType: 'image/heic-sequence'};
-    // case 'qt':
-    //   return {ext: 'mov', mime: 'video/quicktime'};
-    // case 'M4V':
-    // case 'M4VH':
-    // case 'M4VP':
-    //   return {ext: 'm4v', mime: 'video/x-m4v'};
-    // case 'M4P':
-    //   return {ext: 'm4p', mime: 'video/mp4'};
-    // case 'M4B':
-    //   return {ext: 'm4b', mime: 'audio/mp4'};
-    // case 'M4A':
-    //   return {ext: 'm4a', mime: 'audio/x-m4a'};
-    // case 'F4V':
-    //   return {ext: 'f4v', mime: 'video/mp4'};
-    // case 'F4P':
-    //   return {ext: 'f4p', mime: 'video/mp4'};
-    // case 'F4A':
-    //   return {ext: 'f4a', mime: 'audio/mp4'};
-    // case 'F4B':
-    //   return {ext: 'f4b', mime: 'audio/mp4'};
-    // case 'crx':
-    //   return {ext: 'cr3', mime: 'image/x-canon-cr3'};
-    // default:
-    // if (brandMajor.startsWith('3g')) {
-    //   if (brandMajor.startsWith('3g2')) {
-    //     return {ext: '3g2', mime: 'video/3gpp2'};
-    //   }
-    //   return {ext: '3gp', mime: 'video/3gpp'};
-    // }
-    // return {ext: 'mp4', mime: 'video/mp4'};
-}
-exports.decodeMajorBrand = decodeMajorBrand;
-/** Interpret a chunk of bytes as a UTF8 string */
-function getUTF8String(array, start, end) {
-    return String.fromCharCode(...array.slice(start, end));
-}
-function stringToBytes(string) {
-    return [...string].map((character) => character.charCodeAt(0));
-}
-function checkString(buffer, header, offset = 0) {
-    const headerBytes = stringToBytes(header);
-    for (let i = 0; i < headerBytes.length; ++i) {
-        if (headerBytes[i] !== buffer[i + offset]) {
-            return false;
-        }
-    }
-    return true;
-}

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

@@ -1,69 +0,0 @@
-"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.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeImage = void 0;
-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.js

@@ -1,57 +0,0 @@
-"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.js

@@ -1,61 +0,0 @@
-"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;
-}