@loaders.gl/images 4.2.0-alpha.4 → 4.2.0-alpha.6

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

@@ -1,34 +1,43 @@
-var _globalThis$loaders;
 import { isBrowser } from '@loaders.gl/loader-utils';
-const parseImageNode = (_globalThis$loaders = globalThis.loaders) === null || _globalThis$loaders === void 0 ? void 0 : _globalThis$loaders.parseImageNode;
-const IMAGE_SUPPORTED = typeof Image !== 'undefined';
+// @ts-ignore TS2339: Property does not exist on type
+const parseImageNode = globalThis.loaders?.parseImageNode;
+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 = isBrowser ? true : NODE_IMAGE_SUPPORTED;
+/**
+ * Checks if a loaders.gl image type is supported
+ * @param type image type string
+ */
 export function isImageTypeSupported(type) {
-  switch (type) {
-    case 'auto':
-      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`);
-  }
+    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`);
+    }
 }
+/**
+ * Returns the "most performant" supported image type on this platform
+ * @returns image type string
+ */
 export function getDefaultImageType() {
-  if (IMAGE_BITMAP_SUPPORTED) {
-    return 'imagebitmap';
-  }
-  if (IMAGE_SUPPORTED) {
-    return 'image';
-  }
-  if (DATA_SUPPORTED) {
-    return 'data';
-  }
-  throw new Error('Install \'@loaders.gl/polyfills\' to parse images under Node.js');
+    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');
 }
-//# sourceMappingURL=image-type.js.map

package/dist/lib/category-api/parse-isobmff-binary.js

@@ -1,39 +1,91 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// code adapted from https://github.com/sindresorhus/file-type under MIT license
+/**
+ * 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)
+ */
 export function getISOBMFFMediaType(buffer) {
-  if (!checkString(buffer, 'ftyp', 4)) {
-    return null;
-  }
-  if ((buffer[8] & 0x60) === 0x00) {
-    return null;
-  }
-  return decodeMajorBrand(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);
 }
+/**
+ * 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
+ */
 export 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;
-  }
+    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'};
 }
+/** Interpret a chunk of bytes as a UTF8 string */
 function getUTF8String(array, start, end) {
-  return String.fromCharCode(...array.slice(start, end));
+    return String.fromCharCode(...array.slice(start, end));
 }
 function stringToBytes(string) {
-  return [...string].map(character => character.charCodeAt(0));
+    return [...string].map((character) => character.charCodeAt(0));
 }
-function checkString(buffer, header) {
-  let offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  const headerBytes = stringToBytes(header);
-  for (let i = 0; i < headerBytes.length; ++i) {
-    if (headerBytes[i] !== buffer[i + offset]) {
-      return false;
+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;
+    return true;
 }
-//# sourceMappingURL=parse-isobmff-binary.js.map

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

@@ -1,4 +1,4 @@
-import type { ImageType, ImageTypeEnum, ImageDataType } from '../../types';
+import type { ImageType, ImageTypeEnum, ImageDataType } from "../../types.js";
 export declare function isImage(image: ImageType): boolean;
 export declare function deleteImage(image: ImageType): void;
 export declare function getImageType(image: ImageType): ImageTypeEnum;

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

@@ -1 +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"}
+{"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,uBAAoB;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

@@ -1,53 +1,61 @@
 export function isImage(image) {
-  return Boolean(getImageTypeOrNull(image));
+    return Boolean(getImageTypeOrNull(image));
 }
 export function deleteImage(image) {
-  switch (getImageType(image)) {
-    case 'imagebitmap':
-      image.close();
-      break;
-    default:
-  }
+    switch (getImageType(image)) {
+        case 'imagebitmap':
+            image.close();
+            break;
+        default:
+        // Nothing to do for images and image data objects
+    }
 }
 export function getImageType(image) {
-  const format = getImageTypeOrNull(image);
-  if (!format) {
-    throw new Error('Not an image');
-  }
-  return format;
+    const format = getImageTypeOrNull(image);
+    if (!format) {
+        throw new Error('Not an image');
+    }
+    return format;
 }
 export function getImageSize(image) {
-  return getImageData(image);
+    return getImageData(image);
 }
 export function getImageData(image) {
-  switch (getImageType(image)) {
-    case 'data':
-      return image;
-    case 'image':
-    case 'imagebitmap':
-      const canvas = document.createElement('canvas');
-      const context = canvas.getContext('2d');
-      if (!context) {
-        throw new Error('getImageData');
-      }
-      canvas.width = image.width;
-      canvas.height = image.height;
-      context.drawImage(image, 0, 0);
-      return context.getImageData(0, 0, image.width, image.height);
-    default:
-      throw new Error('getImageData');
-  }
+    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');
+    }
 }
+// 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;
+    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;
 }
-//# sourceMappingURL=parsed-image-api.js.map

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

@@ -1,4 +1,4 @@
-import { ImageDataType } from '../../types';
+import { ImageDataType } from "../../types.js";
 /**
  * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"encode-image.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-image.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAM1C;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,aAAa,EACpB,OAAO,CAAC,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,GAC7B,OAAO,CAAC,WAAW,CAAC,CAOtB"}
+{"version":3,"file":"encode-image.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-image.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,aAAa,EAAC,uBAAoB;AAM1C;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,aAAa,EACpB,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

@@ -1,61 +1,77 @@
-var _globalThis$loaders;
 import { getImageSize } from "../category-api/parsed-image-api.js";
-const encodeImageNode = (_globalThis$loaders = globalThis.loaders) === null || _globalThis$loaders === void 0 ? void 0 : _globalThis$loaders.encodeImageNode;
+// @ts-ignore TS2339: Property does not exist on type
+const encodeImageNode = globalThis.loaders?.encodeImageNode;
+/**
+ * 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
+ */
 export async function encodeImage(image, options) {
-  options = options || {};
-  options.image = options.image || {};
-  return encodeImageNode ? encodeImageNode(image, {
-    type: options.image.mimeType
-  }) : encodeImageInBrowser(image, options);
+    options = options || {};
+    options.image = options.image || {};
+    return encodeImageNode
+        ? encodeImageNode(image, { type: options.image.mimeType })
+        : encodeImageInBrowser(image, options);
 }
+// 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
-  } = getImageSize(image);
-  const canvas = document.createElement('canvas');
-  canvas.width = width;
-  canvas.height = height;
-  drawImageToCanvas(image, canvas);
-  const blob = await new Promise(resolve => {
-    if (jpegQuality && qualityParamSupported) {
-      try {
-        canvas.toBlob(resolve, mimeType, jpegQuality);
-        return;
-      } catch (error) {
-        qualityParamSupported = false;
-      }
+    const { mimeType, jpegQuality } = options.image;
+    const { width, height } = 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');
     }
-    canvas.toBlob(resolve, mimeType);
-  });
-  if (!blob) {
-    throw new Error('image encoding failed');
-  }
-  return await blob.arrayBuffer();
+    return await blob.arrayBuffer();
 }
