@loaders.gl/images 3.1.0-alpha.2 → 3.1.0-beta.1

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

@@ -1,64 +1,69 @@
-export function isImage(image) {
-  return Boolean(getImageTypeOrNull(image));
+"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));
 }
-export function deleteImage(image) {
-  switch (getImageType(image)) {
-    case 'imagebitmap':
-      image.close();
-      break;
-
-    default:
-  }
+exports.isImage = isImage;
+function deleteImage(image) {
+    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;
+exports.deleteImage = deleteImage;
+function getImageType(image) {
+    const format = getImageTypeOrNull(image);
+    if (!format) {
+        throw new Error('Not an image');
+    }
+    return format;
 }
-export function getImageSize(image) {
-  return getImageData(image);
+exports.getImageType = getImageType;
+function getImageSize(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');
-  }
+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;
+    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

@@ -0,0 +1,12 @@
+/**
+ * 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 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

@@ -1,70 +1,82 @@
-import { global } from '../utils/globals';
-import { getImageSize } from '../category-api/parsed-image-api';
-const {
-  _encodeImageNode
-} = global;
-export async function encodeImage(image, options) {
-  options = options || {};
-  options.image = options.image || {};
-  return _encodeImageNode ? _encodeImageNode(image, {
-    type: options.image.mimeType
-  }) : encodeImageInBrowser(image, options);
+"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
-  } = 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 } = (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');
     }
-
-    canvas.toBlob(resolve, mimeType);
-  });
-
-  if (!blob) {
-    throw new Error('image encoding failed');
-  }
-
-  return await blob.arrayBuffer();
+    return await blob.arrayBuffer();
 }
-
 function drawImageToCanvas(image, canvas, x = 0, y = 0) {
-  if (x === 0 && y === 0 && typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
-    const context = canvas.getContext('bitmaprenderer');
-
-    if (context) {
-      context.transferFromImageBitmap(image);
-      return canvas;
+    // 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

@@ -0,0 +1,5 @@
+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

@@ -1,52 +1,57 @@
-import { assert } from '../utils/assert';
-import { isImageTypeSupported, getDefaultImageType } from '../category-api/image-type';
-import { getImageData } from '../category-api/parsed-image-api';
-import parseToImage from './parse-to-image';
-import parseToImageBitmap from './parse-to-image-bitmap';
-import parseToNodeImage from './parse-to-node-image';
-export default 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;
+"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':
-      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 (0, image_type_1.getDefaultImageType)();
+        default:
+            // Throw an error if not supported
+            (0, image_type_1.isImageTypeSupported)(type);
+            return type;
+    }
 }
-//# sourceMappingURL=parse-image.js.map

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

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

@@ -1,43 +1,61 @@
-import { isSVG, getBlob } from './svg-utils';
-import parseToImage from './parse-to-image';
+"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;
-export default async function parseToImageBitmap(arrayBuffer, options, url) {
-  let blob;
-
-  if (isSVG(url)) {
-    const image = await parseToImage(arrayBuffer, options, url);
-    blob = image;
-  } else {
-    blob = getBlob(arrayBuffer, url);
-  }
-
-  const imagebitmapOptions = options && options.imagebitmap;
-  return await safeCreateImageBitmap(blob, imagebitmapOptions);
+/**
+ * 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 {
-      return await createImageBitmap(blob, imagebitmapOptions);
-    } catch (error) {
-      console.warn(error);
-      imagebitmapOptionsSupported = false;
+    if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+        imagebitmapOptions = null;
     }
-  }
-
-  return await createImageBitmap(blob);
+    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) {
-  for (const key in object || EMPTY_OBJECT) {
-    return false;
-  }
-
-  return true;
+    // @ts-ignore
+    for (const key in object || EMPTY_OBJECT) {
+        return false;
+    }
+    return true;
 }
-//# sourceMappingURL=parse-to-image-bitmap.js.map

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

@@ -0,0 +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

@@ -1,34 +1,47 @@
-import { getBlobOrSVGDataUrl } from './svg-utils';
-export default async function parseToImage(arrayBuffer, options, url) {
-  const blobOrDataUrl = 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);
+"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);
+        }
     }
-  }
 }
-export async function loadToImage(url, options) {
-  const image = new Image();
-  image.src = url;
-
-  if (options.image && options.image.decode && image.decode) {
-    await image.decode();
-    return image;
-  }
-
-  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.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);
+        }
+    });
 }
-//# sourceMappingURL=parse-to-image.js.map
+exports.loadToImage = loadToImage;

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

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