-function drawImageToCanvas(image, canvas) {
-  let x = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  let y = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-  if (x === 0 && y === 0 && typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
-    const context = canvas.getContext('bitmaprenderer');
-    if (context) {
-      context.transferFromImageBitmap(image);
-      return canvas;
+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;
+        }
     }
-  }
-  const context = canvas.getContext('2d');
-  if (image.data) {
-    const clampedArray = new Uint8ClampedArray(image.data);
-    const imageData = new ImageData(clampedArray, image.width, image.height);
-    context.putImageData(imageData, 0, 0);
+    // 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;
-  }
-  context.drawImage(image, 0, 0);
-  return canvas;
 }
-//# sourceMappingURL=encode-image.js.map

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

@@ -1,5 +1,5 @@
 import type { LoaderContext } from '@loaders.gl/loader-utils';
-import type { ImageType } from '../../types';
-import type { ImageLoaderOptions } from '../../image-loader';
+import type { ImageType } from "../../types.js";
+import type { ImageLoaderOptions } from "../../image-loader.js";
 export declare 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

@@ -1 +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,wBAAsB,UAAU,CAC9B,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,kBAAkB,EAC5B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,SAAS,CAAC,CAkCpB"}
+{"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,uBAAoB;AAC3C,OAAO,KAAK,EAAC,kBAAkB,EAAC,8BAA2B;AAS3D,wBAAsB,UAAU,CAC9B,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

@@ -4,41 +4,48 @@ import { getImageData } from "../category-api/parsed-image-api.js";
 import { parseToImage } from "./parse-to-image.js";
 import { parseToImageBitmap } from "./parse-to-image-bitmap.js";
 import { parseToNodeImage } from "./parse-to-node-image.js";
+// Parse to platform defined image type (data on node, ImageBitmap or HTMLImage on browser)
+// eslint-disable-next-line complexity
 export async function parseImage(arrayBuffer, options, context) {
-  options = options || {};
-  const imageOptions = options.image || {};
-  const imageType = imageOptions.type || 'auto';
-  const {
-    url
-  } = context || {};
-  const loadType = getLoadableImageType(imageType);
-  let image;
-  switch (loadType) {
-    case 'imagebitmap':
-      image = await parseToImageBitmap(arrayBuffer, options, url);
-      break;
-    case 'image':
-      image = await parseToImage(arrayBuffer, options, url);
-      break;
-    case 'data':
-      image = await parseToNodeImage(arrayBuffer, options);
-      break;
-    default:
-      assert(false);
-  }
-  if (imageType === 'data') {
-    image = getImageData(image);
-  }
-  return image;
+    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 parseToImageBitmap(arrayBuffer, options, url);
+            break;
+        case 'image':
+            image = await parseToImage(arrayBuffer, options, url);
+            break;
+        case 'data':
+            // Node.js loads imagedata directly
+            image = await parseToNodeImage(arrayBuffer, options);
+            break;
+        default:
+            assert(false);
+    }
+    // Browser: if options.image.type === 'data', we can now extract data from the loaded image
+    if (imageType === 'data') {
+        image = getImageData(image);
+    }
+    return image;
 }
+// Get a loadable image type from image type
 function getLoadableImageType(type) {
-  switch (type) {
-    case 'auto':
-    case 'data':
-      return getDefaultImageType();
-    default:
-      isImageTypeSupported(type);
-      return 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 getDefaultImageType();
+        default:
+            // Throw an error if not supported
+            isImageTypeSupported(type);
+            return type;
+    }
 }
-//# sourceMappingURL=parse-image.js.map

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

@@ -1,4 +1,4 @@
-import type { ImageLoaderOptions } from '../../image-loader';
+import type { ImageLoaderOptions } from "../../image-loader.js";
 /**
  * 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

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

@@ -1 +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,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,kBAAkB,EAC3B,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,WAAW,CAAC,CAgBtB"}
+{"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,8BAA2B;AAQ3D;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,kBAAkB,EAC3B,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,WAAW,CAAC,CAgBtB"}